Découvrir Docker Compose : comprendre et utiliser Compose

Docker permet de créer et d'exécuter des conteneurs avec des commandes comme docker run. Cette méthode fonctionne très bien, mais les commandes peuvent rapidement devenir longues lorsqu'il faut gérer plusieurs services, ports, volumes ou réseaux.

Docker Compose permet de regrouper toute cette configuration dans un fichier appelé compose.yaml.

Dans ce tutoriel, nous allons découvrir ce qu'est Docker Compose, comprendre son fonctionnement, apprendre à utiliser son fichier de configuration et découvrir les principales commandes. Nous terminerons avec un exemple simple utilisant un serveur web Nginx.

Qu'est-ce que Docker Compose ?

Docker Compose est un outil permettant de définir et gérer des conteneurs Docker à partir d'un fichier YAML.

Avec Docker classique, nous pouvons par exemple lancer Nginx avec :

docker run -d --name serveur-web -p 8080:80 nginx

Avec Docker Compose, nous pouvons placer cette configuration dans un fichier :

services:
  web:
    image: nginx
    ports:
      - "8080:80"

Puis lancer le service avec simplement :

docker compose up -d

Docker Compose lit le fichier et crée automatiquement les ressources nécessaires.

Son intérêt devient encore plus important lorsqu'une application utilise plusieurs conteneurs.

Pourquoi utiliser Docker Compose ?

Prenons une application composée de plusieurs éléments :

Sans Docker Compose, il faudrait généralement lancer et configurer chaque conteneur séparément avec plusieurs commandes docker run.

Avec Docker Compose, toute la configuration peut être regroupée dans un seul fichier :

compose.yaml

Nous pouvons ensuite démarrer les services avec :

docker compose up -d

Docker Compose peut notamment gérer :

• les services ;
• les images Docker ;
• les ports ;
• les volumes ;
• les réseaux ;
• les variables d'environnement ;
• les dépendances entre services.

Le fichier Compose permet également de conserver la configuration et de la réutiliser facilement.

Docker Compose ou docker run ?

Les deux méthodes permettent de lancer des conteneurs Docker.

Avec docker run :

docker run -d \
  --name serveur-web \
  -p 8080:80 \
  nginx

La configuration se trouve directement dans la commande.

Avec Docker Compose :

services:
  web:
    image: nginx
    ports:
      - "8080:80"

Puis :

docker compose up -d

Nous pouvons retenir la différence de cette manière :

Pour lancer rapidement un conteneur, docker run reste très pratique.

Lorsque plusieurs paramètres ou plusieurs conteneurs doivent être gérés ensemble, Docker Compose permet d'obtenir une configuration plus lisible et facilement reproductible.

Vérifier Docker Compose

Avant de commencer, vérifiez que Docker Compose est disponible :

docker compose version

Résultat similaire :

Vous pouvez également vérifier Docker :

docker --version

Résultat similaire :

Attention à l'ancienne commande

Vous pourrez rencontrer sur Internet cette commande : docker-compose

Il s'agit de l'ancienne syntaxe.

La syntaxe actuelle est :

docker compose

Il faut donc privilégier :

docker compose up

Comprendre le fichier compose.yaml

Docker Compose utilise un fichier de configuration YAML.

Nous utiliserons :

compose.yaml

Prenons cet exemple :

services:
  web:
    image: nginx
    ports:
      - "8080:80"

Découvrons les différents éléments.

services

La ligne services contient la liste des services de notre environnement.

Un service représente généralement un composant de l'application.

Par exemple :

Chaque service pourra utiliser sa propre image Docker et sa propre configuration.

web

Dans notre exemple, web est simplement le nom que nous avons donné au service.

Nous aurions également pu utiliser :

serveur-web:

ou :

nginx:

Lorsque plusieurs services sont présents sur le même réseau Compose, leur nom de service peut notamment être utilisé pour communiquer entre eux.

image

La ligne image: nginx indique l'image Docker utilisée par le service.

