Recherche de site Web

Comment installer et utiliser Docker Compose sur Ubuntu

Introduction

Docker simplifie le processus de gestion des processus d'application dans des conteneurs. Bien que les conteneurs présentent certaines similitudes avec les machines virtuelles, ils sont plus légers et consomment moins de ressources. Cela permet aux développeurs de décomposer un environnement d'application en plusieurs services isolés.

Pour les applications dépendant de plusieurs services, orchestrer tous les conteneurs pour qu'ils démarrent, communiquent et s'arrêtent ensemble peut rapidement devenir ingérable. Docker Compose est un outil qui vous permet d'exécuter des environnements d'applications multi-conteneurs basés sur des définitions définies dans un fichier YAML. Il utilise des définitions de services pour créer des environnements entièrement personnalisables avec plusieurs conteneurs pouvant partager des réseaux et des volumes de données.

Ce guide vous expliquera comment installer Docker Compose sur un serveur Ubuntu et exécuter un conteneur simple. Ensuite, vous apprendrez à créer un environnement multi-services en utilisant une application WordPress et une base de données MySQL. Nous aborderons également des sujets plus avancés, notamment la mise à l'échelle des services, la définition de réseaux personnalisés et l'utilisation de directives d'inclusion modulaires. Enfin, cet article fournit un guide de migration de l'ancien docker-compose (v1) vers le moderne docker compose (v2) et une section détaillée sur le dépannage des problèmes courants tels que les conflits de ports et les erreurs de permissions.

Points clés :

  • Docker Compose est un outil permettant de définir et d'exécuter des applications multi-conteneurs en utilisant un seul fichier YAML pour configurer les services, les réseaux et les volumes.
  • Docker Compose est installé sur Ubuntu en ajoutant le dépôt officiel de Docker et en utilisant apt pour installer le paquet docker-compose-plugin.
  • La commande moderne est docker compose (avec un espace). Elle remplace l'outil v1 obsolète docker-compose (avec un trait d'union).
  • Utilisez docker compose up -d pour démarrer une application en mode détaché et docker compose down pour arrêter et supprimer tous ses conteneurs et réseaux.
  • La directive depends_on aide à contrôler l'ordre de démarrage des services, par exemple en garantissant qu'un conteneur de base de données démarre avant un conteneur d'application web.
  • Les problèmes les plus fréquents sont « Permission refusée » (résolu en ajoutant votre utilisateur au groupe docker), les conflits de ports (résolus en modifiant le port hôte dans le fichier YAML) et les erreurs de syntaxe YAML (résolues en corrigeant l’indentation).
  • Vous pouvez exécuter plusieurs instances d'un service en utilisant la commande docker compose up --scale <service_name>=<number>.
  • La directive include permet de diviser un large fichier docker-compose.yml en fichiers de configuration plus petits et plus faciles à gérer.

Prérequis

Pour suivre cet article, vous aurez besoin de :

  • Accès à une machine locale Ubuntu ou à un serveur de développement en tant qu’utilisateur non root avec des privilèges sudo. Si vous utilisez un serveur distant, il est conseillé d’avoir un pare-feu actif installé. Pour les configurer, veuillez vous référer à notre Guide de configuration initiale du serveur pour Ubuntu.
  • Docker installé sur votre serveur ou votre machine locale, en suivant les étapes 1 et 2 du guide Comment installer Docker sur Ubuntu – Guide étape par étape.

Remarque : À partir de Docker Compose v2, Docker a migré vers l'utilisation de la commande plugin CLI compose, et s'éloigne de l'original docker-compose comme documenté dans notre guide « Comment installer Docker Compose sur Ubuntu (Guide étape par étape) ». Bien que l'installation diffère, en général, l'utilisation réelle consiste à supprimer le trait d'union des appels docker-compose pour devenir docker compose. Pour des détails complets sur la compatibilité, consultez la documentation officielle de Docker sur la compatibilité des commandes entre le nouveau compose et l'ancien docker-compose.

Étape 1 — Installer Docker Compose

Il existe deux façons d'installer Docker Compose sur Ubuntu :

  • Installer via le dépôt
  • Installer manuellement

Nous aborderons les deux manières dans cette section.

Installation de Docker Compose en utilisant le dépôt apt

Tout d'abord, configurons le dépôt Docker apt.

# Add Docker's official GPG key:

sudo apt-get update

sudo apt-get install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc



# Add the repository to Apt sources:

echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \

  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \

  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Maintenant, vous pouvez installer Docker Compose en utilisant la commande suivante :

sudo apt install docker-compose-plugin

Docker Compose est maintenant installé avec succès sur votre système. Pour vérifier que l'installation a réussi, vous pouvez exécuter :

docker compose version

Vous verrez une sortie similaire à ceci :

Docker Compose version v2.3.3

Installation manuelle de Docker Compose

Pour vous assurer d'obtenir la version stable la plus récente de Docker Compose, vous téléchargerez ce logiciel depuis son dépôt officiel sur Github.

Tout d'abord, confirmez la dernière version disponible sur leur page des releases. Au moment de la rédaction de cet article, la version stable la plus récente est v2.40.2.

Utilisez la commande suivante pour télécharger :

mkdir -p ~/.docker/cli-plugins/

curl -SL https://github.com/docker/compose/releases/download/v2.40.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose

Ensuite, définissez les permissions correctes afin que la commande docker compose soit exécutable :

chmod +x ~/.docker/cli-plugins/docker-compose

Dans la section suivante, vous verrez comment configurer un fichier docker-compose.yml et démarrer un environnement conteneurisé avec cet outil.

Étape 2 — Configuration d'un fichier docker-compose.yml

Pour montrer comment configurer un fichier docker-compose.yml et travailler avec Docker Compose, vous allez créer un environnement de serveur web en utilisant l’image officielle Nginx depuis Docker Hub, le registre public de Docker. Cet environnement conteneurisé servira un seul fichier HTML statique.

Commencez par créer un nouveau répertoire dans votre dossier personnel, puis entrez dedans :

mkdir ~/compose-demo

cd ~/compose-demo

