## 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 : ```bash 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. ```bash 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 : ```bash 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 : ```bash 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 : ```bash 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` : ```bash 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 : ```bash 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 : ```bash 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 : ```bash 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"` : ```bash 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 : ```bash 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 : ```yaml 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 stats` pour 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 : ```bash 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-.scope/`. Trouvez l’ID du conteneur avec `docker ps --no-trunc`. Ensuite, vérifiez : ```bash cat /sys/fs/cgroup/system.slice/docker-.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 : ```bash cat /sys/fs/cgroup/system.slice/docker-.scope/memory.max ``` Sortie : ``` 536870912 ``` ### Surveiller les statistiques d’exécution Utilisez `docker stats` pour observer l’utilisation des ressources en direct : ```bash 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 : ```bash cat /sys/fs/cgroup/system.slice/docker-.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 : ```bash 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 : ```bash 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` : ```bash 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 : ```bash 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 : ```bash 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é : ```bash 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 : ```bash 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 update` pour 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}}' ` | Propriétaire de l’application | Après les incidents | | Vérifier les limites dans la configuration | `docker inspect --format '{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}' ` | 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.json` en utilisant `default-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 stats` dans 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.