Docker compose expliqué simplement pour bien démarrer

Docker Compose expliqué simplement, c’est la différence entre galérer avec dix commandes Docker à la main et lancer une appli complète avec une seule ligne. Tu vas voir comment ce petit outil te permet de décrire ton environnement en YAML, de gérer chaque service (web, base de données, outils de debug) et d’automatiser tout le déploiement sans te perdre dans la ligne de commande. On part d’un simple serveur Nginx, puis on ajoute MySQL, la communication entre containers et même une base pour un futur backend. Au passage, tu vas aussi comprendre où s’arrête Docker “classique” et où commence la vraie orchestration locale avec Docker Compose.

Ce guide s’adresse à toi si tu as déjà lancé au moins un conteneur Docker, ou que tu vois bien l’intérêt de la virtualisation légère pour le dev, mais que les fichiers docker-compose.yml te font encore un peu peur. L’objectif : te donner un modèle mental simple, des commandes concrètes, et un exemple que tu peux adapter à ton propre projet. Si tu utilises déjà d’autres outils côté dev (WordPress, Django, Node, etc.), tu retrouveras les mêmes logiques que dans d’autres tutos de Midogeekblog sur les environnements de développement modernes.

• Docker Compose permet de décrire une application multi-conteneurs dans un fichier YAML, puis de tout lancer avec une seule commande.
• Sur Linux, Docker Compose s’installe séparément, alors qu’il est intégré à Docker Desktop sur Windows et macOS.
• Un premier exemple concret : un Nginx + page HTML custom, puis ajout d’un service MySQL avec volume persistant.
• Les services communiquent entre eux par leur nom, ce qui simplifie énormément la configuration réseau.
• Compose devient vite un outil central d’automation pour le développement, les tests et des petits déploiements.

Docker Compose : principe, rôle et différence avec Docker “classique”

Pour poser les bases, imagine Léa, développeuse freelance, qui doit lancer un backend, une base MySQL et un front Nginx. Sans Docker Compose, elle tape plusieurs commandes docker run, se trompe de port une fois sur deux et oublie un volume un jour sur trois. Avec Compose, elle décrit ses services dans un fichier configuration unique et laisse l’outil gérer les containers pour elle.

Docker tout seul sert à lancer un conteneur à la fois. Compose ajoute une couche d’orchestration locale : il lit un fichier YAML, crée un réseau dédié, les volumes, et démarre chaque composant dans le bon ordre. Tu gardes la même base de virtualisation légère, mais tu passes d’un usage “manuel” à une vraie automation reproductible. Résultat : ton environnement de dev reste cohérent entre tes machines, et entre les membres de l’équipe.

Cas d’usage typiques de Docker Compose pour bien démarrer

Compose brille dès que ton appli dépasse un seul conteneur. Tu peux par exemple lancer un Nginx + PHP-FPM + MariaDB pour un site WordPress, un Django + Redis + PostgreSQL, ou encore un stack complet avec backend Node.js, front React, et base de données. Chaque service devient un bloc bien isolé, réutilisable sur d’autres projets.

Tu peux aussi t’en servir pour des environnements de test éphémères. Tu démarres une stack complète pour une branche Git, tu l’utilises quelques heures, puis tu la détruis. Comme tout est décrit dans un fichier YAML, le déploiement de cette stack reste ultra prévisible. Ce modèle “jetable” est devenu la norme chez beaucoup de devs et d’équipes DevOps.

Installer Docker et Docker Compose pas à pas sous Linux

Avant de piloter plusieurs containers, il faut bien sûr que Docker tourne déjà. Sur Windows et macOS, Docker Desktop inclut Docker Compose par défaut, donc tu as tout dès l’installation. Sous Linux, tu dois installer Docker Engine, puis ajouter le paquet compose fourni par ta distribution, ce qui reste assez rapide.

On prend encore l’exemple de Léa, qui bosse sur Ubuntu. Elle a déjà Docker fonctionnel, mais veut vérifier si Compose est présent. Un simple docker compose version lui renvoie la version installée, du style Docker Compose version vX.X.X. Si la commande ne passe pas, elle ajoute le paquet dédié et peut ensuite utiliser toutes les commandes docker compose.

Commandes d’installation courantes

Voici les instructions les plus fréquentes sur les principales distributions. Elles s’appuient sur les dépôts officiels de chaque système.

Distribution Linux	Commande d’installation de Docker Compose
Ubuntu / Debian	sudo apt update && sudo apt install docker-compose -y
CentOS / Red Hat	sudo yum install docker-compose -y
SUSE / openSUSE	sudo zypper install docker-compose

