Guide Docker Compose : Simplifiez le développement de conteneurs multiples

Docker Compose simplifie la gestion des applications Docker multi-conteneurs, permettant aux développeurs d'écrire et d'exécuter des applications complexes sans effort.

Les ingénieurs DevOps intermédiaires, les développeurs backend et les développeurs cloud-native, en particulier ceux qui travaillent sur des microservices ou des architectures multiservices, sont souvent confrontés au défi de gérer de nombreux conteneurs interconnectés. Docker Compose répond à ces complexités, en rationalisant les flux de travail de développement et de test. 

Dans cet article, vous apprendrez tout ce dont vous avez besoin pour utiliser Docker Compose. Consultez notre guide Docker pour les débutants si vous commencez à utiliser Docker. 

Qu'est-ce que Docker Compose ?

Docker Compose est un outil conçu pour définir et orchestrer des applications Docker multi-conteneurs via un seul fichier de configuration YAML. 

Avec Compose, vous pouvez facilement spécifier des services, des réseaux, des volumes, des paramètres d'environnement et des dépendances. Il est idéal pour le développement local, les installations de test, le prototypage rapide et les environnements de production plus restreints.

Les cas d'utilisation courants de Docker Compose incluent la création d'environnements locaux qui reflètent les systèmes du monde réel, tels que les architectures microservices. En définissant clairement les interactions entre les composants, Compose assure la cohérence, la facilité d'utilisation et des cycles d'itération plus rapides.

Vous vous demandez peut-être pourquoi vous n'utiliseriez pas simplement Kubernetes. Tout d'abord, il s'agit d'un outil surdimensionné pour les petits projets et les tests locaux. Comme vous le découvrirez dans notre site Kubernetes vs. Docker tutorial, Kubernetes est mieux adapté à la gestion de plusieurs conteneurs dans des clusters. Notre cours Conteneurisation et virtualisation avec Docker et Kubernetes plonge plus profondément dans la façon de construire et de déployer des applications avec Docker et Kubernetes. 

Pourquoi utiliser Docker Compose vs. Commandes Docker manuelles ?

La gestion individuelle de plusieurs conteneurs peut rapidement devenir chaotique :

• Ordres de dépendance complexes, 
• des environnements incohérents, et 
• Problèmes d'évolutivité. 

Avec des commandes manuelles, vous risquez l'erreur humaine, la dérive de la configuration et des flux de travail inefficaces. 

Docker Compose permet de résoudre ces problèmes en définissant tous les services et dépendances de l'application dans un seul fichier YAML. Cela apporte cohérence, évolutivité et facilité de gestion des dépendances, ce qui permet de réduire considérablement les erreurs et d'augmenter la productivité.

Compose est plus rapide que la création manuelle des conteneurs et leur connexion. En outre, compose crée un réseau par défaut pour la communication entre tous les conteneurs. En outre, il gère les volumes, assurant leur rattachement automatique en cas de remplacement ou de redémarrage du service. 

Vous pouvez apprendre à conteneuriser des applications d'apprentissage automatique avec Docker et Kubernetes dans notre tutoriel Comment conteneuriser une application à l'aide de Docker . 

Quelle est la différence entre Docker et Docker Compose ?

Alors que Docker est la plateforme de construction, d'exécution et de gestion des conteneurs, Docker Compose est l'outil qui facilite la définition et la gestion de plusieurs conteneurs à l'aide d'un fichier YAML, principalement docker-compose.yml. 

Docker gère les conteneurs individuels, mais Docker Compose vous permet de les empiler en un seul service. Par exemple, une application avec un backend, un frontend, une base de données, une mise en cache, etc. 

Vous pouvez construire et exécuter vos conteneurs sans Docker Compose. Cependant, le fait de tout encapsuler dans un seul fichier docker-compose.yml facilite la gestion de plusieurs conteneurs. Il permet également de démarrer votre application dans n'importe quel environnement à l'aide d'une seule commande. 

Comprendre Docker et Docker Compose est essentiel pour réussir vos prochains entretiens. Assurez-vous d'être prêt en explorant les 26 meilleures questions et réponses d'entretien sur Docker pour 2025. 

Principes fondamentaux de Docker Compose

