Introduction
Les conteneurs Docker partagent le noyau de l’hôte et, par défaut, peuvent consommer autant de CPU et de mémoire que l’hôte le permet. Sans limites de ressources explicites, un seul conteneur peut affamer les autres conteneurs ou même le système d’exploitation hôte, entraînant une dégradation des performances ou des pannes. La configuration de limites de ressources est essentielle pour des performances prévisibles et une stabilité, mais de nombreuses équipes commettent des erreurs qui soit ne parviennent pas à imposer les limites, soit sur-restreignent les conteneurs, provoquant des plantages ou un mauvais comportement.
Ce guide passe en revue les erreurs courantes de configuration des limites de ressources Docker, montre comment définir correctement les limites avec des exemples pratiques et fournit des flux de validation, de retour en arrière et de dépannage. En suivant ces étapes, vous éviterez les problèmes de contention des ressources et garantirez le fonctionnement fiable de vos conteneurs en production.
Inventaire des versions et de l’environnement
Avant d’appliquer des limites de ressources, documentez votre version de Docker, la configuration de l’hôte et la topologie des conteneurs. Cet inventaire aide à reproduire les problèmes et à comprendre l’impact des modifications.
Vérifier la version et les informations de Docker
Exécutez les commandes suivantes pour vérifier la version de Docker et les détails du serveur :
docker version
La sortie attendue inclut les versions client et serveur. Par exemple :
Client: Docker Engine - Community
Version: 24.0.7
API version: 1.43
Go version: go1.20.10
Git commit: afdd53b
Built: Thu Oct 26 09:08:17 2023
OS/Arch: linux/amd64
Context: default
Server: Docker Engine - Community
Engine:
Version: 24.0.7
Confirmez que votre version de Docker prend en charge les indicateurs de limite de ressources (--cpus, --memory). Ces indicateurs sont disponibles depuis Docker 1.13 et versions ultérieures. Si vous utilisez une version plus ancienne, mettez à niveau d’abord.
docker info
Vérifiez le pilote cgroup et la version cgroup dans la sortie. Les limites de ressources reposent sur les cgroups. Extrait d’exemple :
Cgroup Driver: systemd
Cgroup Version: 2
Inventaire des ressources de l’hôte
Listez le CPU et la mémoire de l’hôte pour comprendre la capacité disponible :
lscpu | grep -E '^CPU\(s\):|^Model name'
free -h
Exemple de sortie :
CPU(s): 8
Model name: Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz
total used free shared buff/cache available
Mem: 31Gi 2.1Gi 27Gi 123Mi 1.6Gi 28Gi
Swap: 2.0Gi 0B 2.0Gi
Topologie des conteneurs
Listez les conteneurs en cours d’exécution et leur utilisation actuelle des ressources :
docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}"
docker stats --no-stream
docker stats affiche l’utilisation du CPU et de la mémoire par conteneur. Cette base de référence aide à décider des limites appropriées.
Prérequis
- Docker Engine avec cgroups v1 ou v2 activés.
- Accès root ou sudo à l’hôte Docker pour appliquer les limites.
- Un environnement de test pour valider les modifications avant la production.
Chemin de configuration sûr
Définir des limites de ressources de manière incorrecte peut nuire aux performances ou entraîner la terminaison des conteneurs. Suivez une approche ciblée : commencez avec un seul conteneur dans un environnement de test, mesurez son comportement, puis ajustez progressivement.
Erreur courante n°1 : Ne définir aucune limite
Sans limites, un conteneur peut consommer tout le CPU et toute la mémoire. Pour définir des limites pour un nouveau conteneur :
docker run -d --name web --cpus="1.5" --memory="512m" nginx
Cette commande restreint le conteneur à 1,5 cœur de CPU et 512 Mo de mémoire.
Erreur courante n°2 : Mal comprendre les limites CPU
L’utilisation de --cpus définit un quota sur le temps CPU. Par exemple, --cpus="1.5" limite le conteneur à 150 % d’un cœur de CPU. Si vous devez épingler à des cœurs spécifiques, utilisez --cpuset-cpus :
docker run -d --name cpu-pinned --cpuset-cpus="0-1" nginx
Cependant, l’utilisation de --cpuset-cpus sans --cpus permet toujours au conteneur d’utiliser 100 % des cœurs épinglés. Combinez les deux pour un contrôle strict :
docker run -d --name cpu-limited --cpus="1.0" --cpuset-cpus="0-1" nginx
Cela limite à l’équivalent d’un CPU de temps sur les cœurs 0 et 1.
Erreur courante n°3 : Définir une limite de mémoire trop basse
Si un conteneur dépasse sa limite de mémoire, le tueur OOM (out-of-memory) du noyau termine le processus. Définissez les limites de mémoire en fonction de l’utilisation réelle avec une marge. Utilisez --memory-reservation comme limite douce que Docker utilise pour l’ordonnancement mais qui ne déclenche pas de terminaison forcée :
docker run -d --name app --memory="1g" --memory-reservation="750m" myapp
Cela définit une limite stricte de 1 Go et une réservation douce de 750 Mo.
Erreur courante n°4 : Oublier les limites de swap
Par défaut, un conteneur peut utiliser autant de swap que l’hôte en a de disponible. Pour contrôler le swap, définissez --memory-swap en conjonction avec --memory. Par exemple, pour n’autoriser aucun swap :
docker run -d --name no-swap --memory="512m" --memory-swap="512m" myapp
Ici, --memory-swap est égal à --memory, donc aucun swap n’est autorisé. Pour autoriser 1 Go au total (mémoire + swap), définissez --memory-swap="1g" :
docker run -d --name with-swap --memory="512m" --memory-swap="1g" myapp
Erreur courante n°5 : Définir les limites uniquement au démarrage du conteneur
Les limites peuvent également être définies dans Docker Compose ou via une mise à jour. Pour les conteneurs existants, vous pouvez mettre à jour les limites avec :
docker update --cpus="2.0" --memory="1g" web
Remarque : Vous ne pouvez pas mettre à jour --memory-swap sur un conteneur en cours d’exécution ; vous devez le recréer.
Exemple Docker Compose
Dans docker-compose.yml, spécifiez les limites sous deploy.resources.limits (pour Swarm) ou mem_limit et cpus (pour Compose v2/v3). Utilisez la syntaxe suivante pour Compose v3 compatible Swarm :
version: '3.8'
services:
web:
image: nginx
deploy:
resources:
limits:
cpus: '1.5'
memory: 512M
reservations:
cpus: '0.5'
memory: 256M
Déployez avec docker stack deploy -c docker-compose.yml mystack si vous utilisez Swarm, ou utilisez docker compose up (Compose v2) qui respecte également ces limites.
Implémentation sûre étape par étape
- Mesurer la base de référence : Exécutez le conteneur sans limites et surveillez
docker statspour l’utilisation typique et maximale. - Appliquer des limites prudentes : Commencez avec des limites de 20 à 30 % supérieures au pic observé.
- Test de charge : Simulez un trafic réaliste et surveillez l’étranglement ou les kills OOM.
- Ajuster progressivement : Augmentez ou diminuez les limites en fonction du comportement observé.
- Documenter et versionner : Stockez la configuration dans Docker Compose ou des manifestes Kubernetes.
Vérification et diagnostics
Après avoir défini les limites, vérifiez qu’elles sont appliquées et diagnostiquez tout problème.
Inspecter la configuration du conteneur
Utilisez docker inspect pour voir les limites appliquées :
docker inspect web --format '{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}'
Par exemple, sortie :
1500000000 536870912
NanoCpus est en milliardièmes de CPU (1,5 x 1e9 = 1500000000), et Memory est en octets (512 Mo = 536870912).
Vérifier directement les limites cgroup
Accédez aux fichiers cgroup du conteneur sur l’hôte. Pour cgroup v2, le chemin est /sys/fs/cgroup/system.slice/docker-<container-id>.scope/. Trouvez l’ID du conteneur avec docker ps --no-trunc. Ensuite, vérifiez :
cat /sys/fs/cgroup/system.slice/docker-<container-id>.scope/cpu.max
Exemple de sortie pour une limite de 1,5 CPU :
150000 100000
Cela signifie que le conteneur peut utiliser 150000 microsecondes de temps CPU par période de 100000 microsecondes.
Pour la mémoire :
cat /sys/fs/cgroup/system.slice/docker-<container-id>.scope/memory.max
Sortie :
536870912
Surveiller les statistiques d’exécution
Utilisez docker stats pour observer l’utilisation des ressources en direct :
docker stats web
La sortie inclut le pourcentage CPU et MEM USAGE / LIMIT. Vérifiez que MEM USAGE reste en dessous de la limite.
Tester l’étranglement CPU
Pour voir si le CPU est étranglé, vérifiez le compteur nr_throttled dans le cgroup :
cat /sys/fs/cgroup/system.slice/docker-<container-id>.scope/cpu.stat | grep nr_throttled
Si la valeur augmente, le conteneur atteint sa limite CPU et est étranglé. Envisagez d’augmenter la limite.
Tester l’OOM mémoire
Dépassez délibérément la limite de mémoire pour voir le comportement OOM. Exécutez un conteneur avec une petite limite de mémoire et une commande qui alloue de la mémoire :
docker run --rm --memory="50m" alpine sh -c 'tail /dev/zero'
Cette commande lit /dev/zero indéfiniment, consommant de la mémoire. Après quelques secondes, le tueur OOM du noyau terminera le processus. Vérifiez le code de sortie du conteneur :
docker run --rm --memory="50m" alpine sh -c 'tail /dev/zero'; echo $?
Le code de sortie attendu est 137 (128 + 9, SIGKILL), indiquant un kill OOM.
Modes de défaillance et récupération
Les limites de ressources peuvent provoquer des défaillances si elles sont mal configurées. Comprenez les modes de défaillance courants et comment récupérer.
Mode de défaillance 1 : Conteneur tué par OOM
Symptôme : Le conteneur s’arrête de manière inattendue, code de sortie 137, les journaux montrent un kill OOM.
Diagnostic : Vérifiez docker inspect pour State.OOMKilled :
docker inspect web --format '{{.State.OOMKilled}}'
Si true, le conteneur a dépassé sa limite de mémoire.
Récupération : Augmentez la limite de mémoire ou réduisez l’utilisation de la mémoire. Mettez à jour la limite :
docker update --memory="1g" web
Si le conteneur a planté, redémarrez-le avec des paramètres corrigés.
Mode de défaillance 2 : Famine CPU
Symptôme : L’application est lente, latence élevée, mais l’utilisation du CPU sur l’hôte n’est pas maximale. nr_throttled augmente.
Diagnostic : Vérifiez l’étranglement CPU du cgroup comme indiqué précédemment.
Récupération : Augmentez la limite CPU :
docker update --cpus="2.0" web
Mode de défaillance 3 : Configuration de swap incorrecte
Symptôme : Le conteneur utilise un swap excessif, provoquant des E/S disque et un ralentissement.
Diagnostic : Vérifiez l’utilisation du swap dans docker stats (si disponible) ou dans le cgroup memory.swap.current.
Récupération : Recréez le conteneur avec --memory-swap approprié :
docker stop web && docker rm web
docker run -d --name web --memory="512m" --memory-swap="512m" nginx
Mode de défaillance 4 : Limite non appliquée
Symptôme : Le conteneur utilise plus de ressources que prévu, docker inspect ne montre aucune limite.
Cause : Limites spécifiées dans un fichier compose mais non appliquées en raison de l’utilisation de docker-compose up avec des champs non pris en charge, ou oubli de déployer la pile.
Diagnostic : Inspectez le conteneur en cours d’exécution :
docker inspect web --format '{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}'
Si les valeurs sont 0 0, aucune limite n’est définie.
Récupération : Appliquez les limites explicitement via docker update ou recréez avec les indicateurs corrects.
Bonnes pratiques de retour en arrière et de récupération
- Conservez la configuration dans un système de contrôle de version.
- Utilisez
docker updatepour des changements rapides de limites sans recréer le conteneur. - Pour les changements de swap, recréez le conteneur avec un script ou un fichier compose.
- Testez le retour en arrière en restaurant les limites précédentes et en vérifiant avec
docker stats.
Pièges courants et comment les éviter
Outre les erreurs déjà décrites, voici des pièges supplémentaires qui piègent souvent les équipes :
Piège n°1 : Ignorer les métriques d’étranglement CPU
De nombreuses équipes définissent des limites CPU mais ne vérifient jamais si le conteneur est étranglé. L’étranglement peut provoquer des pics de latence même si l’utilisation du CPU semble inférieure à la limite. Pourquoi cela arrive : Le conteneur atteint le quota CPU dans une période d’ordonnancement et est forcé d’attendre. Comment éviter : Surveillez régulièrement nr_throttled dans le cgroup cpu.stat. S’il augmente sous charge normale, augmentez la limite CPU ou ajustez la période (avancé).
Piège n°2 : Ne pas définir de réservation de mémoire
Une limite stricte de mémoire seule peut entraîner un swapping agressif ou des kills OOM sous pression mémoire. Pourquoi cela arrive : Le noyau peut récupérer des pages du conteneur, provoquant une dégradation des performances avant que la limite stricte ne soit atteinte. Comment éviter : Définissez un --memory-reservation inférieur à la limite stricte pour signaler une frontière plus douce. Cela aide le noyau à prendre de meilleures décisions.
Piège n°3 : Surallouer les ressources de l’hôte
Si la somme des limites des conteneurs dépasse la capacité de l’hôte, l’hôte peut devenir instable. Pourquoi cela arrive : Les équipes supposent que les limites sont des réservations, mais ce ne sont que des plafonds ; les conteneurs peuvent encore se faire concurrence pour les ressources. Comment éviter : Utilisez docker stats et la surveillance de l’hôte pour vous assurer que les limites totales ne dépassent pas 80 à 90 % de la capacité de l’hôte. Laissez une marge pour le système d’exploitation hôte et les démons système.
Piège n°4 : Oublier de mettre à jour les fichiers Compose
Après avoir ajusté manuellement les limites avec docker update, les équipes oublient de mettre à jour le fichier compose source de vérité. Pourquoi cela arrive : Les corrections rapides en production entraînent une dérive de configuration. Comment éviter : Mettez toujours à jour le fichier compose ou le manifeste d’abord, puis appliquez les modifications via un pipeline de déploiement. Utilisez le contrôle de version pour suivre les changements.
Liste de contrôle opérationnelle
Utilisez cette liste de contrôle pour la gestion continue des limites de ressources Docker. Attribuez un seul propriétaire (par exemple, ingénieur DevOps) pour chaque tâche récurrente et la fréquence de revue.
| Tâche | Commande ou action | Propriétaire | Fréquence |
|---|---|---|---|
| Examiner l’utilisation des ressources des conteneurs | docker stats --no-stream | SRE de garde | Hebdomadaire |
| Vérifier les kills OOM | docker inspect --format '{{.State.OOMKilled}}' <conteneur> | Propriétaire de l’application | Après les incidents |
| Vérifier les limites dans la configuration | docker inspect --format '{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}' <conteneur> | Responsable DevOps | Mensuel |
| Auditer l’étranglement | Vérifier nr_throttled de cpu.stat par conteneur | Ingénieur performance | Mensuel |
| Mettre à jour les limites en fonction des tendances | Ajuster --cpus et --memory si nécessaire | Propriétaire du service | Trimestriel |
| Tester le comportement OOM en staging | Exécuter un test de stress mémoire en non-production | Responsable QA | Avant les versions majeures |
| Documenter les limites dans la CMDB | Tenir un registre des allocations de ressources | Gestionnaire de configuration | En continu |
Considérations supplémentaires
- Définir des limites par défaut pour le démon : Vous pouvez configurer certaines limites de ressources par défaut dans
/etc/docker/daemon.jsonen utilisantdefault-ulimits, mais les valeurs par défaut de CPU et de mémoire ne sont pas directement prises en charge. Utilisez des politiques d’orchestration ou des modèles pour imposer des valeurs par défaut. - Utiliser les fonctionnalités de l’orchestrateur : Si vous utilisez Kubernetes, définissez les demandes et limites de ressources dans les spécifications de pod. Pour Docker Swarm, utilisez les contraintes de service et les réservations de ressources.
- Surveiller avec des outils : Intégrez la sortie de
docker statsdans des systèmes de surveillance comme Prometheus via cAdvisor ou node exporter pour des alertes sur l’utilisation des ressources et l’étranglement.
Conclusion
Configurer les limites de ressources Docker est une pratique essentielle pour maintenir les performances et la stabilité. En comprenant les erreurs courantes telles que négliger les limites, mal comprendre la sémantique du CPU, définir une mémoire trop basse et ignorer le swap, vous éviterez les problèmes de production. Le chemin de configuration sûr consiste à mesurer l’utilisation de base, appliquer des limites prudentes, effectuer des tests de charge et ajuster progressivement. La vérification via docker inspect, les fichiers cgroup et docker stats garantit que les limites sont efficaces. En cas de défaillance, une récupération rapide est possible avec docker update ou la recréation du conteneur. Enfin, une liste de contrôle opérationnelle avec une propriété claire et des fréquences de revue aide à maintenir la gestion des ressources cohérente dans le temps.
Commencez avec un conteneur, appliquez les exemples de ce guide et mesurez l’impact. Ensuite, étendez à l’ensemble de votre flotte en toute confiance.