Ici, Docker utilisera l'image : nginx

Si elle n'est pas disponible localement, Docker pourra la télécharger depuis le registre configuré.

ports

La configuration ports permet de publier un port du conteneur.

Nous avons : 8080:80

Cela signifie :

Nous pourrons donc accéder au serveur depuis :

http://localhost:8080

Comprendre l'indentation YAML

Le fichier Compose utilise le format YAML.

L'indentation est importante.

Cette configuration est correcte :

services:
  web:
    image: nginx
    ports:
      - "8080:80"

Les paramètres appartenant au service web sont décalés vers la droite.

Une mauvaise indentation peut empêcher Docker Compose d'interpréter correctement le fichier.

Docker Compose possède justement une commande permettant de vérifier la configuration :

docker compose config

Créer notre premier fichier Compose

Créons maintenant un environnement très simple.

Créez un dossier :

mkdir tuto-compose

Entrez dans le dossier :

cd tuto-compose

Créez ensuite :

nano compose.yaml

Ajoutez :

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"

Notre dossier contient maintenant :

Vérifier la configuration

Avant de lancer le service, vérifiez le fichier :

docker compose config

Docker Compose va lire et interpréter le fichier compose.yaml.

Si le fichier est valide, Docker Compose affiche la configuration interprétée.

Cette commande est particulièrement utile pour détecter une erreur de syntaxe ou d'indentation avant de démarrer les services.

Démarrer avec docker compose up

Nous pouvons maintenant démarrer notre environnement :

docker compose up

Docker Compose va notamment :

1. lire le fichier compose.yaml ;
2. récupérer l'image si nécessaire ;
3. créer les ressources nécessaires ;
4. créer le conteneur ;
5. démarrer le service.

Les logs de Nginx restent affichés directement dans le terminal.

Démarrer les services en arrière-plan

Il est généralement plus pratique de démarrer les conteneurs en arrière-plan.

Utilisez :

docker compose up -d

L'option -d signifie detached.

Vous récupérez donc immédiatement votre terminal pendant que le conteneur continue de fonctionner.

Résultat similaire :

Docker Compose a notamment créé automatiquement un réseau pour notre environnement.

Afficher les services

Pour afficher les services du projet :

docker compose ps

Résultat similaire :

Nous retrouvons notre service web.

Vous pouvez également utiliser la commande Docker classique :

docker ps

Cela confirme que le port 8080 de notre machine est redirigé vers le port 80 du conteneur.

Tester le serveur Nginx

Ouvrez votre navigateur et rendez-vous sur :

http://localhost:8080

La page suivante devra apparaître :

Notre serveur Nginx fonctionne donc correctement.

Vous pouvez également tester depuis le terminal :

curl http://localhost:8080

Vous devriez obtenir le code HTML retourné par Nginx.

Résultat de la commande curl :

Notre fichier :

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"

nous a donc permis de lancer Nginx sans avoir à écrire directement :

docker run -d -p 8080:80 nginx:alpine

Afficher les logs

Pour consulter les logs des services :

docker compose logs

Pour suivre les logs en temps réel :

docker compose logs -f

Actualisez ensuite plusieurs fois :

http://localhost:8080

Les requêtes HTTP vont apparaître dans votre terminal.

Le conteneur continue de fonctionner.

Arrêter les services

Pour arrêter les services sans supprimer les conteneurs :

docker compose stop

Vous pouvez vérifier leur état avec :

docker compose ps

Pour les redémarrer :

docker compose start

Nous n'avons pas besoin de recréer les conteneurs puisqu'ils existent toujours.

Comprendre docker compose down

Docker Compose possède une commande importante :

docker compose down

Elle permet d'arrêter l'environnement et de supprimer les conteneurs ainsi que les réseaux créés par Compose pour ce projet.

Exécutez :

docker compose down

Résultat similaire :

Notre fichier compose.yaml reste présent sur la machine.