Dans ce répertoire, créez un dossier d'application qui servira de racine des documents pour votre environnement Nginx :

mkdir app

En utilisant votre éditeur de texte préféré, créez un nouveau fichier index.html dans le dossier app :

nano app/index.html

Placez le contenu suivant dans ce fichier :

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>

Enregistrez et fermez le fichier une fois que vous avez terminé. Si vous utilisez nano, vous pouvez le faire en tapant CTRL+X, puis Y et ENTRÉE pour confirmer.

Ensuite, créez le fichier docker-compose.yml :

nano docker-compose.yml

Insérez le contenu suivant dans votre fichier docker-compose.yml :

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

Dans Docker Compose moderne, le champ version est optionnel et souvent omis, car Compose peut détecter automatiquement la version de la configuration. L'exemple ci-dessus n'inclut pas de champ version, ce qui est l'approche recommandée pour la plupart des nouveaux projets. Vous n'avez besoin de spécifier version que pour la compatibilité avec les anciens projets.

Vous avez ensuite le bloc services, où vous configurez les services qui font partie de cet environnement. Dans votre cas, vous avez un seul service appelé web. Ce service utilise l'image nginx:alpine et configure une redirection de port avec la directive ports. Toutes les requêtes sur le port 8000 de la machine hôte (le système à partir duquel vous exécutez Docker Compose) seront redirigées vers le conteneur web sur le port 80, où Nginx sera en cours d'exécution.

La directive volumes créera un volume partagé entre la machine hôte et le conteneur. Cela partagera le dossier local app avec le conteneur, et le volume sera situé à /usr/share/nginx/html à l'intérieur du conteneur, ce qui remplacera alors le répertoire racine par défaut de Nginx.

Enregistrez et fermez le fichier.

Vous avez mis en place une page de démonstration et un fichier docker-compose.yml pour créer un environnement de serveur web conteneurisé qui la servira. Dans l'étape suivante, vous allez lancer cet environnement avec Docker Compose.

Étape 3 — Exécution de Docker Compose

Avec le fichier docker-compose.yml en place, vous pouvez maintenant exécuter Docker Compose pour démarrer votre environnement. La commande suivante téléchargera les images Docker nécessaires, créera un conteneur pour le service web et exécutera l'environnement containerisé en mode arrière-plan :

docker compose up -d

Docker Compose recherchera d'abord l'image définie sur votre système local, et si elle ne peut pas localiser l'image, elle la téléchargera depuis Docker Hub. Vous verrez une sortie comme ceci :

Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

Remarque : Si vous rencontrez une erreur « permission refusée » lors de l’exécution de docker compose up, cela signifie généralement que votre utilisateur non-root n’a pas la permission d’accéder au socket du démon Docker.

Par défaut, le démon Docker se lie à un socket Unix (/var/run/docker.sock) qui est détenu par l’utilisateur root. Pour résoudre ce problème, vous devez ajouter votre utilisateur non-root au groupe docker, qui est créé lors de l’installation de Docker.

Exécutez la commande suivante pour ajouter votre utilisateur au groupe docker :

sudo usermod -aG docker ${USER}

Après avoir exécuté cette commande, vous devrez vous déconnecter puis vous reconnecter pour que les modifications de groupe prennent effet. Vous pouvez également activer les modifications pour la session terminal actuelle en tapant :

newgrp docker

Cette commande devrait résoudre toutes les erreurs de permission liées au socket Docker. Pour un guide complet, veuillez vous référer à l'Étape 2 de Comment installer Docker sur Ubuntu – Guide étape par étape.

Votre environnement est maintenant opérationnel en arrière-plan. Pour vérifier que le conteneur est actif, vous pouvez exécuter :

docker compose ps

Cette commande vous montrera des informations sur les conteneurs en cours d'exécution et leur état, ainsi que sur toutes les redirections de ports actuellement en place :

       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Vous pouvez maintenant accéder à l'application de démonstration en pointant votre navigateur vers localhost:8000 si vous exécutez cette démonstration sur votre machine locale, ou votre_domaine_ou_IP_serveur:8000 si vous exécutez cette démonstration sur un serveur distant.

Vous verrez une page comme celle-ci :

Le volume partagé que vous avez configuré dans le fichier docker-compose.yml maintient les fichiers de votre dossier app synchronisés avec la racine des documents du conteneur. Si vous apportez des modifications au fichier index.html, elles seront automatiquement prises en compte par le conteneur et donc reflétées sur votre navigateur lorsque vous actualiserez la page.

Dans l'étape suivante, vous verrez comment gérer votre environnement conteneurisé avec les commandes Docker Compose.

Étape 4 — Se familiariser avec les commandes Docker Compose

Vous avez vu comment configurer un fichier docker-compose.yml et démarrer votre environnement avec docker compose up. Vous allez maintenant voir comment utiliser les commandes Docker Compose pour gérer et interagir avec votre environnement conteneurisé.

Pour vérifier les journaux générés par votre conteneur Nginx, vous pouvez utiliser la commande logs :

docker compose logs

Vous verrez une sortie similaire à ceci :

Attaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Si vous voulez mettre en pause l'exécution de l'environnement sans changer l'état actuel de vos conteneurs, vous pouvez utiliser :

docker compose pause
Pausing compose-demo_web_1 ... done

Pour reprendre l'exécution après avoir émis une pause :

docker compose unpause
Unpausing compose-demo_web_1 ... done

La commande stop arrêtera l'exécution du conteneur, mais ne supprimera aucune donnée associée à vos conteneurs :

docker compose stop
Stopping compose-demo_web_1 ... done

Si vous souhaitez supprimer les conteneurs, réseaux et volumes associés à cet environnement conteneurisé, utilisez la commande down :

docker compose down
Removing compose-demo_web_1 ... done
Removing network compose-demo_default

Remarquez que cela ne supprimera pas l'image de base utilisée par Docker Compose pour lancer votre environnement (dans votre cas, nginx:alpine). De cette façon, chaque fois que vous relancerez votre environnement avec un docker compose up, le processus sera beaucoup plus rapide puisque l'image est déjà présente sur votre système.

Si vous voulez également supprimer l'image de base de votre système, vous pouvez utiliser :