Une fois le paquet ajouté, un docker compose version doit fonctionner. Tu peux alors enchaîner sur la première stack multi-conteneurs. Si tu veux revoir l’installation de Docker lui‑même, tu peux compléter avec un guide général sur l’écosystème Docker et la conteneurisation avant de continuer.

Premier projet Docker Compose : serveur Nginx et page HTML perso

Pour apprivoiser Docker Compose, rien de mieux qu’un exemple concret et minimal. Tu vas lancer un Nginx qui sert une simple page HTML, avec un seul fichier YAML. L’idée est de comprendre comment on décrit un service dans Compose, comment fonctionne le mapping de ports et la gestion des volumes.

Reprenons Léa : elle veut montrer un “hello world” à un client dans un navigateur, sans installer Nginx à la main sur sa machine. Elle crée un petit projet Compose local, qu’elle pourra ensuite réutiliser comme base pour d’autres sites ou maquettes.

Étapes pour créer l’arborescence et la page HTML

Dans un dossier de travail, crée la structure suivante. Elle servira à isoler ton projet.

1. Créer les dossiers
   mkdir mon-projet-compose
   cd mon-projet-compose
   mkdir html
2. Ajouter un fichier HTML simple
   echo « <h1>Bienvenue sur mon serveur Nginx avec Docker Compose !</h1> » > html/index.html

Tu as maintenant un répertoire mon-projet-compose avec un sous-dossier html contenant index.html. Cette structure sera montée dans un container Nginx grâce à la configuration YAML que tu vas écrire juste après.

Écriture du fichier docker-compose.yml pour Nginx

Dans le dossier mon-projet-compose, crée un fichier nommé docker-compose.yml. Colle-y le contenu suivant, que l’on détaille ligne par ligne pour bien comprendre :

version: ‘3’
services:
  web:
    image: nginx:latest
    ports:
      – « 8080:80 »
    volumes:
      – ./html:/usr/share/nginx/html

Ici, tu définis un service web basé sur l’image nginx:latest. Le port 8080 de ta machine est relié au port 80 du conteneur, ce qui rend le site accessible via http://localhost:8080. Le volume ./html:/usr/share/nginx/html indique que ton dossier local html remplace le dossier de contenus par défaut de Nginx dans le container.

Lancer, vérifier et tester ton application avec Docker Compose

Ton fichier YAML est prêt, il reste à demander à Docker Compose de créer et démarrer le service. C’est ici que tu vois la différence avec un docker run à rallonge : tu n’as plus à te souvenir de chaque paramètre, tout est déjà inscrit dans la configuration.

La commande équivalente en Docker “pur” serait :
docker run -d -p 8080:80 -v ./html:/usr/share/nginx/html nginx:latest
Avec Compose, tu te contentes de travailler à partir du fichier docker-compose.yml et de commandes plus courtes.

Démarrage, logs et test dans le navigateur

Dans le dossier mon-projet-compose, lance :

docker compose up -d

Le flag -d démarre les containers en arrière-plan. Tu peux ensuite vérifier que tout tourne avec :

docker compose ps

Tu devrais voir une ligne ressemblant à :

NAME          IMAGE   PORTS           STATUS
mon-projet-web  nginx   0.0.0.0:8080->80/tcp  Up

Ouvre ensuite ton navigateur et va sur http://localhost:8080. Tu devrais voir la phrase “Bienvenue sur mon serveur Nginx avec Docker Compose !”. En cas de souci, les journaux sont accessibles via docker compose logs -f, ce qui te permet de suivre en temps réel ce qu’il se passe dans tes services.

Gérer le cycle de vie des conteneurs avec Docker Compose

Une fois ton environnement en route, tu dois aussi savoir le stopper proprement, le redémarrer ou inspecter ce qu’il fait. C’est là que l’orchestration par Docker Compose simplifie énormément la routine quotidienne, surtout quand tu cumules plusieurs services.

Tu peux voir Compose comme un chef d’orchestre : c’est lui qui démarre, arrête et supprime les éléments quand tu le lui demandes. Tu ne travailles presque plus jamais directement avec docker stop ou docker rm sur chaque conteneur un par un.

Commandes de gestion essentielles

Voici une petite liste des commandes indispensables pour gérer ton stack :