Avant de plonger dans les détails pratiques, il est essentiel de comprendre les principes fondamentaux et la syntaxe de Docker Compose. Avant d'utiliser compose, assurez-vous que Docker est installé en suivant les instructions de notre site Installer Docker sur Ubuntu : De l'installation au premier conteneur guide. 

Cadre conceptuel

Docker Compose fait abstraction de la complexité de l'orchestration des conteneurs pour un développement local et des déploiements plus simples. Avec un fichier de composition au format YAML, vous déclarez les services dont ils ont besoin, définissez leurs dépendances, spécifiez les réseaux, les volumes, les variables d'environnement, etc. Compose gère efficacement le démarrage, l'arrêt, la mise à l'échelle et l'interconnexion de ces services.

Syntaxe de Core Compose

Docker Compose s'articule autour d'une syntaxe YAML simple. Les principaux éléments sont les suivants

• services pour définir les applications conteneurisées
• images ou build contextes pour spécifier les conteneurs
• ports pour exposer les services
• volumes pour le stockage de données persistantes
• networks pour la communication interservices

Définition des services et architecture des applications

Les fichiers composites représentent les services et les connexions de l'application.

Définir les services

Les services sont au cœur d'un fichier Compose. Vous pouvez définir et nommer clairement plusieurs services (tels que des frontaux web, des bases de données et des services de mise en cache), en spécifiant les dépendances à l'aide de mots-clés simples tels que depends_on pour contrôler l'ordre de démarrage des conteneurs.

Les bases de la mise en réseau

Docker Compose crée automatiquement des réseaux par défaut pour faciliter la communication entre les services définis. Les développeurs peuvent également spécifier des réseaux personnalisés si nécessaire pour améliorer l'isolation ou répondre à des exigences détaillées en matière de réseau.

Gestion des volumes

Les volumes permettent la persistance des données au-delà des cycles de vie des conteneurs. Vous pouvez spécifier des volumes nommés ou des répertoires d'hôtes de montage pour les conteneurs, ce qui garantit la cohérence des bases de données, des journaux ou d'autres données avec état.

Variables d'environnement

Compose simplifie le passage de variables d'environnement et de secrets en toute sécurité dans les conteneurs. Il prend en charge les déclarations directes sous les services et le référencement des variables stockées dans les fichiers env ainsi que les fichiers de composition pour sécuriser les valeurs sensibles et les séparer des définitions Docker.

Mise à l'échelle et orchestration de Docker Compose

Docker Compose rationalise également la mise à l'échelle et l'orchestration de base, ce qui est particulièrement utile pour les scénarios de test de charge rapide ou l'évaluation de services parallèles.

Services de mise à l'échelle

L'option "--scale" de Compose vous permet de créer rapidement plusieurs copies de services. Cela simplifie les scénarios de test tels que l'évaluation de l'équilibrage de la charge ou la gestion des demandes simultanées.

Par exemple, la mise à l'échelle d'un conteneur d'application Flask peut se faire en une seule commande :

docker-compose up --scale flaskapp=4

Docker Compose vs Docker Swarm et Kubernetes

Si Docker Compose excelle dans le développement local et les configurations à petite échelle, il est limité dans l'orchestration multi-hôtes à l'échelle de la production. Pour les scénarios complexes de niveau production sur de nombreux hôtes, des orchestrateurs plus robustes comme Docker Swarm ou Kubernetes sont appropriés, car ils offrent un équilibrage de charge puissant, une autoréparation, une mise en réseau avancée et une évolutivité à grande échelle qui ne sont pas disponibles dans Compose.

Notre Docker Compose vs. L'article de blog de Kubernetes décrit plus en détail les principales différences entre Docker Compose et Kubernetes.  

Techniques d'optimisation pour une utilisation efficace de Compose

L'utilisation efficace de Docker Compose comprend l'optimisation des constructions, l'ajout de contrôles de santé et la gestion des ressources de service. Dans cette section, vous en apprendrez davantage sur ces techniques d'optimisation.

Stratégies de construction efficaces

L'utilisation de constructions en plusieurs étapes dans des fichiers Docker permet de réduire la taille des images Docker, tandis que l'exploitation explicite de la mise en cache des constructions accélère considérablement les processus de développement et de CI.

Contrôles de santé et politiques de redémarrage

