E-NO
DevOps 10 min de lecture

Limites de ressources Docker : erreurs de configuration et correctifs pratiques

calendar_today Publié : 2026-11-16
update Dernière mise à jour : 2026-11-16
analytics Efficacité SEO : 100%
Illustration du guide technique pour « Limites de ressources Docker : erreurs de configuration et correctifs pratiques ».

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.

Question rapide 1 sur 2

Selon le passage, que se passe-t-il lorsqu'un conteneur dépasse sa limite de mémoire ?

Le passage indique que si un conteneur dépasse sa limite de mémoire, le OOM killer du noyau met fin au processus.

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 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 :

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 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.

Question rapide 2 sur 2

Quel est l'effet d'utiliser l'option --cpuset-cpus sans utiliser également --cpus ?

Le passage indique qu'utiliser --cpuset-cpus sans --cpus permet toujours au conteneur d'utiliser 100 % des cœurs épinglés.

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âcheCommande ou actionPropriétaireFréquence
Examiner l’utilisation des ressources des conteneursdocker stats --no-streamSRE de gardeHebdomadaire
Vérifier les kills OOMdocker inspect --format '{{.State.OOMKilled}}' <conteneur>Propriétaire de l’applicationAprès les incidents
Vérifier les limites dans la configurationdocker inspect --format '{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}' <conteneur>Responsable DevOpsMensuel
Auditer l’étranglementVérifier nr_throttled de cpu.stat par conteneurIngénieur performanceMensuel
Mettre à jour les limites en fonction des tendancesAjuster --cpus et --memory si nécessairePropriétaire du serviceTrimestriel
Tester le comportement OOM en stagingExécuter un test de stress mémoire en non-productionResponsable QAAvant les versions majeures
Documenter les limites dans la CMDBTenir un registre des allocations de ressourcesGestionnaire de configurationEn 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.

Recherches connexes

Score de qualité de l’article

Utilité pour le lecteur 100%
  • check_circle Guide prêt à lire
  • check_circle Exemples pratiques inclus
  • check_circle URL d’article optimisée pour le SEO