• docker compose up -d : crée et lance les containers définis dans docker-compose.yml en tâche de fond.
• docker compose down : arrête et supprime les containers et le réseau associés au projet.
• docker compose restart : redémarre les services sans les recréer entièrement.
• docker compose logs -f : affiche les logs en continu pour tous les services (ou un service spécifique).
• docker compose ps : liste l’état des services (Up, Exited, ports, etc.).

Ces quelques commandes couvrent déjà 90 % de ce dont tu as besoin au quotidien. Tu passes d’une gestion manuelle des conteneurs à une vraie automation pilotée par la configuration YAML du projet.

Ajouter une base de données MySQL à ton projet Docker Compose

Maintenant que le serveur web tourne, passons au niveau supérieur : l’ajout d’un service MySQL pour préparer une future application dynamique. C’est là que tu vois clairement l’intérêt de Docker Compose pour gérer plusieurs containers liés (web + base, au minimum), sans exploser la complexité.

On continue avec Léa : son client veut une appli qui stocke des données. Plutôt que d’installer MySQL en dur dans son système, elle crée un nouveau service db dans docker-compose.yml, avec un volume persistant pour les données et des variables d’environnement pour configurer les comptes.

Modifier docker-compose.yml pour ajouter MySQL

Dans ton fichier docker-compose.yml existant, remplace le contenu par :

version: ‘3’
services:
  web:
    image: nginx:latest
    ports:
      – « 8080:80 »
    volumes:
      – ./html:/usr/share/nginx/html

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: testdb
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      – « 3306:3306 »
    volumes:
      – mysql_data:/var/lib/mysql

volumes:
  mysql_data:

Ce fichier définit maintenant deux services. Le service db repose sur l’image mysql:5.7. Les variables d’environnement gèrent le mot de passe root, le nom de base, l’utilisateur et son mot de passe. Le volume mysql_data garde les données MySQL en dehors du cycle de vie des conteneurs, ce qui les protège des suppressions accidentelles de containers.

Redémarrer la stack et tester MySQL

Relance l’ensemble avec :

docker compose up -d

Vérifie ensuite l’état des services :

docker compose ps

Tu devrais voir quelque chose comme :

NAME         IMAGE    PORTS           STATUS
mon-projet-web  nginx    0.0.0.0:8080->80/tcp  Up
mon-projet-db   mysql:5.7  0.0.0.0:3306->3306/tcp  Up

Pour tester la connexion MySQL directement depuis le container db, tu peux exécuter :

docker exec -it $(docker compose ps -q db) mysql -uuser -ppassword testdb

Si tout est bien configuré, tu te retrouves dans le client MySQL interactif. Tu as désormais une stack web + base prête à accueillir un backend plus élaboré.

Communication entre conteneurs : parler à un service par son nom

Un des gros atouts de Docker Compose est la gestion automatique des réseaux entre services. Tous les conteneurs d’un même projet sont reliés sur un réseau interne, et peuvent se joindre par leur nom logique. Tu n’as plus besoin de retenir des adresses IP internes qui changent tout le temps, la configuration reste lisible.

Pour illustrer ça, tu vas ajouter un troisième service, basé sur l’image alpine/curl, qui sert uniquement d’outil de test. Il restera en vie en exécutant une commande “sleep infinity”, ce qui te permettra de rentrer dedans et de tester des requêtes HTTP vers les autres conteneurs.

Ajouter un service curl et interroger Nginx

Modifie ton docker-compose.yml ainsi :

version: ‘3’
services:
  web:
    image: nginx:latest
    ports:
      – « 8080:80 »
    volumes:
      – ./html:/usr/share/nginx/html

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: testdb
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      – « 3306:3306 »
    volumes:
      – mysql_data:/var/lib/mysql

  curl:
    image: alpine/curl:latest
    command: sleep infinity

volumes:
  mysql_data:

Relance la stack avec docker compose up -d, puis connecte-toi au service curl :

docker compose exec -it curl sh

Depuis ce shell, tape :

curl http://web

Tu devrais voir le contenu de la page HTML servie par Nginx. Tu constates ainsi qu’un container peut interroger un autre en utilisant simplement son nom de service comme URL. C’est un point clé de l’orchestration par Compose, qui simplifie énormément la configuration réseau de tes stacks.

Aller plus loin : backend, Dockerfile et stack complète avec Docker Compose

À ce stade, tu as Nginx, MySQL et un conteneur de test qui discutent ensemble. L’étape logique suivante consiste à ajouter un backend (Django, Express, FastAPI, Symfony…) qui va parler à la base de données et exposer une API consommée par le front. C’est là que ton fichier YAML se transforme doucement en mini-plateforme d’orchestration pour ton appli.