Compose vous permet de définir des contrôles de santé explicites pour le conteneur afin de maintenir la fiabilité de l'application. Les politiques de redémarrage permettent de s'assurer que les conteneurs défaillants redémarrent automatiquement, ce qui améliore la résilience.

Gérer les limites des ressources

La définition de limites de CPU et de mémoire directement dans les définitions YAML de Compose vous aide à contrôler les allocations de ressources, améliorant ainsi la prévisibilité et l'efficacité des ressources.

Un exemple de snippet pour les limites de ressources :

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Exemple pratique : Application multi-conteneurs

Voici un exemple réel simplifié impliquant une application Python Flask couplée à Redis :

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

Le fichier Docker Compose définit une application multi-conteneurs avec trois services :

1. redis
2. web (application Flask avec Gunicorn)
3. travailleur (travailleur du céleri)

Pour le service redis:

• Utilise l'image officielle de Redis 7.
• Définit le nom du conteneur à redis.
• Mapper le port 6379 à l'intérieur du conteneur sur le port 6379 de l'hôte.
• Redémarre toujours s'il se plante (redémarrer : toujours).
• Définit un site healthcheck qui exécute redis-cli ping toutes les 30 secondes, s'arrête au bout de 5 secondes et réessaie 3 fois avant de déclarer le conteneur en mauvaise santé.

Pour le service web :

• Construit l'image à partir du répertoire actuel (build: . ).
• Nomme le conteneur flask_app.
• Exécute la commande gunicorn app:app utilisant gevent workers, se liant à 0.0.0.0:5000, avec un timeout long de 3000 secondes
• Associe le port 5000 du conteneur au port 5000 de l'hôte.
• Déclare une dépendance sur le service redis, en s'assurant que Redis démarre en premier.
• Définit une variable d'environnement REDIS_URL qui pointe vers le conteneur Redis interne.
• Charge des variables d'environnement supplémentaires à partir du fichier .env.
• Monte trois dossiers locaux dans le conteneur :
• ./shorts à l'adresse /app/shorts,
• ./temp_uploads à /app/temp_uploads 
• ./uploads à /app/uploads
• Configuré pour toujours redémarrer s'il se plante.

Pour le travailleur service :

• Construit également l'image à partir du répertoire courant (build : .), en réutilisant le même fichier Docker que la commande web .
• Nomme le conteneur : celery_worker.
• Exécute la commande celery -A celery_worker.celery worker --loglevel=info qui lance un travailleur Celery pour traiter les tâches d'arrière-plan.
• Déclare une dépendance sur le service redis, en s'assurant que Redis démarre en premier.
• Définit la même variable d'environnement REDIS_URL pour se connecter au courtier Redis.
• Charge d'autres variables d'environnement à partir du fichier .env.
• Monte les trois mêmes dossiers que l'application web ce qui permet à l'application web et à l'employé de partager des fichiers et des téléchargements.
• Configuré pour toujours redémarrer s'il se plante.

Découvrez d'autres idées de projets Docker dans notre tutoriel 10 idées de projets Docker. 

Création et exécution d'applications multi-conteneurs

Docker Compose offre un ensemble d'outils simples pour les tâches courantes liées aux conteneurs :

Images de bâtiments

Utilisez docker compose build pour générer des images de conteneurs selon les fichiers Docker que vous avez définis. Pour en savoir plus sur la création d'images Docker, consultez notre site How to Learn Docker from Scratch (Comment apprendre Docker à partir de zéro) : Un guide pour les professionnels des données tutorial. 

Services d'exécution

L'utilisation de docker compose up lance tous les services définis dans le fichier de composition. Pour le mode détaché, utilisez docker compose up -d. Notre cours Introduction à Docker aborde plus en détail l'exécution d'un conteneur en arrière-plan. 

Visualisation des conteneurs en cours d'exécution

Pour voir les conteneurs actifs et leur état, utilisez docker compose ps pour lister tous les services en cours d'exécution.

Arrêt des services

Utilisez docker compose down pour arrêter les services en cours d'exécution. 

Visualisation des journaux

Utilisez docker compose logs pour vérifier les journaux. Vous pouvez spécifier un conteneur dans lequel vérifier les journaux en utilisant docker logs container_name. Pour diffuser les journaux, utilisez docker compose -f container_name. 

