E-NO
DevOps 10 min de lecture

Profils Docker Compose : guide pratique pour l’optimisation des performances

calendar_today Publié : 2026-11-20
update Dernière mise à jour : 2026-11-20
analytics Efficacité SEO : 100%
Illustration du guide technique pour « Profils Docker Compose : guide pratique pour l’optimisation des performances ».

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.

Question rapide 1 sur 2

Si vous définissez COMPOSE_PROFILES=frontend,debug, quels services docker compose up démarrera-t-il ?

Selon la référence, définir COMPOSE_PROFILES=frontend,debug sélectionne les services avec les profils frontend et debug ainsi que tous les services sans profil spécifié.

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.

Question rapide 2 sur 2

Quel séparateur est utilisé pour spécifier plusieurs profils dans la variable d'environnement COMPOSE_PROFILES ?

La référence indique que pour spécifier plusieurs profils, on utilise une virgule comme séparateur, par ex. COMPOSE_PROFILES=frontend,debug.

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âcheCommande ou actionRésultat attenduResponsableFréquence
Vérifier la version de Composedocker compose versionv2.xResponsable DevOps (Priya Shah)Avant chaque cycle d’optimisation
Lister les profils actifsdocker compose psAffiche uniquement les services actifsIngénieur plateformeHebdomadaire
Vérifier les limites de ressourcesdocker stats --no-streamLimites affichéesSREQuotidien
Modifier la sélection de profilsMettre à jour les drapeaux de la commande compose upLes services souhaités démarrentDéveloppeur (sur branche de fonctionnalité)À chaque changement
Appliquer les limites de ressourcesÉditer deploy.resources.limits dans le YAMLLimites appliquéesResponsable DevOpsÀ chaque changement
Optimiser les réseauxDéfinir les réseaux et attacher les servicesConnectivité conforme à la conceptionAdministrateur réseauRevue mensuelle
Ajouter des healthchecksDéfinir healthcheck pour les dépendancesLa condition depends_on fonctionneDéveloppeur backendÀ chaque changement
Tester le temps de démarragetime docker compose up -dDémarrage raisonnableIngénieur QAÀ chaque livraison
Exécuter un test de chargeUtiliser ab, wrk ou similaireDébit et latence dans les objectifsIngénieur performanceAvant et après optimisation
Vérifier les ports exposésss -tulpnAucun port non intentionnelIngénieur sécuritéHebdomadaire
Revenir en arrière si nécessairegit checkout docker-compose.yml && docker compose up -dÉtat précédent restauréResponsable DevOpsAu 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.

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