Introduction

Dans le tutoriel précédent, nous avons découvert Docker Compose, son rôle et le fonctionnement du fichier compose.yaml.

Docker Compose devient particulièrement intéressant lorsqu'une application ne repose plus sur un seul conteneur. Une application web peut par exemple avoir besoin :

• d'un serveur web ;
• d'une base de données ;
• d'une application ;
• et parfois d'autres services complémentaires.

Avec la commande docker run, il faudrait créer et configurer chaque conteneur séparément. Plus le nombre de conteneurs augmente, plus l'administration devient compliquée.

Docker Compose permet de regrouper toute cette configuration dans un seul fichier et de démarrer l'ensemble de l'environnement avec une seule commande.

Dans ce tutoriel, nous allons créer une petite infrastructure composée de deux conteneurs :

L'objectif est surtout de comprendre comment déclarer, démarrer, arrêter et administrer plusieurs conteneurs avec Docker Compose.

Préparer le répertoire du projet

Nous allons commencer par créer un nouveau dossier pour notre environnement Docker Compose.

mkdir docker-compose-multi

Entrons ensuite dans ce dossier :

cd docker-compose-multi

Notre projet contiendra principalement un fichier :

Le fichier compose.yaml contiendra la configuration de tous les conteneurs nécessaires à notre environnement.

Créer le fichier compose.yaml

Créons le fichier :

nano compose.yaml

Ajoutons la configuration suivante :

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

  database:
    image: mariadb:11
    environment:
      MARIADB_ROOT_PASSWORD: motdepasse
      MARIADB_DATABASE: sysnettuto

Enregistrez ensuite le fichier.

Nous venons de déclarer deux services Docker :

Docker Compose créera un conteneur pour chacun de ces services.

Comprendre le service web

Observons d'abord cette partie :

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

Le mot web correspond au nom du service.

La ligne :

image: nginx:alpine

indique à Docker Compose d'utiliser l'image Docker Nginx Alpine.

Enfin :

Ports permet de rendre Nginx accessible depuis notre machine.

Le fonctionnement est le suivant :

Nous pourrons donc accéder au serveur web avec :

http://localhost:8080

Comprendre le service database

Regardons maintenant la deuxième partie :

database:
  image: mariadb:11
  environment:
    MARIADB_ROOT_PASSWORD: motdepasse
    MARIADB_DATABASE: sysnettuto

Le service s'appelle database.

Il utilise l'image : mariadb:11

La section environment permet de transmettre des variables d'environnement au conteneur.

Dans notre exemple :

MARIADB_ROOT_PASSWORD: motdepasse

définit le mot de passe du compte root de MariaDB.

La variable MARIADB_DATABASE: sysnettuto demande à MariaDB de créer automatiquement une base de données appelée : sysnettuto

Nous avons donc maintenant notre architecture :

Démarrer plusieurs conteneurs

Nous pouvons maintenant démarrer tous les services définis dans le fichier compose.yaml.

Exécutez :

docker compose up

Docker Compose va lire le fichier compose.yaml.

Il va ensuite notamment :

Les journaux des différents conteneurs vont apparaître directement dans le terminal.

Démarrer les conteneurs en arrière-plan

Dans la majorité des cas, nous préférerons exécuter les conteneurs en arrière-plan.

Arrêtez éventuellement Docker Compose avec :

Ctrl + C

Puis démarrez l'environnement avec :

docker compose up -d

L'option -d signifie detached mode.

Les conteneurs continuent ainsi de fonctionner sans bloquer le terminal.

Vérifier les conteneurs Docker Compose

Pour connaître l'état des services de notre projet, utilisons :

docker compose ps

Vous devriez obtenir deux conteneurs correspondant à nos deux services.

Par exemple :

Docker Compose génère automatiquement les noms des conteneurs à partir :

Nom du projet + Nom du service + Numéro du conteneur

Le numéro permet notamment à Docker Compose de gérer plusieurs instances d'un même service.

Vérifier avec docker ps

Les conteneurs Docker Compose restent de véritables conteneurs Docker.