Nous pouvons donc recréer notre environnement à tout moment avec :

docker compose up -d

C'est l'un des grands avantages de Docker Compose : la configuration de l'environnement reste enregistrée dans le fichier YAML.

Ajouter un volume

Docker Compose permet également de gérer les volumes.

Créons un dossier pour notre site :

mkdir site

Créez ensuite :

nano site/index.html

Ajoutez :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Docker Compose</title>
</head>
<body>
    <h1>Docker Compose fonctionne !</h1>
    <p>Bienvenue sur SysNetTuto.</p>
</body>
</html>

Notre dossier ressemble maintenant à :

Modifiez ensuite :

nano compose.yaml

Ajoutez le volume :

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./site:/usr/share/nginx/html:ro

Nous avons ajouté :

Cela signifie que le dossier site de notre machine est monté dans :

/usr/share/nginx/html

à l'intérieur du conteneur.

Le suffixe :ro signifie read-only, c'est-à-dire que le montage est accessible en lecture seule depuis le conteneur.

Appliquer la nouvelle configuration

Après avoir modifié le fichier Compose, lancez :

docker compose up -d

Docker Compose va appliquer la nouvelle configuration et recréer le service si cela est nécessaire.

Ouvrez ensuite :

http://localhost:8080

Vous devriez maintenant voir :

Notre configuration gère maintenant :

Comprendre les réseaux avec Docker Compose

Docker Compose simplifie également la gestion des réseaux.

Affichez les réseaux Docker :

docker network ls

Vous devriez trouver un réseau ressemblant à :

Docker Compose crée automatiquement un réseau par défaut pour le projet.

Cela devient particulièrement intéressant lorsque plusieurs services sont définis.

Imaginons que :

services:
  web:
    image: nginx

  database:
    image: mariadb

Nous aurions alors deux services :

Les services connectés au même réseau Compose peuvent communiquer en utilisant leur nom de service.

Le service web pourrait donc utiliser database comme nom d'hôte pour contacter le service correspondant, sans avoir besoin de connaître son adresse IP.

Comprendre plusieurs services dans compose.yaml

Un fichier Compose n'est pas limité à un seul conteneur.

Il peut contenir plusieurs services.

Par exemple :

services:
  web:
    image: nginx
    ports:
      - "8080:80"

  database:
    image: mariadb

Nous avons ici :

Lorsque nous exécutons :

docker compose up -d

Docker Compose prend en compte les différents services définis dans le fichier.

C'est particulièrement utile pour les applications qui nécessitent plusieurs conteneurs fonctionnant ensemble.

Différence entre docker compose stop et down

Il est important de comprendre la différence entre ces deux commandes.

Avec :

docker compose stop

les conteneurs sont simplement arrêtés.

Nous pouvons ensuite les redémarrer avec :

docker compose start

En revanche :

docker compose down

supprime les conteneurs et le réseau Compose du projet.

docker compose down
        ?
        ??? Arrêt des conteneurs
        ??? Suppression des conteneurs
        ??? Suppression du réseau Compose

Le fichier compose.yaml reste présent.

Il suffit donc de lancer pour recréer l'environnement :

docker compose up -d

Conclusion

Docker Compose permet de décrire la configuration d'un ou plusieurs conteneurs Docker dans un fichier compose.yaml.

Au lieu de multiplier les commandes docker run, nous pouvons déclarer les images, les ports, les volumes, les réseaux et d'autres paramètres dans un seul fichier.

Dans ce tutoriel, nous avons notamment utilisé :

docker compose up -d
docker compose ps
docker compose logs
docker compose stop
docker compose start
docker compose down

Nous avons également vu qu'un fichier Compose peut contenir plusieurs services et que Docker Compose crée automatiquement un réseau permettant à ces services de communiquer.

Docker Compose permet ainsi de réunir les notions essentielles de Docker — conteneurs, images, volumes et réseaux — dans une configuration unique, lisible et facilement reproductible.