Tu peux par exemple t’inspirer d’un schéma classique : un service db basé sur MariaDB ou MySQL, un service web construit à partir d’un Dockerfile Python ou Node, et un front qui interroge le backend. Compose te laisse ajuster les ports, les volumes, les dépendances, tout en conservant une configuration lisible.

Exemple de stack Django + MariaDB avec Dockerfile

Voici une base inspirante pour un projet Django, que tu peux adapter. Le docker-compose.yml pourrait ressembler à :

version: ‘3’
services:
  db:
    container_name: mysql
    image: mariadb:10.5.5
    restart: always
    command: –default-authentication-plugin=mysql_native_password
    environment:
      MYSQL_DATABASE: test
      MYSQL_USER: test
      MYSQL_PASSWORD: test
      MYSQL_ROOT_PASSWORD: test
    ports:
      – 3306:3306
    volumes:
      – ./db:/var/lib/mysql

  web:
    build: .
    command: python3 manage.py runserver 0.0.0.0:8000
    volumes:
      – ./blog:/app
    ports:
      – « 8888:8000 »
    depends_on:
      – db

Le Dockerfile associé pourrait être :

FROM python:3
ENV PYTHONUNBUFFERED 1
RUN mkdir /app
WORKDIR /app
COPY requirements.txt /app/
RUN pip install –upgrade pip && pip install -r requirements.txt
COPY . /app/

Tu construis ensuite l’image backend avec docker-compose build, puis tu lances le tout via docker-compose up -d. En une seule commande, ton backend Django, ta base MariaDB et ton réseau interne sont prêts. C’est la preuve concrète que Docker Compose est un outil clé pour structurer le déploiement et l’automation de tes stacks multi-conteneurs.

Exercice pratique pour t’approprier Docker Compose

Pour bien ancrer ces notions, tu peux te fixer un petit défi : ajouter un backend de ton choix (Express, FastAPI, Symfony, Laravel…) à la stack Nginx + MySQL. L’objectif est de créer un service supplémentaire dans docker-compose.yml et de le faire interagir avec la base, puis avec ta page HTML.

Quelques pistes :

• Crée un backend qui expose une API REST simple (par exemple /api/messages) et stocke les données dans testdb.
• Modifie la page HTML servie par Nginx pour interroger ce backend via JavaScript.
• Vérifie que tout continue à fonctionner quand tu relances la stack avec docker compose down puis docker compose up -d.

Avec cet exercice, tu passes d’un simple “hello world” statique à une vraie mini-application distribuée. Tu manipules la virtualisation légère par conteneurs, la configuration déclarative en YAML, et la petite orchestration locale qu’offre Docker Compose, comme le font aujourd’hui la plupart des équipes de développement web.

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

Docker est l outil de base qui crée et exécute un seul container à la fois. Docker Compose ajoute une couche d orchestration locale : il lit un fichier YAML pour lancer, configurer et relier plusieurs services (web, base, outils) avec une seule commande, ce qui simplifie énormément les environnements complets de développement et de test.

Faut-il utiliser Docker Compose en production ?

Docker Compose reste surtout pensé pour le développement, les tests et les environnements de préproduction. Pour des déploiements à grande échelle, on lui préfère généralement Kubernetes ou Swarm, mais Compose peut convenir pour de petites applis auto-hébergées, à condition de bien gérer les volumes, les sauvegardes et la supervision.

Comment mettre à jour un service dans un projet Docker Compose ?

Tu modifies le fichier docker-compose.yml (image, variables, ports, etc.), puis tu exécutes docker compose pull si tu utilises une nouvelle image, et enfin docker compose up -d. Compose recrée seulement les conteneurs concernés en conservant les volumes de données, ce qui rend la mise à jour assez fluide.

Comment éviter de perdre mes données avec Docker Compose ?

La clé est d utiliser des volumes nommés ou des montages de répertoires locaux dans ta configuration YAML. Les données critiques (bases SQL, fichiers d upload) doivent être stockées dans ces volumes, qui survivent aux docker compose down. Tu peux ensuite mettre en place des sauvegardes classiques sur ces dossiers.

Puis-je lancer plusieurs projets Docker Compose sur la même machine ?

Oui, chaque projet a son propre réseau et ses propres services. Il suffit d éviter les conflits de ports exposés (par exemple ne pas utiliser 8080 dans deux stacks en parallèle). Compose isole déjà bien les containers, tu n as donc qu à ajuster les ports externes et les noms de dossiers pour cohabiter sans souci.