Nous pouvons donc également utiliser :

docker ps

Nous retrouverons nos conteneurs Nginx et MariaDB dans la liste.

Docker Compose ne remplace donc pas Docker.

Il permet simplement de piloter plus facilement plusieurs ressources Docker à partir d'un fichier de configuration.

Tester le serveur web

Notre conteneur Nginx expose le port 80 sur le port 8080 de notre machine.

Ouvrez un navigateur puis rendez-vous à l'adresse :

http://localhost:8080

La page par défaut de Nginx devrait apparaître.

Cela confirme que notre premier conteneur fonctionne correctement.

L'accès suit ce chemin :

Comprendre le réseau Docker Compose

Lorsque nous exécutons :

docker compose up -d

Docker Compose crée automatiquement un réseau pour notre projet.

Nous pouvons le vérifier avec :

docker network ls

Un réseau correspondant à notre projet devrait apparaître.

Par exemple :

docker-compose-multi_default

Les services déclarés dans notre fichier compose.yaml sont automatiquement connectés à ce réseau.

Notre architecture ressemble donc réellement à ceci :

Les deux conteneurs peuvent communiquer entre eux sans que nous ayons besoin de créer manuellement le réseau.

Les services peuvent communiquer avec leur nom

Docker Compose fournit également une résolution de noms entre les services.

Le conteneur web peut donc retrouver le conteneur MariaDB simplement grâce au nom :

database

Il n'est pas nécessaire de connaître l'adresse IP du conteneur.

Par exemple, une application aurait généralement cette configuration pour joindre MariaDB :

Serveur : database
Port : 3306
Base : sysnettuto
Utilisateur : root
Mot de passe : motdepasse

L'architecture devient alors :

C'est un point particulièrement important avec Docker Compose : le nom du service peut être utilisé comme nom d'hôte entre les conteneurs du projet.

Afficher les journaux des conteneurs

Lorsque plusieurs conteneurs fonctionnent simultanément, il est important de pouvoir consulter leurs journaux.

Docker Compose fournit la commande :

docker compose logs

Elle affiche les journaux de l'ensemble des services.

Pour suivre les journaux en temps réel :

docker compose logs -f

L'option -f signifie que le terminal reste alors ouvert et affiche les nouveaux événements au fur et à mesure.

Pour quitter :

Ctrl + C

Cela ne stoppe pas les conteneurs.

Afficher les logs d'un seul service

Nous pouvons également cibler uniquement un service.

Pour Nginx :

docker compose logs web

Pour MariaDB :

docker compose logs database

Et pour suivre uniquement les logs de MariaDB :

docker compose logs -f database

C'est particulièrement utile lorsqu'une infrastructure contient de nombreux conteneurs.

Exécuter une commande dans un conteneur

Docker Compose permet également d'exécuter facilement une commande dans un service.

Par exemple :

docker compose exec web sh

Nous ouvrons alors un shell directement dans le conteneur Nginx.

Nous pouvons vérifier son contenu :

ls

Puis quitter :

exit

La syntaxe générale est :

docker compose exec SERVICE COMMANDE

Par exemple :

docker compose exec database mariadb -u root -p

Docker nous demandera alors le mot de passe MariaDB.

Dans notre configuration, il s'agit de :

motdepasse

Arrêter un service uniquement

Docker Compose permet également de gérer les services indépendamment.

Pour arrêter seulement le serveur web :

docker compose stop web

Vérifions :

docker compose ps

Le conteneur MariaDB peut continuer à fonctionner alors que Nginx est arrêté.

Pour redémarrer le service web :

docker compose start web

Cette possibilité est pratique lorsqu'il n'est pas nécessaire d'arrêter toute l'infrastructure.

Redémarrer un service

Pour redémarrer directement un conteneur :

docker compose restart web

Ou pour MariaDB :

docker compose restart database

Pour redémarrer tous les services :

docker compose restart

Arrêter l'ensemble des conteneurs

Pour arrêter les conteneurs sans les supprimer :

docker compose stop

Vérifiez ensuite avec :

docker compose ps

