Introduction
Les profils Docker Compose permettent de définir plusieurs configurations de services dans un seul fichier compose et d’activer uniquement les services nécessaires pour un environnement ou une tâche donnée. Cependant, à mesure que les projets se développent, une sélection de profils inadéquate peut entraîner une surallocation des ressources, des temps de démarrage lents et des configurations réseau confuses. L’optimisation des performances avec les profils ne se résume pas à l’activation et la désactivation de services ; elle exige une planification délibérée des ressources et des flux de travail de vérification.
Dans ce guide, nous adoptons une approche pratique pour optimiser les profils Docker Compose afin d’améliorer les performances. Nous aborderons les vérifications de version, les modifications de configuration sûres, les diagnostics, la récupération après échec et une liste de contrôle opérationnelle. À la fin, vous disposerez d’un processus reproductible pour garder vos environnements Compose multi-profils légers et rapides.
Inventaire des versions et de l’environnement
Avant d’apporter des modifications, établissez un inventaire clair de vos versions de Docker et Compose, des ressources de l’hôte et de l’utilisation actuelle des profils. Cette base de référence éclaire les décisions de dimensionnement et aide à détecter les régressions ultérieures.
Étape 1 : Vérifier les versions de Docker et Compose
Exécutez les commandes suivantes pour confirmer vos versions :
docker --version
# Docker version 24.0.7, build afdd53b
docker compose version
# Docker Compose version v2.21.0
Docker Compose v2 est requis pour la prise en charge des profils. Si vous utilisez une version antérieure, effectuez une mise à niveau avant de continuer. Les profils ont été introduits dans le format de fichier Compose 3.5 et versions ultérieures ; assurez-vous donc que votre fichier compose déclare une clé de version compatible ou, mieux encore, omettez-la entièrement selon la spécification Compose.
Étape 2 : Inventorier l’allocation actuelle des ressources
Utilisez docker stats pour voir l’utilisation en direct des ressources de vos conteneurs en cours d’exécution :
docker stats --no-stream
# CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
# 2f1d4a7b9c0e myapp_web_1 0.50% 120MiB / 7.77GiB 1.51% 1.2kB / 0B 0B / 0B 10
# 5e8f6d2b1a3d myapp_db_1 1.20% 450MiB / 7.77GiB 5.66% 6.8kB / 0B 20MB / 0B 25
Notez la colonne des limites de mémoire. Si aucune limite n’est définie, le conteneur peut consommer autant de mémoire que l’hôte le permet, ce qui peut affamer d’autres services. Nous utiliserons ces chiffres plus tard lors de la définition de contraintes de ressources explicites.
Étape 3 : Identifier les profils actifs
Listez les profils actuellement actifs en inspectant votre projet compose :
docker compose ls
# NAME STATUS CONFIG FILES
# myapp running(3) /home/user/myapp/docker-compose.yml
Pour voir quels services sont réellement en cours d’exécution et leurs profils, utilisez :
docker compose ps
# NAME COMMAND SERVICE STATUS PORTS
# myapp_web_1 "nginx -g 'daemon ..." web running 0.0.0.0:8080->80/tcp
# myapp_db_1 "docker-entrypoint.s..." db running 5432/tcp
# myapp_worker_1 "celery -A app worker" worker running
Si un service n’est pas listé, il peut être affecté à un profil non activé. Vérifiez votre fichier compose pour les attributs profiles: sous chaque service.
Chemin de configuration sûr
L’optimisation des performances avec les profils implique trois leviers principaux : choisir les services à activer, dimensionner les ressources de chaque service et optimiser les interactions réseau. Apportez toujours des modifications incrémentales et testez après chaque ajustement.
Étape 1 : Examiner les définitions de profils
Ouvrez votre docker-compose.yml et notez quels services appartiennent à quels profils. Par exemple :
services:
web:
image: nginx:1.25
profiles: ["frontend"]
ports:
- "8080:80"
depends_on:
- api
api:
build: ./api
profiles: ["backend"]
environment:
DATABASE_URL: postgres://db:5432/app
depends_on:
- db
db:
image: postgres:16
profiles: ["backend"]
volumes:
- db_data:/var/lib/postgresql/data
worker:
build: ./worker
profiles: ["backend"]
depends_on:
- db
adminer:
image: adminer:4
profiles: ["debug"]
ports:
- "8081:8080"
Ici, web fait partie du profil frontend, api, db et worker font partie de backend, et adminer fait partie de debug. Lorsque vous exécutez docker compose --profile backend up, seuls les services backend démarrent. Si vous omettez --profile, seuls les services sans clé profiles démarrent (dans cet exemple, aucun).
Étape 2 : Activer uniquement les profils requis
Pour des tests de performances de type production, activez uniquement les profils nécessaires à votre charge de travail. Par exemple, pour tester le backend sans le frontend web :
docker compose --profile backend up -d
# [+] Running 3/3
# ✔ Container myapp_db_1 Started
# ✔ Container myapp_api_1 Started
# ✔ Container myapp_worker_1 Started
Évitez d’activer le profil debug lors des tests de performances, car des outils supplémentaires comme Adminer peuvent consommer du CPU et de la mémoire et exposer des ports inutiles.
Étape 3 : Définir des limites de ressources
Les conteneurs sans limites peuvent monopoliser les ressources de l’hôte. Ajoutez deploy.resources.limits (Compose v2) ou mem_limit / cpus (v1) pour contraindre chaque service. Exemple pour le service de base de données :
db:
image: postgres:16
profiles: ["backend"]
volumes:
- db_data:/var/lib/postgresql/data
deploy:
resources:
limits:
cpus: '2.0'
memory: 1G
reservations:
cpus: '0.5'
memory: 256M
Après avoir mis à jour le fichier, recréez les conteneurs :
docker compose --profile backend up -d --force-recreate
# [+] Running 3/3
# ✔ Container myapp_db_1 Recreated
# ✔ Container myapp_api_1 Recreated
# ✔ Container myapp_worker_1 Recreated
Vérifiez que les limites sont appliquées :
docker inspect myapp_db_1 --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}}'
# 1073741824 2000000000
La mémoire est en octets (1 Go = 1073741824) et NanoCpus correspond à 2 CPU (2 000 000 000 nanosecondes par seconde).
Étape 4 : Optimiser la disposition du réseau
Les profils peuvent créer par inadvertance des réseaux séparés lorsque les services sont répartis. Par défaut, Compose crée un réseau par défaut pour le projet, et tous les services (quel que soit le profil) s’y attachent, sauf si vous définissez des réseaux personnalisés. Pour réduire les sauts réseau et améliorer le débit, définissez des réseaux explicites et attachez les services en conséquence. Par exemple :
networks:
frontend_net:
driver: bridge
backend_net:
driver: bridge
services:
web:
profiles: ["frontend"]
networks:
- frontend_net
api:
profiles: ["backend"]
networks:
- frontend_net
- backend_net
db:
profiles: ["backend"]
networks:
- backend_net
worker:
profiles: ["backend"]
networks:
- backend_net
Cela garantit que web peut atteindre api via frontend_net, tandis que api communique avec db et worker sur backend_net. La base de données est isolée du frontend, réduisant la surface d’attaque et le trafic de diffusion inutile.
Après avoir modifié les réseaux, recréez les services concernés :
docker compose --profile frontend --profile backend up -d --force-recreate
Étape 5 : Ajuster les dépendances et les healthchecks
Les dépendances inutiles peuvent retarder le démarrage. Utilisez depends_on avec condition: service_healthy uniquement lorsque cela est vraiment nécessaire. Par exemple, le service api peut avoir besoin que la base de données soit prête. Définissez un healthcheck pour db :
db:
image: postgres:16
profiles: ["backend"]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 5s
timeout: 5s
retries: 5
Puis dans api :
api:
profiles: ["backend"]
depends_on:
db:
condition: service_healthy
Cela empêche api de démarrer avant que la base de données ne soit prête, évitant des tentatives de connexion échouées qui ajoutent de la latence.
Vérification et diagnostics
Après avoir appliqué les modifications, vérifiez que les performances s’améliorent et qu’aucune régression ne se produit. Utilisez des commandes concrètes et des sorties attendues.
Mesurer le temps de démarrage d’un conteneur
Mesurez le temps nécessaire pour qu’un service devienne sain :
time docker compose --profile backend up -d
# real 0m8.432s
# user 0m0.524s
# sys 0m0.121s
Comparez avec la référence. Une réduction indique un démarrage plus rapide.
Vérifier l’utilisation des ressources sous charge
Exécutez un test de charge contre votre service et surveillez les ressources. Par exemple, en utilisant ab (ApacheBench) contre l’API :
ab -n 1000 -c 10 http://localhost:8080/api/health
# Requests per second: 250.00 [#/sec] (mean)
# Time per request: 40.000 [ms] (mean)
# Time per request: 4.000 [ms] (mean, across all concurrent requests)
# Transfer rate: 200.00 [Kbytes/sec] received
Pendant que le test s’exécute, ouvrez un autre terminal et vérifiez docker stats pour les conteneurs impliqués. Recherchez une utilisation élevée du CPU ou de la mémoire approchant les limites.
Inspecter la connectivité réseau entre les profils
Si vous avez divisé les réseaux, assurez-vous que les services de différents profils peuvent toujours communiquer selon les besoins. Utilisez docker exec pour faire un ping ou tester la connectivité :
docker exec myapp_web_1 wget -qO- http://api:3000/health
# {"status":"ok"}
Si la connexion échoue, vérifiez les attaches réseau :
docker inspect myapp_web_1 --format '{{json .NetworkSettings.Networks}}'
# {"frontend_net":{"IPAddress":"172.18.0.2"}}
Le conteneur web doit être uniquement sur frontend_net, mais il peut toujours atteindre api si api est également attaché à frontend_net.
Valider que les limites de ressources sont appliquées
Utilisez docker stats pour confirmer que les limites ne sont pas dépassées :
docker stats --no-stream
# CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM %
# ... myapp_db_1 1.50% 400MiB / 1GiB 39.06%
La colonne MEM USAGE / LIMIT montre que la limite est de 1 GiB, et l’utilisation est en dessous.
Vérifier les ports exposés inutiles
Si vous avez désactivé le profil debug, vérifiez que les ports de débogage ne sont pas à l’écoute sur l’hôte :
ss -tulpn | grep 8081
# (pas de sortie)
Cela confirme que le service Adminer n’est pas en cours d’exécution.
Modes de défaillance et récupération
Même avec une optimisation minutieuse, des problèmes peuvent survenir. Voici les modes de défaillance courants et comment les récupérer.
Échec de démarrage dû à un profil manquant
Si vous oubliez d’activer un profil requis, les services dépendants peuvent échouer. Par exemple, exécuter docker compose up -d sans --profile backend ne démarre aucun service car tous sont affectés à des profils. Si vous vous attendez à ce que les services démarrent mais qu’ils ne le font pas, vérifiez les profils actifs :
docker compose ps
# NAME COMMAND SERVICE STATUS PORTS
Aucun conteneur listé. Pour corriger, spécifiez les profils corrects :
docker compose --profile backend up -d
Épuisement des ressources dû à des limites trop basses
Si vous définissez des limites de mémoire trop agressives, les conteneurs peuvent être tués par OOM (out of memory) et redémarrer. Vérifiez les codes de sortie des conteneurs et les journaux :
docker inspect myapp_db_1 --format '{{.State.ExitCode}} {{.State.OOMKilled}}'
# 137 true
Ou vérifiez les journaux système pour les événements OOM. Si OOM tué, augmentez la limite de mémoire dans le fichier compose et recréez :
memory: 2G
Puis recréez :
docker compose --profile backend up -d --force-recreate
L’isolation réseau casse la communication
Si vous déplacez des services vers des réseaux séparés et oubliez d’attacher un service au réseau approprié, la communication échoue. Diagnostiquez avec docker logs et l’inspection réseau :
docker logs myapp_api_1
# ... Connection refused ...
Vérifiez les attaches réseau de l’API et de la base de données :
docker inspect myapp_api_1 --format '{{json .NetworkSettings.Networks}}'
# {"frontend_net":{"IPAddress":"172.18.0.3"}}
docker inspect myapp_db_1 --format '{{json .NetworkSettings.Networks}}'
# {"backend_net":{"IPAddress":"172.19.0.2"}}
Ici, api est sur frontend_net mais pas sur backend_net, donc il ne peut pas atteindre db. Pour corriger, ajoutez backend_net aux réseaux du service api et recréez.
Procédure de rollback
Si un changement cause des problèmes, revenez à la configuration précédente. Conservez des copies versionnées de votre fichier compose. Par exemple, utilisez Git pour suivre les modifications. Pour revenir en arrière :
git checkout docker-compose.yml
docker compose --profile backend up -d --force-recreate
Si vous ne pouvez pas revenir immédiatement, vous pouvez arrêter temporairement les services problématiques et les démarrer avec les overrides de ligne de commande précédents :
docker compose stop api
docker compose run --rm --entrypoint sh api
Mais un rollback propre du fichier est préférable.
Pièges courants et comment les éviter
Sur-activer les profils pendant le développement
Il est tentant d’activer tous les profils pour « tout avoir à disposition », mais cela entraîne une consommation de ressources inutile et des temps de démarrage plus lents. Commencez toujours par l’ensemble minimal de profils requis pour votre tâche actuelle. Passez en revue vos profils actifs chaque semaine et désactivez ceux qui ne sont plus nécessaires.
Ignorer les limites de ressources
Sans limites explicites, un conteneur incontrôlable peut consommer toute la mémoire et le CPU de l’hôte, provoquant des défaillances en cascade sur d’autres services. Définissez toujours deploy.resources.limits pour chaque service dans les environnements de type production et vérifiez avec docker stats.
S’appuyer sur la clé version obsolète
Utiliser une ancienne clé version: '3' dans votre fichier compose peut créer de la confusion sur les fonctionnalités disponibles. Selon la spécification Compose, le champ version est obsolète. Omettez-le et comptez sur Docker Compose v2 pour les fonctionnalités modernes comme les profils.
Oublier les conditions de healthcheck
Une erreur courante est d’utiliser depends_on sans condition: service_healthy, ce qui attend seulement le démarrage du conteneur, pas que l’application à l’intérieur soit prête. Cela peut provoquer des conditions de course et des connexions échouées. Définissez des healthchecks pour les services avec état et utilisez-les dans depends_on.
Définitions de réseau incohérentes
Un mélange de réseaux par défaut et personnalisés peut conduire à une isolation inattendue. Définissez toujours des réseaux explicites et attachez chaque service aux réseaux dont il a besoin. Évitez d’utiliser le réseau par défaut pour autre chose que des projets simples à un seul service.
Liste de contrôle opérationnelle
Utilisez cette liste avant et après l’optimisation des performances pour garantir la cohérence et la sécurité.
| Tâche | Commande ou action | Résultat attendu | Responsable | Fréquence |
|---|---|---|---|---|
| Vérifier la version de Compose | docker compose version | v2.x | Responsable DevOps (Priya Shah) | Avant chaque cycle d’optimisation |
| Lister les profils actifs | docker compose ps | Affiche uniquement les services actifs | Ingénieur plateforme | Hebdomadaire |
| Vérifier les limites de ressources | docker stats --no-stream | Limites affichées | SRE | Quotidien |
| Modifier la sélection de profils | Mettre à jour les drapeaux de la commande compose up | Les services souhaités démarrent | Développeur (sur branche de fonctionnalité) | À chaque changement |
| Appliquer les limites de ressources | Éditer deploy.resources.limits dans le YAML | Limites appliquées | Responsable DevOps | À chaque changement |
| Optimiser les réseaux | Définir les réseaux et attacher les services | Connectivité conforme à la conception | Administrateur réseau | Revue mensuelle |
| Ajouter des healthchecks | Définir healthcheck pour les dépendances | La condition depends_on fonctionne | Développeur backend | À chaque changement |
| Tester le temps de démarrage | time docker compose up -d | Démarrage raisonnable | Ingénieur QA | À chaque livraison |
| Exécuter un test de charge | Utiliser ab, wrk ou similaire | Débit et latence dans les objectifs | Ingénieur performance | Avant et après optimisation |
| Vérifier les ports exposés | ss -tulpn | Aucun port non intentionnel | Ingénieur sécurité | Hebdomadaire |
| Revenir en arrière si nécessaire | git checkout docker-compose.yml && docker compose up -d | État précédent restauré | Responsable DevOps | Au besoin |
Effectuez cette liste de contrôle après chaque modification pour éviter de manquer des régressions.
Conclusion
Les profils Docker Compose sont un outil puissant pour gérer des environnements multi-services, mais l’optimisation des performances exige une approche systématique. En inventoriant vos versions et ressources, en apportant des modifications incrémentales, en vérifiant avec des diagnostics concrets et en vous préparant aux échecs, vous pouvez garder vos projets Compose efficaces et fiables.
Commencez par un pilote étroit et mesurable : activez uniquement les profils dont vous avez besoin, définissez des limites de ressources et mesurez avant et après. Ensuite, élargissez vos efforts d’optimisation à mesure que vous gagnez en confiance. Avec la liste de contrôle fournie, vous pouvez intégrer ces pratiques dans votre flux de travail opérationnel régulier.
Prochaines étapes : appliquez les paramètres de profil et de ressources de ce guide à l’un de vos environnements de développement ou de staging, exécutez un test de charge avant-après et documentez les résultats pour votre équipe.