docker image rm nginx:alpine
Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Remarque : Veuillez consulter notre guide sur Comment installer Docker sur Ubuntu – Guide étape par étape pour une référence plus détaillée sur les commandes Docker.

Étape 5 — Construire une application multi-services

Le véritable atout de Docker Compose réside dans la gestion de plusieurs services qui fonctionnent ensemble. L'exemple de Nginx était un service unique. Créons une application plus pratique et multi-service : un site WordPress connecté à une base de données MySQL.

Cette configuration implique deux services : wordpress (exécutant l'application) et db (exécutant la base de données). Nous utiliserons également des volumes Docker pour garantir que les données de la base de données persistent même si le conteneur est supprimé.

Créons un nouveau répertoire pour cette application :

mkdir -p ~/compose-demo/wordpressapp

cd ~/compose-demo/wordpressapp

Pour cet exemple, nous n’avons besoin d’aucun fichier local, car les images contiendront tous les logiciels nécessaires.

Créez un nouveau fichier docker-compose.yml :

nano docker-compose.yml

Collez la configuration suivante. Ce fichier est plus complexe, nous allons donc examiner chaque partie.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

volumes:
  db_data:

Remarque : Nous avons codé en dur les valeurs du mot de passe ici à des fins d'illustration. Lors de l'utilisation dans un environnement réel, assurez-vous d'utiliser des variables d'environnement dans le fichier .env afin de ne pas exposer vos informations d'identification.

Enregistrez et fermez le fichier. N'oubliez pas de remplacer les espaces réservés <^...^> par des mots de passe solides et sécurisés.

Décomposons les nouvelles directives dans ce fichier :

  • services : Ce bloc définit toujours nos conteneurs. Nous en avons maintenant deux : db et wordpress.
  • image : Nous utilisons mysql:8.0 pour la base de données et l’image wordpress:latest pour l’application.
  • container_name : Cela définit un nom spécifique et lisible par l’homme pour le conteneur, ce qui est plus facile à référencer que les noms générés automatiquement.
  • environment : Il s'agit d'une liste de variables d'environnement transmises au conteneur. L'image mysql les utilise pour définir le mot de passe root et créer une base de données et un utilisateur initiaux. L'image wordpress les utilise pour savoir comment se connecter à sa base de données.

  • volumes (niveau de service):

    • Pour le service db, db_data:/var/lib/mysql associe un volume géré par Docker nommé db_data au répertoire de données MySQL à l'intérieur du conteneur. Cela permet de sécuriser vos données.
    • Pour le service wordpress, ./wp_content:/var/www/html/wp-content mappe un répertoire local (wp_content) au répertoire de contenu de WordPress. Cela vous permet de modifier directement les thèmes et les plugins depuis votre machine hôte.
  • depends_on : Cela indique à Compose de démarrer le service db avant de démarrer le service wordpress. C’est important, car WordPress échouera s’il ne trouve pas sa base de données au démarrage.
  • volumes (niveau supérieur) : Ce bloc définit les volumes nommés. db_data : crée un volume géré par Docker, ce qui est la manière recommandée de gérer les données persistantes.

Maintenant, lancez cette application multi-services :

docker compose up -d

Compose téléchargera à la fois les images mysql et wordpress, puis créera les conteneurs, en démarrant d'abord le service db.

Creating network "compose-demo_default" with the default driver
Creating volume "compose-demo_db_data" with default driver
Pulling db (mysql:8.0)...
...
Pulling wordpress (wordpress:latest)...
...
Creating mysql_db        ... done
Creating wordpress_app ... done

Vous pouvez maintenant accéder à votre nouveau site WordPress en naviguant vers localhost:8001 ou <^votre_domaine_ou_IP_serveur<^>:8001 dans votre navigateur. Vous devriez voir l'écran d'installation de WordPress. Pour un exemple plus détaillé, consultez notre article sur Comment installer WordPress avec Docker Compose.

Étape 6 — Utiliser Docker Compose pour le développement IA/ML

Au-delà des applications web, Docker Compose est un outil extrêmement utile pour créer des environnements de science des données et d'apprentissage automatique (AI/ML) reproductibles. Les projets AI/ML sont connus pour leurs dépendances complexes, incluant des versions spécifiques de Python, des bibliothèques comme TensorFlow ou PyTorch, et des pilotes au niveau du système comme le NVIDIA CUDA Toolkit. Docker Compose capture l'intégralité de cet environnement dans des fichiers de configuration, résolvant ainsi le problème du « ça fonctionne sur ma machine », ce qui est crucial pour la recherche reproductible.

Dans cet exemple, vous allez créer un environnement AI/ML multi-services comprenant :

  • JupyterLab : Un conteneur pour le développement interactif, construit à partir d’un Dockerfile personnalisé.
  • PostgreSQL : Un conteneur de base de données pour stocker les résultats des expériences et les métadonnées.
  • Accès au GPU : Le conteneur JupyterLab sera configuré pour accéder au GPU NVIDIA de la machine hôte, une exigence courante pour l'entraînement de modèles.

Prérequis : Cet exemple nécessite une carte GPU NVIDIA sur votre machine hôte ainsi que l'installation du NVIDIA Container Toolkit. Sans cela, le conteneur ne pourra pas démarrer lors de la demande de ressources GPU.

Structure des fichiers

Tout d'abord, créez un répertoire pour votre projet. À l'intérieur, vous allez créer un fichier docker-compose.yml, un répertoire jupyter, un Dockerfile pour Jupyter, et un fichier requirements.txt. La structure devrait ressembler à ceci :

ai-project/
├── docker-compose.yml
└── jupyter/
    ├── Dockerfile
    └── requirements.txt

Création des fichiers du composant

1. Le fichier requirements.txt

Ce fichier répertorie les packages Python pour votre environnement de science des données.

nano jupyter/requirements.txt

Ajoutez vos packages requis. Pour cet exemple, nous inclurons des bibliothèques pour la manipulation des données, la connexion à une base de données et un framework d'apprentissage profond.

pandas
scikit-learn
tensorflow
jupyterlab
psycopg2-binary

Enregistrez et fermez le fichier.

2. Le Dockerfile

Ce fichier définit votre service JupyterLab personnalisé. Il utilise une image officielle de Jupyter comme base et installe les packages à partir de requirements.txt.

nano jupyter/Dockerfile

Collez le contenu suivant :

# Start from a base image that includes Jupyter and scientific libraries
FROM jupyter/scipy-notebook:latest

# Copy our local requirements file into the container
COPY requirements.txt /tmp/requirements.txt

# Install the Python packages
RUN pip install --no-cache-dir -r /tmp/requirements.txt

Ce fichier indique à Docker d'utiliser jupyter/scipy-notebook comme point de départ, de copier votre requirements.txt dans le conteneur, puis d'utiliser pip pour installer les packages.

Définir l'environnement avec docker-compose.yml

Maintenant, créez le fichier principal docker-compose.yml. Ce fichier orchestrera à la fois le service db et votre service personnalisé jupyter.

nano docker-compose.yml

Collez la configuration suivante en remplaçant les espaces réservés <^...^> par vos propres identifiants sécurisés.

services:
  db:
    image: postgres:15-alpine
    container_name: ai_postgres_db
    environment:
      POSTGRES_USER: <^your_db_user^>
      POSTGRES_PASSWORD: <^your_db_pass^>
      POSTGRES_DB: experiments
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U <^your_db_user^> -d experiments"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - ai_net

  jupyter:
    build: ./jupyter
    container_name: ai_jupyter_lab
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_USER=<^your_db_user^>
      - POSTGRES_PASSWORD=<^your_db_pass^>
      - POSTGRES_DB=experiments
    restart: unless-stopped
    networks:
      - ai_net
    depends_on:
      db:
        condition: service_healthy
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  postgres_data:
    name: ai_project_data

networks:
  ai_net:
    driver: bridge

Ce fichier de configuration présente plusieurs concepts importants :

  • build: ./jupyter : Cela indique à Docker Compose de construire une image personnalisée pour le service jupyter. Il recherche un Dockerfile dans le répertoire spécifié ./jupyter.
  • volumes: - ./notebooks:/home/jovyan/work : Cela monte un répertoire local nommé notebooks dans le conteneur. Cela garantit que tous les notebooks Jupyter que vous créez sont enregistrés directement sur votre machine hôte, les conservant même après la suppression du conteneur.
  • healthcheck : Comme indiqué dans la section de dépannage, cette vérification valide que le service db n'est pas seulement en cours d'exécution, mais prêt à accepter des connexions avant que les autres services ne démarrent.
  • depends_on: ... condition: service_healthy : Cela indique au service jupyter d'attendre que le contrôle d'état (healthcheck) du service db soit réussi avant de démarrer.

  • deploy.resources.reservations.devices : C'est le bloc qui demande l'accès au GPU.

    • driver : nvidia : Spécifie le pilote hôte à utiliser.
    • count: 1 : Demande un GPU.
    • capabilities: [gpu] : Assure que le conteneur dispose des capacités nécessaires pour utiliser le GPU.

Exploitation de l'environnement IA/ML

Avec vos fichiers en place, vous êtes prêt à construire et à exécuter les services.

  1. Depuis votre répertoire ai-project, exécutez la commande docker compose up. Vous devez ajouter l'option --build la première fois pour indiquer à Compose de construire votre image personnalisée jupyter.

    docker compose up -d --build

  2. Compose construira d'abord l'image jupyter (ce qui peut prendre quelques minutes le temps de télécharger TensorFlow), puis téléchargera l'image postgres, et enfin lancera les deux conteneurs.

    [+] Building 5.8s (9/9) FINISHED
 => [internal] load build definition from Dockerfile
...
[+] Running 3/3
 ✔ Network ai-project_ai_net        Created
 ✔ Container ai_postgres_db         Started
 ✔ Container ai_jupyter_lab         Started

  3. Vous pouvez maintenant accéder à l'interface JupyterLab en naviguant vers http://localhost:8888 (ou <^votre_ip_serveur^>:8888) dans votre navigateur. Il vous sera demandé un jeton, que vous pouvez obtenir à partir des journaux du conteneur :

    docker compose logs jupyter

    Cherchez une ligne similaire à http://127.0.0.1:8888/lab?token=a1b2c3d4e5f6...

  4. À l'intérieur d'un notebook Jupyter, vous pouvez maintenant vous connecter à votre base de données en utilisant le nom d'hôte db et les identifiants que vous avez fournis. Votre environnement a également accès au GPU de l'hôte pour l'entraînement du modèle.

Mise à l'échelle des services et utilisation de réseaux personnalisés

Docker Compose comprend des fonctionnalités pour la mise à l'échelle des services et la gestion des réseaux sur lesquels ils communiquent.

Mise à l'échelle du service avec des réplicas

Imaginez que votre serveur web Nginx de l'étape 2 reçoit trop de trafic. Vous pouvez mettre à l'échelle le service web pour exécuter plusieurs instances de conteneurs. Docker Compose peut gérer cela automatiquement.

Il existe deux principales façons de faire évoluer un service.

1. Utilisation de la clé replicas (Préféré en v2)

Vous pouvez définir le nombre souhaité d'instances directement dans votre fichier docker-compose.yml en utilisant les clés deploy et replicas. Cette fonctionnalité faisait à l'origine partie de Docker Swarm, mais elle est désormais disponible pour les déploiements Compose standard.

Modifiez votre docker-compose.yml de Nginx à partir de l'Étape 2 :

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3

Lorsque vous exécutez docker compose up -d, Compose créera trois conteneurs web. Cependant, vous rencontrerez un problème : les trois tenteront de se lier au port hôte 8000. Cela provoquera une erreur « le port est déjà attribué » pour le deuxième et le troisième conteneur. Pour résoudre ce problème dans une configuration de production, vous devriez supprimer le mappage ports du service web. De cette manière, les conteneurs web ne sont accessibles que depuis le réseau Docker. Un service séparé de répartition de charge serait le seul à disposer d’un port public. Il distribuerait ensuite le trafic vers les trois répliques web.

Un exemple de configuration ressemblerait à ceci (c'est un exemple avancé) :

services:
  web:
    image: nginx:alpine
    # No 'ports' mapping here.
    # The service is only accessible inside the 'web-net' network.
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3
    networks:
      - web-net

  load_balancer:
    image: nginx:latest
    ports:
      - "80:80" # The load_balancer is the only service with a public port.
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf # A config file that load balances to 'web'.
    networks:
      - web-net
    depends_on:
      - web

networks:
  web-net:

Dans cette configuration, le load_balancer écoute sur le port 80 et redirige les requêtes vers web_1, web_2 et web_3 en interne.

Cette clé replicas est surtout utile lorsqu'elle est utilisée avec un reverse proxy (comme Traefik ou une autre instance Nginx) qui peut équilibrer la charge des requêtes entre les répliques au sein du réseau Docker, sans que chaque réplique ait besoin d'exposer un port sur l'hôte.

2. Utilisation de l’option --scale

Une méthode courante pour le scaling est le paramètre --scale, hérité de Compose v1. Ce paramètre est appliqué au moment de l'exécution et remplace toute clé replicas.

Cependant, vous devez faire attention aux définitions de ports. Si votre service définit un mappage de port hôte fixe (par exemple, "8000:80"), exécuter docker compose up --scale provoquera une erreur pour le deuxième et le troisième conteneur, car ils tenteront tous de se lier au même port hôte.

Pour utiliser --scale pour des services qui exposent des ports, vous ne devez pas utiliser de mappage de port fixe sur l'hôte.

  • Option 1 : Mapper sur des ports hôtes aléatoires (idéal pour le développement)

    Vous pouvez modifier votre docker-compose.yml pour spécifier uniquement le port du conteneur. Cela indique à Docker de mapper le port 80 de chaque conteneur sur un port aléatoire disponible sur votre machine hôte.

    services:
  web:
    image: nginx:alpine
    ports:
      - "80" # No fixed host port
    volumes:
      - ./app:/usr/share/nginx/html

    Maintenant, lorsque vous exécutez la commande scale :

    docker compose up -d --scale web=3

    Exécutez docker compose ps pour voir le résultat. Chaque conteneur fonctionnera sur un port hôte différent, attribué aléatoirement :

          Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49154->80/tcp
compose-demo-web_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49155->80/tcp
compose-demo-web_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49156->80/tcp

    • docker-compose.yml - Correct pour --scale

  • Option 2 : Utiliser un proxy inverse (idéal pour la production)

    L'autre solution, comme mentionné dans la section replicas, est de supprimer complètement la directive ports du service web. Vous utiliseriez alors un conteneur de répartition de charge séparé (qui possède le seul port public) pour gérer et distribuer le trafic vers les répliques mises à l'échelle à l'intérieur du réseau Docker.

    Pour arrêter et supprimer les trois conteneurs, la commande reste la même :

    docker compose down

Configuration réseau personnalisée

Par défaut, Docker Compose crée un seul réseau bridge pour votre application. Chaque service du fichier y est attaché, ce qui explique comment le conteneur wordpress a pu trouver le conteneur db simplement en utilisant le nom de son service (db).

Cependant, vous pouvez définir vos propres réseaux personnalisés pour une meilleure isolation et un meilleur contrôle.

Modifions l'exemple WordPress pour utiliser un réseau bridge personnalisé.

services:
  db:
    image: mysql:8.0
    ...
    networks:
      - app_net

  wordpress:
    image: wordpress:latest
    ...
    ports:
      - "8001:80"
    depends_on:
      - db
    networks:
      - app_net

volumes:
  db_data:

networks:
  app_net:
    driver: bridge

Voici ce que nous avons ajouté :

  • réseaux (niveau supérieur) : Cela définit un nouveau réseau nommé app_net et précise qu'il doit utiliser le pilote standard bridge.
  • réseaux (niveau service) : Sous db et wordpress, cette clé les relie à notre réseau app_net.

Si vous aviez un troisième service (comme un outil d'analyse) que vous n'aviez pas attaché à app_net, il serait complètement isolé et incapable de communiquer avec les conteneurs db ou wordpress.

Pour le clustering multi-hôtes avec Docker Swarm, vous devez changer le driver de bridge à overlay. Le driver bridge est destiné à la communication entre les conteneurs sur un seul hôte, ce qui est la norme pour la plupart des cas d'utilisation de Docker Compose.

Utilisation de fichiers de configuration modulaires

À mesure que vos applications se développent, votre fichier docker-compose.yml peut devenir volumineux et difficile à gérer. Docker Compose prend en charge la directive include, vous permettant de répartir votre configuration sur plusieurs fichiers.

Imaginez que vous souhaitez séparer vos définitions WordPress et base de données, et peut-être avoir un docker-compose.override.yml commun pour les paramètres spécifiques au développement (comme lier un port sur la base de données).

La structure de votre répertoire pourrait ressembler à ceci :

compose-demo/
├── docker-compose.yml
├── docker-compose.db.yml
├── docker-compose.web.yml

Ce fichier définira uniquement le service db.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

volumes:
  db_data:

Ce fichier définira uniquement le service wordpress.

services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

Maintenant, votre fichier principal docker-compose.yml devient très simple. Il utilise simplement include pour intégrer les autres fichiers.

include:
  - docker-compose.db.yml
  - docker-compose.web.yml

Lorsque vous exécutez docker compose up -d, Compose lira les trois fichiers, fusionnera les configurations et démarrera les services db et wordpress exactement comme s'ils étaient définis dans un seul fichier. Cette approche rend votre configuration beaucoup plus modulaire et réutilisable.

Remarque : La directive include : nécessite Docker Compose v2.20 ou une version ultérieure. Si votre système utilise une version plus ancienne, vous pouvez combiner les fichiers en utilisant docker compose -f docker-compose.db.yml -f docker-compose.web.yml up.

Migration de docker-compose (v1) vers docker compose (v2)

La commande docker compose que vous avez installée à l'étape 1 est « Compose v2 ». C'est un plugin basé sur Go intégré directement dans l'interface en ligne de commande Docker.

La version originale, « Compose v1 », était un outil Python distinct lancé avec docker-compose (avec un trait d'union). Depuis juillet 2023, Compose v1 n’est plus pris en charge et a été déprécié.

Principales modifications et compatibilité avec les versions précédentes

  • La commande : Le changement le plus évident concerne la commande. Le trait d'union (docker-compose) est désormais remplacé par un espace (docker compose).
  • Installation : la version v1 a été installée avec pip. La version v2 est incluse avec Docker Desktop ou installée en tant que plugin CLI, comme vous l'avez fait à l'Étape 1.
  • Fichiers YAML : Vos fichiers docker-compose.yml sont presque 100 % compatibles avec les versions précédentes. Compose v2 prend entièrement en charge les versions de fichiers 3.x. Vous n'avez pas besoin de modifier vos fichiers YAML pour la migration, seulement vos commandes.
  • --project-name option : L'option -p fonctionne toujours, mais l'option complète est maintenant --project-name au lieu de --project_name.

Guide de migration des commandes

La plupart des commandes sont identiques, juste sans le trait d'union. Voici un tableau comparant les commandes courantes de la version 1 avec leurs équivalents de la version 2.

Commande docker-compose (v1)Commande docker compose (v2)Notes
docker-compose up -d
docker compose up -d
Aucun changement dans la syntaxe.
docker-compose down
docker compose down
Aucun changement dans la syntaxe.
docker-compose ps
docker compose ps
Aucun changement dans la syntaxe.
docker-compose logs
docker compose logs
Aucun changement dans la syntaxe.
docker-compose stop
docker compose stop
Aucun changement dans la syntaxe.
docker-compose build
docker compose build
Aucun changement dans la syntaxe.
docker-compose exec web bash
docker compose exec web bash
Aucun changement dans la syntaxe.
docker-compose run web bash
docker compose run web bash
run crée un nouveau conteneur. exec s'exécute dans un conteneur existant.
docker-compose up --scale web=3
docker compose up --scale web=3
Le drapeau --scale est toujours pris en charge dans la v2.

Comme vous pouvez le voir, pour la plupart des utilisations quotidiennes, le seul changement est docker-compose -> docker compose. Si vous utilisez des scripts, vous pouvez les mettre à jour simplement en supprimant le trait d'union.

Si vous avez encore l'ancien docker-compose v1 installé, vous pouvez le supprimer pour éviter toute confusion :

sudo pip3 uninstall docker-compose

Ou, si cela a été installé avec apt :

sudo apt remove docker-compose

Résolution des problèmes courants de Docker Compose

Lorsque vous travaillez avec Docker Compose, vous pouvez rencontrer des problèmes liés à la syntaxe des fichiers, aux permissions ou aux conflits d'exécution des conteneurs. La plupart des problèmes peuvent être diagnostiqués et résolus en vérifiant méthodiquement votre configuration, vos permissions et les journaux des conteneurs.

Examinons certaines des erreurs les plus courantes et leurs solutions.

Permission refusée (Socket Docker)

C'est l'une des erreurs les plus courantes chez les nouveaux utilisateurs de Docker. Vous exécutez docker compose up et voyez un message d'erreur concernant le socket du démon Docker.

permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

  • Problème : Votre utilisateur non-root n'a pas la permission de communiquer avec le démon Docker, qui s'exécute en tant que root.

  • Solution : Vous devez ajouter votre utilisateur au groupe docker, qui a été créé lors de l’installation de Docker.

    1. Ajoutez votre utilisateur au groupe docker :

      sudo usermod -aG docker ${USER}

    2. Pour que la nouvelle adhésion au groupe prenne effet, vous devez vous déconnecter et vous reconnecter.

    3. Sinon, vous pouvez activer les modifications de groupe pour votre session de terminal actuelle en tapant :

      newgrp docker

    Cela devrait résoudre toutes les erreurs d'autorisation liées au socket Docker.

Erreurs de syntaxe et d'indentation YAML

Docker Compose ne parvient pas à s'exécuter et indique que votre fichier docker-compose.yml est invalide.

ERROR: The Compose file './docker-compose.yml' is invalid because:
services.web.ports contains an invalid type, it should be a list

Or :

mapping values are not allowed in this context at line 5
  • Problème : Le fichier docker-compose.yml dépend d'une syntaxe YAML stricte. L'erreur la plus courante est une indentation incorrecte. YAML utilise des espaces, pas des tabulations, pour définir la structure.

  • Solution : Vérifiez attentivement l'indentation de votre fichier docker-compose.yml.

    • La norme est deux espaces pour chaque niveau d'indentation.
    • Assurez-vous que toutes les clés au même niveau (comme version, services, volumes) commencent à la même colonne.
    • Assurez-vous que toutes les sous-clés (comme image, ports, volumes sous un service) sont indentées de deux espaces de plus que leur service parent (par exemple, web ).
    • Utilisez un éditeur de code avec un linter YAML pour mettre automatiquement en évidence les erreurs de syntaxe.

Conflits portuaires

Vous essayez de démarrer votre environnement, mais la commande échoue avec un message d'erreur indiquant que l'adresse est déjà utilisée.

Error starting userland proxy: listen tcp 0.0.0.0:8000: bind: address already in use

  • Problème : Un autre processus sur votre machine hôte écoute déjà sur le port que vous essayez de mapper (dans ce cas, le port 8000). Il s'agit souvent d'un autre conteneur Docker ou d'un serveur de développement local.

  • Solution : Vous avez deux options :

    1. Arrêtez l'autre processus. Vous pouvez trouver le processus utilisant le port avec cette commande :

      sudo lsof -i :8000

      S'il s'agit d'un autre conteneur Docker, arrêtez-le avec docker stop <container_id>.

    2. Changez le port hôte dans votre fichier docker-compose.yml. C'est souvent la solution la plus simple. Modifiez le mappage ports de "8000:80" à un autre port, comme "8001:80".

      ...
ports:
  - "8001:80" # Changed from 8000
...

      3. docker-compose.yml

Le service échoue avec Connexion refusée (depends_on)

Dans une application multi-service (comme l'exemple WordPress et MySQL), le conteneur wordpress démarre mais ses journaux affichent Connexion refusée ou Le serveur MySQL a disparu lorsqu'il essaie de se connecter au service db.

  • Problème : Vous avez utilisé depends_on, mais cette directive ne fait que attendre que le conteneur db démarre. Elle ne garantit pas que l'application MySQL à l'intérieur du conteneur soit entièrement initialisée et prête à accepter des connexions.

  • Solution : L'application (dans ce cas, WordPress) doit être configurée pour réessayer sa connexion. La plupart des images modernes ont cette logique de réessai intégrée. Pour les images qui ne l'ont pas, vous devez mettre en place un contrôle de santé.

    Vous pouvez ajouter un healthcheck à votre service db. Le depends_on du service wordpress peut alors être configuré pour attendre que la base de données soit « healthy », et pas seulement « started ».

Exemple de vérification de santé pour MySQL :

services:
  db:
    image: mysql:8.0
    ...
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p<^your_root_password_here<^>"]
      interval: 10s
      timeout: 5s
      retries: 5

  wordpress:
    image: wordpress:latest
    ...
    depends_on:
      db:
        condition: service_healthy # This now waits for the healthcheck
    ...

Erreurs avec les volumes et les montages de liaison

Vous pouvez rencontrer des erreurs d'autorisation dans les journaux de votre conteneur, ou constater que le répertoire de données de votre conteneur est vide.

Permissions des fichiers/dossiers

  • Problème : Le conteneur s’exécute en tant qu’utilisateur spécifique (par exemple, www-data avec l’ID utilisateur 33), mais le répertoire hôte que vous avez monté appartient à votre utilisateur (par exemple, ubuntu avec l’ID utilisateur 1000). L’utilisateur du conteneur n’a pas la permission d’écrire dans le répertoire hôte.

  • Solution : Changez la propriété du répertoire hôte pour qu'elle corresponde à l'ID utilisateur à l'intérieur du conteneur. Vous pouvez trouver l'ID utilisateur du conteneur en exécutant docker compose exec <service_name> id. Par exemple, si l'ID est 33 (commun pour www-data) :

    sudo chown -R 33:33 ./wp_content

Problèmes de chemin relatif

  • Problème : Votre docker-compose.yml utilise un chemin relatif comme ./app, mais votre fichier index.html n'est pas servi.

  • Solution : Docker Compose interprète les chemins relatifs à partir du répertoire où vous exécutez la commande docker compose up. Exécutez toujours les commandes Compose depuis le même répertoire qui contient votre fichier docker-compose.yml.

Réseautage et découverte de services

Les journaux de votre conteneur d'application affichent Hôte non trouvé ou Impossible de résoudre l'hôte : db.

  • Problème : Votre conteneur wordpress ne parvient pas à trouver le conteneur db sur le réseau.

  • Solution : Par défaut, Docker Compose crée un réseau et y connecte tous les services. Les services peuvent se trouver les uns les autres en utilisant leurs noms de service.

    1. Vérifiez les noms de services : Assurez-vous que le nom d'hôte dans la configuration de votre application (par exemple, la variable d'environnement WORDPRESS_DB_HOST) est exactement le même que le nom du service dans votre docker-compose.yml (par exemple, db).

    2. Inspecter le réseau : Utilisez docker compose ps pour trouver le nom de votre projet (par exemple, compose-demo). Ensuite, inspectez le réseau par défaut :

      docker network inspect compose-demo_default

      La sortie JSON listera tous les conteneurs connectés à ce réseau. Si l'un de vos services est manquant, vérifiez votre docker-compose.yml pour toute configuration personnalisée de networks qui pourrait l'isoler.

Incompatibilité de commande (v1 contre v2)

Vous tapez docker-compose up (avec un trait d'union) et voyez une erreur « commande introuvable ».

docker-compose: command not found
  • Problème : Vous essayez d'utiliser la commande pour Compose v1, qui est un outil Python obsolète. Ce guide installe Compose v2, qui est un plugin intégré directement dans le CLI Docker.
  • Solution : Utilisez la commande correcte en remplaçant le trait d'union (-) par un espace.
docker-compose (v1)docker compose (v2)
docker-compose updocker compose up
docker-compose downdocker compose down
docker-compose psdocker compose ps
docker-compose logsdocker compose logs

Utilisez toujours docker compose (avec un espace) lorsque vous suivez ce guide.

FAQ

1. À quoi sert Docker Compose ?

Docker Compose est un outil pour définir et exécuter des applications Docker multi-conteneurs.

Il utilise un seul fichier YAML (par défaut, docker-compose.yml) pour configurer tous les composants de votre application, appelés services. Ce fichier définit également les réseaux qui permettent aux services de communiquer entre eux ainsi que les volumes utilisés pour les données persistantes.

Avec ce seul fichier, vous pouvez gérer l'ensemble de votre pile d'applications avec des commandes simples :

  • docker compose up démarre et exécute l'ensemble de votre application, y compris tous les conteneurs, réseaux et volumes spécifiés.
  • docker compose down arrête et supprime tous les conteneurs, réseaux et volumes créés par votre application.

Il est particulièrement utile pour gérer des applications nécessitant plusieurs composants, comme un site web qui a besoin d'un serveur web (comme Nginx), d'un backend d'application (comme WordPress) et d'une base de données (comme MySQL).

2. Comment installer Docker Compose sur Ubuntu ?

La méthode recommandée consiste à installer Docker Compose en tant que plugin pour l’interface en ligne de commande Docker. Cela se fait en installant le paquet docker-compose-plugin depuis le dépôt apt officiel de Docker.

  1. Tout d'abord, assurez-vous d'avoir suivi la documentation officielle de Docker pour configurer le dépôt apt de Docker sur votre système Ubuntu.

  2. Mettez à jour la liste de vos paquets :

    sudo apt update

  3. Installez le plugin Docker Compose :

    sudo apt install docker-compose-plugin

  4. Vérifiez l'installation en vérifiant la version. La commande utilise un espace, pas un trait d'union.

    docker compose version

3. Comment puis-je mettre à jour Docker Compose vers la dernière version ?

Parce que Docker Compose (v2) est installé comme un paquet système via apt, vous pouvez le mettre à jour en utilisant le processus standard de mise à jour des logiciels d'Ubuntu.

  1. Actualisez l'index de vos paquets locaux :

    sudo apt update

  2. Exécutez une mise à jour du système complète, qui inclura le plugin Compose :

    sudo apt upgrade

    Sinon, si vous voulez seulement mettre à jour le plugin lui-même, vous pouvez exécuter :

    sudo apt install --only-upgrade docker-compose-plugin

4. Docker Compose peut-il être utilisé dans des environnements de production ?

Oui, Docker Compose est fréquemment utilisé en production, en particulier pour les applications qui s'exécutent sur un hôte unique.

Il offre un moyen simple de définir, déployer et gérer le cycle de vie des services, réseaux et volumes de votre application. Pour un déploiement sur un seul serveur, c'est une solution très efficace et facile à gérer.

Pour des scénarios plus complexes nécessitant la coordination de conteneurs sur plusieurs hôtes (un cluster), d'autres outils sont plus couramment utilisés. Parmi eux, le Docker Swarm (qui utilise une syntaxe de fichier Compose similaire) et Kubernetes (qui est la norme de l'industrie pour l'orchestration de conteneurs à grande échelle).

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

Ce tableau présente les principales différences entre l'interface en ligne de commande Docker et l'interface en ligne de commande Docker Compose.

Fonctionnalitédocker (Moteur Docker)docker compose (Plugin Compose)
PortéeGère les objets Docker individuels.Gère une application complète à plusieurs conteneurs comme une seule unité.
Usage principalCréation d’images (docker build), exécution de conteneurs uniques (docker run), gestion des conteneurs (docker ps), des images, des volumes et des réseaux.Orchestrer plusieurs services définis dans un fichier docker-compose.yml.
CommandesCommandes de bas niveau concentrées sur un seul objet. Exemple : docker run -d -p 80:80 -v ./:/app nginxCommandes de haut niveau pour l'ensemble de l'application. Exemple : docker compose up
AnalogieUn élément de construction (un conteneur unique).Le plan et le responsable de la construction de l'ensemble du bâtiment (la demande).

En résumé, vous utilisez docker pour interagir avec un seul conteneur. Vous utilisez docker compose pour gérer l'ensemble de votre pile d'applications (par exemple, web, app, db) en une seule fois.

6. Comment exécuter plusieurs conteneurs avec Docker Compose ?

Vous exécutez plusieurs conteneurs en les définissant comme des services dans votre fichier docker-compose.yml.

  1. Créez un fichier nommé docker-compose.yml.

  2. Dans ce fichier, utilisez la clé services : pour définir chaque conteneur que vous souhaitez exécuter.

    Voici un exemple pratique qui définit et exécute deux conteneurs : un site WordPress et une base de données MySQL.

    services:
  db:
    # This is the first service (container)
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: <^your_password_here<^>
      MYSQL_DATABASE: wordpress
    volumes:
      - db_data:/var/lib/mysql

  wordpress:
    # This is the second service (container)
    image: wordpress:latest
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_PASSWORD: <^your_password_here<^>
    depends_on:
      - db

volumes:
  db_data:

    3. docker-compose.yml

  3. Enregistrez le fichier et ouvrez un terminal dans le même répertoire.

  4. Exécutez une seule commande pour démarrer les deux conteneurs :

    docker compose up -d

Docker Compose lira le fichier, créera un réseau partagé pour les services, téléchargera les images mysql et wordpress, et démarrera un conteneur pour chaque service.

7. Pourquoi utiliser Docker Compose pour le développement ?

Docker Compose est un outil standard pour les environnements de développement car il résout plusieurs problèmes courants.

  • Environnements cohérents : Il assure que chaque développeur d'une équipe utilise exactement les mêmes services (base de données, cache, serveur web) avec les mêmes versions et configurations. Cela est défini dans le fichier docker-compose.yml, qui est ajouté au contrôle de version. Cela élimine le problème du « ça marche sur ma machine ».

  • Simplicité : Il remplace les scripts d'installation complexes et les longues commandes docker run. Un développeur n'a besoin que d'exécuter docker compose up pour démarrer l'ensemble de la pile d'applications et docker compose down pour l'arrêter.

  • Isolation des services : Les développeurs peuvent travailler sur plusieurs projets sur la même machine sans conflits de dépendances. Le projet A peut utiliser PostgreSQL 9.6 et le projet B peut utiliser PostgreSQL 14, chaque base de données fonctionnant dans un conteneur isolé géré par son propre fichier Compose.

  • Tests d'intégration faciles : Parce que Compose démarre toutes les dépendances d'une application en même temps, il crée un environnement local idéal pour exécuter des tests d'intégration qui vérifient comment les services interagissent entre eux.

Conclusion

Dans ce guide, vous avez installé Docker Compose et configuré une application complète à plusieurs conteneurs. Vous avez commencé avec un fichier de base docker-compose.yml pour un serveur web Nginx et avez progressé vers une pile plus complexe et réaliste impliquant une application WordPress et une base de données MySQL. Vous avez appris à gérer l'ensemble du cycle de vie de l'application, de la création et l'exécution des services à leur arrêt et suppression.

Vous êtes maintenant familiarisé avec les concepts clés pour gérer efficacement les applications, y compris la mise à l'échelle des services, les définitions de réseau personnalisées et la division de votre configuration en fichiers modulaires à l'aide de la directive include. En suivant le guide de migration et les étapes de dépannage, vous pouvez également résoudre des problèmes courants tels que les conflits de ports, les erreurs « Permission refusée » et les erreurs de syntaxe YAML. Les compétences abordées ici vous permettront de créer des environnements de développement cohérents et reproductibles et de déployer des applications sur un seul hôte en toute confiance.

Pour une référence complète de toutes les commandes docker compose disponibles, consultez la documentation officielle.

Pour plus de tutoriels liés à Docker, consultez les articles suivants :

  • Comment installer Docker sur Ubuntu – Guide étape par étape
  • Comment installer WordPress avec Docker Compose

Merci d'apprendre avec la communauté Linux-Console.net.