Puis redémarrez-les avec :

docker compose start

Nous avons donc :

Supprimer l'environnement Docker Compose

Lorsque nous n'avons plus besoin de notre environnement, nous pouvons utiliser :

docker compose down

Cette commande arrête les conteneurs puis supprime notamment :

• les conteneurs créés par Compose ;
• le réseau créé pour le projet.

Nous pouvons vérifier avec :

docker compose ps

Les conteneurs ne devraient plus apparaître.

Démarrer seulement certains services

Il n'est pas obligatoire de lancer tous les services déclarés dans compose.yaml.

Nous pouvons par exemple démarrer uniquement MariaDB :

docker compose up -d database

Puis vérifier :

docker compose ps

Nous pouvons ensuite démarrer Nginx :

docker compose up -d web

La syntaxe est donc :

docker compose up -d NOM_DU_SERVICE

Cette possibilité devient très pratique lorsqu'un projet contient beaucoup de services.

Ajouter un troisième conteneur

L'un des avantages de Docker Compose est qu'il devient très simple d'ajouter un nouveau service.

Nous allons par exemple ajouter Adminer, une interface web permettant d'administrer différentes bases de données.

Modifiez le fichier :

nano compose.yaml

Utilisez maintenant :

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

  database:
    image: mariadb:11
    environment:
      MARIADB_ROOT_PASSWORD: motdepasse
      MARIADB_DATABASE: sysnettuto

  adminer:
    image: adminer
    ports:
      - "8081:8080"

Notre environnement contient maintenant trois services :

Démarrer la nouvelle infrastructure

Exécutez :

docker compose up -d

Docker Compose détecte la nouvelle configuration.

Il conserve les services existants et crée le service manquant.

Vérifiez :

docker compose ps

Vous devriez maintenant retrouver :

Nous venons donc de passer d'une infrastructure de deux conteneurs à trois conteneurs en modifiant simplement notre fichier compose.yaml.

Accéder à Adminer

Adminer est accessible sur le port : 8081

Ouvrez donc :

http://localhost:8081

Pour vous connecter à MariaDB, utilisez :

Système : MySQL

Serveur : database
Utilisateur : root
Mot de passe : motdepasse
Base de données : sysnettuto

Le point important est le serveur database.

Nous utilisons encore une fois le nom du service Docker Compose, et non une adresse IP.

Adminer et MariaDB étant connectés au même réseau Docker Compose, Docker peut automatiquement résoudre le nom database.

Notre architecture ressemble maintenant à ceci :

Afficher la configuration interprétée par Docker Compose

Une commande particulièrement utile est :

docker compose config

Docker Compose analyse le fichier compose.yaml puis affiche la configuration qu'il a réellement comprise.

Cette commande est pratique pour détecter :

• une erreur d'indentation ;
• une mauvaise structure YAML ;
• une variable mal déclarée ;
• une erreur dans un service.

Avant de démarrer une infrastructure plus importante, il peut donc être intéressant d'utiliser :

docker compose config

Conclusion

Docker Compose prend tout son intérêt lorsqu'une application nécessite plusieurs conteneurs.

Au lieu d'exécuter plusieurs commandes comme :

docker run ...
docker run ...
docker run ...

nous pouvons déclarer toute l'infrastructure dans :

compose.yaml

Puis démarrer l'ensemble avec :

docker compose up -d

Dans notre exemple, nous avons progressivement construit l'infrastructure suivante :

Docker Compose nous apporte donc plusieurs avantages :

• centraliser la configuration ;
• démarrer plusieurs conteneurs simultanément ;
• créer automatiquement un réseau entre les services ;
• permettre aux services de communiquer grâce à leur nom ;
• consulter facilement les journaux ;
• arrêter ou redémarrer un service individuellement ;
• supprimer toute l'infrastructure avec une seule commande ;
• ajouter facilement de nouveaux services.

Cette manière de travailler est beaucoup plus simple à reproduire qu'une succession de commandes docker run.

Elle constitue surtout une base importante pour construire des environnements plus complets composés d'un serveur web, d'une application et d'une base de données.