Notre guide Top 18 Docker Commands to Build, Run, and Manage Containers (18 commandes Docker pour construire, exécuter et gérer des conteneurs) détaille d'autres commandes Docker afin que vous puissiez gérer en toute confiance des applications dans différents environnements.

Cas d'utilisation avancés de Docker Compose 

Composez des flux de travail qui s'adaptent à des configurations de développement plus complexes ou à des configurations d'environnement différentes.

Configuration multi-environnements

Plusieurs fichiers Compose ou fichiers override facilitent la mise en place de différents environnements (développement, test, production). Les définitions sont ainsi maintenues et lisibles, ce qui permet d'effectuer des modifications rapides sans encombrer les configurations.

Gestion des dépendances

Alors que depends_on gère l'ordre de démarrage de base, les scénarios complexes peuvent intégrer des scripts d'initialisation (tels que "wait-for-it"), garantissant que les conteneurs ne démarrent que lorsque des conditions spécifiques sont remplies, telles que l'état de préparation de la base de données.

Intégration avec CI/CD

Compose s'intègre sans difficulté dans les flux d'intégration continue, en automatisant la configuration d'environnements complets pour les tests. Des plateformes comme GitLab CI et GitHub Actions offrent des approches natives ou simples pour l'intégration de Compose, rationalisant ainsi les tests automatisés.

Meilleures pratiques et défis communs

Vous pouvez éviter les pièges les plus courants et créer des configurations faciles à maintenir en organisant et en structurant les définitions Compose de manière réfléchie.

Organisation des fichiers de composition

Veillez à ce que vos fichiers Compose soient clairs et modulaires. Pour les projets plus simples, un seul fichier peut suffire, mais pour les applications plus importantes, envisagez de diviser la configuration en plusieurs fichiers Compose à l'aide de la fonction de remplacement. Cela permet :

• Séparation logique des composants (par exemple, docker-compose.backend.yml, docker-compose.frontend.yml)
• Personnalisation plus facile de l'environnement local par rapport à l' environnement de production
• Contrôle de version et collaboration simplifiés, puisque les modifications apportées à un service n'ont pas d'incidence sur l'ensemble du fichier.

Utilisez des noms de services significatifs et une indentation cohérente pour faciliter la lecture et la navigation dans les fichiers.

Pièges potentiels

Soyez attentifs à ces erreurs courantes :

• Utilisation des balises latest pour les images: Cela introduit de l'imprévisibilité, car la version réelle de l'image peut changer au fil du temps. Épinglez toujours les versions des images de manière explicite (par exemple, postgres:15.1) afin de garantir la cohérence entre les environnements.
• Les secrets codés en dur: N'incluez jamais de données sensibles (clés API, mots de passe, etc.) directement dans les fichiers Compose. Utilisez plutôt des variables d'environnement, des fichiers .env (exclus du contrôle de version) ou des outils de gestion des secrets comme Docker Secrets pour une manipulation sécurisée.
• Des définitions de services trop complexes : Résistez à l'envie d'entasser trop de logique ou trop de responsabilités dans un seul contenant. Suivez le principe de la responsabilité unique et privilégiez la simplicité dans la mesure du possible.
• Négliger la mise en réseau explicite: Définissez des réseaux personnalisés dans Compose au lieu de vous fier au comportement par défaut. Cela permet de mieux contrôler la communication des services, de réduire les conflits entre les ports et d'améliorer les limites de sécurité.

En adoptant ces pratiques, vos flux de travail basés sur Compose seront plus robustes, plus sûrs et plus faciles à maintenir dans des environnements collaboratifs ou évolutifs.

Conclusion

Docker Compose simplifie considérablement la création, la gestion et l'exécution d'applications multi-conteneurs pour les développeurs. Ses définitions claires basées sur YAML, sa facilité d'orchestration et sa mise à l'échelle simple en font un outil précieux pour les scénarios de développement local et les architectures de déploiement plus simples. Bien que les orchestrateurs avancés comme Docker Swarm et Kubernetes soient plus adaptés aux charges de travail de production à grande échelle, Compose reste un point d'entrée essentiel pour comprendre les principes fondamentaux de l'orchestration de conteneurs et améliorer les flux de travail des développeurs.

Consultez nos cours sur Docker pour apprendre :

• Conteneurisation et virtualisation avec Docker et Kubernetes 
• Docker intermédiaire