Archives Wild Code School
Docker

Docker - Compose

Quête 4 sur 8 · 2 images archivées

Introduction

Dans cette quête sur Docker Compose, tu vas apprendre les bases de cet outil puissant qui te permet de gérer et de déployer tes applications multi-conteneurs.

spacer

Logo Docker compose

🤓 Objectifs :

✅ Comprendre le rôle et l'importance de Docker Compose dans le déploiement d'applications
✅ Maîtriser les commandes de base de Docker Compose ✅ Savoir créer des services à l'aide de Docker Compose

Sommaire

:point_right: Qu'est-ce que Docker Compose ?

Docker compose est un outil utilisé pour organiser l'instanciation de plusieurs conteneurs.

Lorsqu’on utilise juste Docker, gérer plusieurs conteneurs différents peut vite devenir fastidieux.

Docker Compose permet de les orchestrer plus facilement.

Docker Compose est une extension de Docker (un plugin de la CLI Docker-CE) qui permet de définir et de gérer des applications multi-conteneurs grâce à des fichiers de configuration simples utilisant le langage YAML. Docker Compose est étroitement lié à Docker Engine, car il utilise l'API de Docker Engine pour créer et gérer des conteneurs.

Plutôt que de gérer manuellement chaque conteneur individuellement, Docker Compose permet de déclarer les services, les réseaux, les volumes dans un seul fichier. Ensuite, avec une seule commande, tu crées et démarre tous les services à partir de ton fichier de configuration.

Docker compose est principalement utilisé pour déployer des applications multi-conteneurs dans un environnement à noeud Docker unique.

Bravo

Comme introduction à Docker compose, tu peux regarder la vidéo suivante :

▶
Vidéo YouTube
https://www.youtube.com/watch?v=F8SopumoYNs

:point_right: Installation de Docker Compose

Sans plus tarder, je te propose d'installer Docker compose afin de passer tout de suite à la pratique.

↗
https://docs.docker.com/compose/install/

Pour installer Docker Compose, tu peux suivre les instructions fournies dans la documentation officielle de Docker.

docs.docker.com

Une fois installé, tu peux vérifier si Docker Compose fonctionne correctement en exécutant la commande suivante :

bash
wilder@docker1:~$ docker compose version
Docker Compose version v2.24.7

Assure-toi d'avoir une sortie similaire.

:point_right: Cas pratique

Pour apprendre à utiliser Docker compose, je te propose d'utiliser un exemple dans lequel nous avons besoin d'une stack Wordpress , qui sera composée d'un conteneur frontal Wordpress et d'un conteneur backend base de données Mysql.

  • Notre service Wordpress sera accessible sur le port 80 de l'hôte Docker sur un réseau personnalisé de type bridge nommé frontend .
  • Notre frontend WordPress discutera avec son serveur de base de données sur un second réseau personnalisé de type bridge nommé backend.
  • Le frontend et le backend auront chacun besoin de volumes pour leurs données persistantes
  • Des variables d'environnement devront être définies notamment pour la base de données.

Stack Wordpress

Bravo

Dans un premier temps, nous allons déployer manuellement ces conteneurs à l'aide de commandes ad-hoc de Docker, puis nous utiliserons Docker Compose pour simplifier et automatiser ce processus.

C'est parti !

:point_right: Déploiement de la stack WordPress sans Docker Compose

Premièrement, créons les réseaux backend et frontend :

bash
# Création du réseau personnalisé `backend` : 
wilder@docker1:~$ docker network create backend 

# Création du réseau personnalisé `frontend` :
wilder@docker1:~$ docker network create frontend

Puis, créons et configurons le conteneur MySQL :

bash
# Création du conteneur `wordpress_db` : 
wilder@docker1:~$ docker run -d --name wordpress_db \
   --network backend \
   -e MYSQL_ROOT_PASSWORD=V%*gWsNw5ah!YmERQejbA3F7t \
   -e MYSQL_DATABASE=wordpress \
   -e MYSQL_USER=wordpress \
   -e MYSQL_PASSWORD=e248*s7Mx!wbzdJ#$PWBg3rTFj \
   -v db_data:/var/lib/mysql \
   mysql:8.0

Ensuite, déployons le conteneur WordPress :

bash
# Création du conteneur `wordpress` : 
wilder@docker1:~$ docker run -d --name wordpress \
   --network backend \
   --network frontend -p 80:80 \
   -e WORDPRESS_DB_HOST=wordpress_db:3306 \
   -e WORDPRESS_DB_USER=wordpress \
   -e WORDPRESS_DB_PASSWORD=e248*s7Mx!wbzdJ#$PWBg3rTFj \
   -e WORDPRESS_DB_NAME=wordpress \
   -v wp_data:/var/www/html \
   wordpress:latest

Résultat :

  1. Création des réseaux Docker :

    • Un réseau Docker nommé backend est créé, permettant aux conteneurs de communiquer entre eux de manière isolée.
    • Un second réseau nommé frontend est créé

  2. Création des volumes Docker :

    • Deux volumes Docker sont créés : db_data et wp_data, utilisés respectivement pour stocker les données de la base de données MySQL et de WordPress.

  3. Conteneur MySQL (wordpress_db) :

    • Un conteneur MySQL est lancé avec l'image mysql:8.0.
    • Il est connecté au réseau backend.
    • Les variables d'environnement sont configurées pour définir le mot de passe root, la base de données, l'utilisateur et le mot de passe de MySQL.
    • Un volume Docker est monté pour stocker les données de la base de données MySQL.

  4. Conteneur WordPress (wordpress) :

    • Un conteneur WordPress est lancé avec l'image wordpress:latest.
    • Il est connecté aux réseaux backend et frontend.
    • Le port 80 du conteneur est exposé sur le port 80 de l'hôte.
    • Les variables d'environnement sont configurées pour définir l'hôte de la base de données MySQL, l'utilisateur, le mot de passe et le nom de la base de données WordPress.
    • Un volume Docker est monté pour stocker les données de WordPress.
Attention

Notre stack Wordpress est tout à fait fonctionnelle, sauf qu'on pourrait se retrouver avec plusieurs problématiques liées à son administration :

  • Complexité de gestion : Sans Docker Compose, tu devras gérer chaque conteneur individuellement, ce qui peut devenir fastidieux et propice aux erreurs. Tu devras créer des scripts personnalisés ou exécuter des commandes Docker distinctes pour chaque conteneur, ce qui rend la gestion plus complexe.
  • Incohérence de configuration : La configuration de chaque conteneur pourrait différer d'un environnement à l'autre, car elle serait définie individuellement. Cela pourrait entraîner des erreurs de déploiement et une gestion incohérente des services.
  • Gestion des dépendances : Sans Docker Compose, la gestion des dépendances entre les différents services devient plus compliquée. Tu devras t'assurer manuellement que les services nécessaires sont démarrés dans le bon ordre, ce qui peut être source d'erreurs et de temps perdu.
  • Difficulté à reproduire l'environnement : Il serait plus difficile de reproduire l'environnement de développement ou de production sur différentes machines. Chaque développeur devrait configurer manuellement les services nécessaires, ce qui pourrait entraîner des différences entre les environnements et des problèmes de compatibilité.
  • Manque de scalabilité : Sans Docker Compose, l'ajout de nouveaux services ou la mise à l'échelle des services existants pourrait être plus difficile à gérer. Tu devras modifier manuellement la configuration de chaque conteneur.

Bref, tu l'auras compris, c'est plutôt compliqué, pas infaisable mais compliqué. Et encore, dans notre exemple nous avons utilisé une stack qui contient seulement 2 conteneurs. Imagine une application composée de 4, 5 voire 10 conteneurs ... C'est une autre histoire !!!

Nous allons maintenant déployer notre stack Wordpress à l'aide de Docker Compose.

:point_right: Déploiement de la stack WordPress avec Docker Compose

Info

Pour bien comprendre qu’il ne s’agit que de convertir des options de commande Docker en YAML, un site te permet de convertir une commande docker run en fichier Docker Compose : https://www.composerize.com/

Par la suite, tu pourras t'aider de ce site pour bien prendre en main les subtilités qu'imposent la rédaction d'un fichier compose.yml .

Préparation de l'environnement

1. Création du répertoire de projet

Généralement, tu vas créer un répertoire pour ton projet. Tu peux le nommer comme il te convient, mais c'est quand même plus sympa de lui donner un nom explicite en relation avec le service que tu souhaites déployer :

bash
wilder@docker1:~$ mkdir wordpress
wilder@docker1:~$ cd wordpress

2. Le fichier Docker compose

Le fichier YAML qui définit l'ensemble des services qui composent ton application (ainsi que leurs configurations, les réseaux et les volumes associés), portera le nom de  compose.yaml ou compose.yml . Tu peux aussi utiliser comme nom de fichier docker-compose.yaml et docker-compose.yml , il s'agit des noms utilisés dans les anciennes versions de Docker compose (V1 et V2) mais qui sont reconnues dans la dernière version de Docker compose.

bash
wilder@docker1:~/wordpress$ touch compose.yml

Ton arborescence doit être similaire à ceci :

bash
wilder@docker1:~$ tree
.
└── wordpress
    └── compose.yml

A partir de là, nous allons configurer notre stack en éditant ce fichier compose.yml

bash
wilder@docker1:~/wordpress$ nano compose.yml

Configuration du fichier dockercompose.yml

Version de compose

La première instruction que tu trouveras dans un fichier compose.yml est la version : version: <n°> . Cette déclaration sur la version du fichier compose.yml permet de spécifier à Docker Compose quelle version on souhaite utiliser. Ici, la version 3 a été indiquée car il s’agit de la version actuellement la plus utilisée. Celle-ci permet de définir la comptabilité de notre fichier avec le moteur Docker installé sur l’hôte. A ce jour, la version la plus récente est la 3.8.

Plus d’informations sur la compatibilité des versions ici.

bash
version: '3'

Les services

Chaque service représente un conteneur. Dans notre cas de figure, nous avons besoin d'un conteneur Wordpress et d'un conteneur MySQL. L'ensemble des conteneurs qui doivent être créés doivent être définis sous l'argument services: . Chaque conteneur commence avec un nom qui lui est propre. Par exemple, ici, le premier conteneur se nommera wordpress_db (il correspondra à la base de données que l’on veut créer) et le second se nommera wordpress (et correspond au serveur frontal wordpress).

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:

  # Création d'un service Wordpress
  wordpress:
Bravo

Tu es libre de nommer tes services comme tu le souhaite

Les images

Avec l'instruction image: , tu viens déclarer les images sur lesquels tes conteneurs seront basés. Nous allons utiliser les images officielles du Docker Hub mysql:8.0 et wordpress:latest . Si rien n'est stipulé, la version latest sera utilisée.

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0

  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
Bravo

Tu pourrais même utiliser un fichier Dockerfile pour utiliser tes propres images personnalisées avec l'instruction build :

bash
version: '3'
services:
  # Création d'un service BDD en utilisant le chemin vers un fichier Dockerfile
  wordpress_db:
    build: /path/to/Dockerfile/

  # Création d'un service Wordpress en utilisant une image sur git
  wordpress:
    build: https://gitlab.com/wildcodeschool/my-project.git

Nom des conteneurs

Avec l'instruction container_name: , tu peux donner un nom spécifique au conteneur pour une identification facile :

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db

  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
    container_name: wordpress

Instruction restart: always

Comme nous utiliserons ce service dans un environnement de production, nous pouvons spécifier l'instruction restart: always afin d'indiquer que le conteneur concerné doit être redemarré automatiquement en cas d'échec ou d'arrêt :

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db
    restart: always

  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    restart: always

Exposition de port

Comme pour les commandes Docker ad-hoc, pour que notre conteneur wordpress soit accessible depuis l'extérieur, il est nécessaire d'exposer un port de l'hôte Docker et de le mapper au conteneur. Cela se fait avec l'instruction ports: :

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db
    restart: always

  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    restart: always
    ports:
      - "80:80"

Variables d'environnement

Cette instruction environment dans un fichier Docker compose vient remplacer l'instruction -e dans les commandes Docker ad-hoc :

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: V%*gWsNw5ah!YmERQejbA3F7t
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj


  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    restart: always
    ports:
      - "80:80"
    environment:
      WORDPRESS_DB_HOST: wordpress_db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
      WORDPRESS_DB_NAME: wordpress

Le réseau

On va spécifier sur quel réseau nos conteneurs vont se connecter à l'aide de l'instruction networks :

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: V%*gWsNw5ah!YmERQejbA3F7t
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
    networks:
      - backend

  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    restart: always
    ports:
      - "80:80"
    environment:
      WORDPRESS_DB_HOST: wordpress_db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
      WORDPRESS_DB_NAME: wordpress
    networks:
      - backend
      - frontend

networks:
  frontend:
  backend:
Bravo

Remarque que nous avons choisi de déclarer les réseaux en fin de fichiers et d'utiliser dans les différents services une liste pour faire appel à ces réseaux. Tu peux en savoir plus sur les options de réseaux dans un fichier Docker compose sur ce lien : https://docs.docker.com/compose/compose-file/06-networks/

Info

Docker compose crée les réseaux que tu déclares, tu n'as pas besoin de les créer auparavant !!! Le conteneur wordpress_db sera connecté au réseau backend seulement, et le conteneur wordpress sera connecté aux réseau backend et frontend .

Volumes

Comme pour les réseaux, on peut déclarer des volumes pour les différents services sans les avoir créés auparavant :

version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db
    restart: always
    ports:
      - "80:80"
    environment:
      MYSQL_ROOT_PASSWORD: V%*gWsNw5ah!YmERQejbA3F7t
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
    networks:
      - backend
    volumes:
      - db_data:/var/lib/mysql

  # Création d'un service Wordpress
  wordpress:
    image: wordpress:latest
    container_name: wordpress
    restart: always
    environment:
      WORDPRESS_DB_HOST: wordpress_db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
      WORDPRESS_DB_NAME: wordpress
    networks:
      - backend
      - frontend
    volumes:
      - wp_data:/var/www/html

networks:
  frontend:
  backend:
volumes:
  db_data:
  wp_data:
Bravo

Docker compose crée 2 volumes :

  • db_data pour stocker les données du conteneur wordpress_db
  • wp_data pour stocker les données du conteneur wordpress

Ordre de démarrage : dépendance

La directive depends_on: permet de définir des dépendances entre les services. Elle spécifie qu'un service donné dépend d'un ou plusieurs autres services avant de pouvoir être démarré. Cela permet de garantir que les services requis sont opérationnels avant de lancer un service dépendant.

L'utilisation de depends_on: est particulièrement utile lorsque tu as une application composée de plusieurs services et que certains d'entre eux ont besoin d'attendre que d'autres services soient prêts avant de pouvoir fonctionner correctement.

Nous rajoutons l'instruction lignes 22 et 23 .

bash
version: '3'
services:
  # Création d'un service BDD
  wordpress_db:
    image: mysql:8.0
    container_name: wordpress_db
    restart: always
    ports:
      - "80:80"
    environment:
      MYSQL_ROOT_PASSWORD: V%*gWsNw5ah!YmERQejbA3F7t
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
    networks:
      - backend
    volumes:
      - db_data:/var/lib/mysql

  # Création d'un service Wordpress
  wordpress:
    depends_on:
      - wordpress_db
    image: wordpress:latest
    container_name: wordpress
    restart: always
    environment:
      WORDPRESS_DB_HOST: wordpress_db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
      WORDPRESS_DB_NAME: wordpress
    networks:
      - backend
      - frontend
    volumes:
      - wp_data:/var/www/html

networks:
  frontend:
  backend:
volumes:
  db_data:
  wp_data:

Résumé du fichier Docker Compose

  • version: '3' : Spécifie à Docker quelle version de Docker compose on utilise

  • services: : Définit les différents conteneurs nécessaires à l'application.

    • wordpress_db : Service pour la base de données MySQL.
    • wordpress : Service pour WordPress.

  • images : : Spécifie les images Docker utilisées pour chaque service.

  • container_name: : Donne un nom spécifique à chaque conteneur pour une identification facile.

  • restart: always : Indique que les conteneurs doivent être redémarrés automatiquement en cas d'échec ou d'arrêt.

  • ports: 80:80 : Mappe le port 80 du conteneur WordPress sur le port 80 de l'hôte.

  • environment: : Configure les variables d'environnement nécessaires pour la configuration de MySQL et de WordPress.

  • networks: : Connecte les conteneurs aux réseaux backend et frontend.

  • volumes: : Définit les volumes Docker pour stocker les données persistantes des conteneurs MySQL et WordPress.

↗
https://docs.docker.com/compose/compose-file/

Ces instructions ne sont pas toutes obligatoires, c'est à toi de définir les éléments que tu veux configurer. En parcourant la documentation Docker compose, tu seras en mesure de mieux comprendre les différents attributs à déclarer pour tes différentes applications.

docs.docker.com

:point_right: Commandes Docker Compose

Une fois que tu as créé ton fichier Docker Compose et défini tes services, réseaux et volumes, tu peux utiliser différentes commandes Docker Compose pour gérer ton application. Place toi dans le répertoire qui contient ton fichier compose.yml et teste ces différentes commandes :

docker compose config

bash
wilder@docker1:~/wordpress$ docker compose config
name: wordpress
networks:
  backend:
    name: wordpress_backend
  default:
    name: wordpress_default
  frontend:
    driver: bridge
    name: wordpress_frontend
services:
  wordpress:
    container_name: wordpress
    depends_on:
      wordpress_db:
        condition: service_started
        required: true
    environment:
      WORDPRESS_DB_HOST: wordpress_db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
      WORDPRESS_DB_NAME: wordpress
    image: wordpress:latest
    networks:
      backend: null
      frontend: null
    ports:
      - mode: ingress
        protocol: tcp
        published: "80"
        target: 80
    restart: always
    volumes:
      - source: wp_data
        target: /var/www/html
        type: volume
        volume: {}
  wordpress_db:
    container_name: wordpress_db
    environment:
      MYSQL_ROOT_PASSWORD: V%*gWsNw5ah!YmERQejbA3F7t
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: e248*s7Mx!wbzdJ#$PWBg3rTFj
    image: mysql:8.0
    networks:
      backend: null
    restart: always
    volumes:
      - source: db_data
        target: /var/lib/mysql
        type: volume
        volume: {}
version: "3"
volumes:
  db_data:
    name: wordpress_db_data
  wp_data:
    name: wordpress_wp_data

La commande docker compose config est utilisée pour valider et afficher la configuration Docker Compose après le traitement des fichiers compose.yml :

  • Validation de la syntaxe : Vérifie que la syntaxe du fichier compose.yml est correcte. Elle s'assure que toutes les instructions sont correctement formatées et qu'il n'y a pas d'erreurs de syntaxe.

  • Affichage de la configuration : Affiche la configuration résultante à l'écran. Cela inclut tous les services, réseaux, volumes, variables d'environnement et autres paramètres définis dans le fichier compose.yml.

docker compose up -d

bash
wilder@docker1:~/wordpress$ docker compose up -d
[+] Running 2/6
 ⠏ Network wordpress_frontend  Created                                                                                            0.9s
 ⠏ Network wordpress_backend   Created                                                                                            0.9s
 ⠏ Volume "wordpress_db_data"  Created                                                                                            0.8s
 ⠏ Volume "wordpress_wp_data"  Created                                                                                            0.8s
 ✔ Container wordpress_db      Started                                                                                            0.4s
 ✔ Container wordpress         Started                                                                                            0.8s

Cette commande permet de construire (si nécessaire) et de démarrer tous les services définis dans ton fichier Docker Compose en arrière-plan. L'option -d indique que les conteneurs doivent être lancés en mode détaché, ce qui signifie qu'ils s'exécutent en arrière-plan.

Info

Tu peux voir dans la sortie de la commande que Docker compose crée automatiquement les réseaux et les volumes spécifiés dans le fichier compose.yml.

Bravo

Si tout s'est bien passé, ton service Wordpress sera accessible depuis un navigateur en HTTP à l'adresse de ton hôte Docker.

docker compose ps

bash
wilder@docker1:~/wordpress$ docker compose ps
NAME           IMAGE              COMMAND                  SERVICE        CREATED         STATUS         PORTS
wordpress      wordpress:latest   "docker-entrypoint.s…"   wordpress      4 minutes ago   Up 4 minutes   0.0.0.0:80->80/tcp, :::80->80/tcp
wordpress_db   mysql:8.0          "docker-entrypoint.s…"   wordpress_db   4 minutes ago   Up 4 minutes   3306/tcp, 33060/tcp

Tu peux vérifier le démarrage des conteneurs avec la commande docker compose ps . Cette commande affiche l'état des services Docker Compose, y compris les conteneurs en cours d'exécution, leur ID, leur nom et leur état (par exemple, en cours d'exécution, arrêté, en échec, etc.).

docker compose logs

bash
wilder@docker1:~/wordpress$ docker compose logs
...

Cette commande affiche les journaux des services Docker Compose en cours d'exécution. Elle est utile pour vérifier les messages de journalisation et pour diagnostiquer les éventuels problèmes rencontrés par les conteneurs.

docker compose down

bash
wilder@docker1:~/wordpress$ docker compose down
[+] Running 4/4
 ✔ Container wordpress         Removed      1.3s
 ✔ Container wordpress_db      Removed      0.9s
 ✔ Network wordpress_frontend  Removed      0.1s
 ✔ Network wordpress_backend   Removed      0.1s

Cette commande arrête et supprime tous les conteneurs déclarés dans ton fichier compose.yml.

Attention

docker compose down supprimera également d'autres ressources, comme les réseaux créés pour l'application mais il ne supprimera pas les volumes !!!

Pour supprimer aussi les volumes, tu pourras utiliser l'option -v :

bash
wilder@docker1:~/wordpress$ docker compose down -v
[+] Running 6/6
 ✔ Container wordpress         Removed      1.2s
 ✔ Container wordpress_db      Removed      1.6s
 ✔ Volume wordpress_db_data    Removed      0.0s
 ✔ Volume wordpress_wp_data    Removed      0.2s
 ✔ Network wordpress_backend   Removed      0.1s
 ✔ Network wordpress_frontend  Removed      0.2s

docker compose stop

bash
wilder@docker1:~/wordpress$ docker compose stop
[+] Stopping 2/2
 ✔ Container wordpress     Stopped      1.3s
 ✔ Container wordpress_db  Stopped      1.0s

Pour arrêter les services actifs en toute sécurité, tu peux utiliser stop, qui gardera les conteneurs, les volumes et les réseaux, ainsi que toutes les modifications qui leur sont apportées.

docker compose start

bash
wilder@docker1:~/wordpress$ docker compose start
[+] Running 2/2
 ✔ Container wordpress_db  Started      0.2s
 ✔ Container wordpress     Started      0.4s

Si tu as simplement arrêté tes conteneurs, tu pourras utiliser la commande start pour relancer ton service au lieu de la commande up .

docker compose exec

Cette commande te permet d'exécuter une commande à l'intérieur d'un conteneur spécifique. Par exemple, pour exécuter une commande bash à l'intérieur du conteneur WordPress :

bash
wilder@docker1:~/wordpress$ docker compose exec wordpress bash

docker compose build

Cette commande permet de construire les images Docker des services définis dans le fichier Docker Compose. Elle est utile lorsque tu as fais référence à des images personnalisée à l'aide d'un fichier Dockerfile.

bash
wilder@docker1:~/wordpress$ docker-compose build
↗
https://docs.docker.com/compose/reference/

La plupart des commandes Docker compose se passent d'explication car elles ont des équivalences avec les commandes Docker. Tu peux consulter la documentation officielle pour en apprendre plus sur les commandes CLI de Docker compose.

docs.docker.com

:point_right: Bonnes pratiques

Lorsque tu travailles avec Docker compose en production, il est important de suivre certaines bonnes pratiques pour garantir la portabilité et la maintenabilité de tes configurations.

Voici quelques bonnes pratiques à considérer :

  1. Utilise des fichiers .env : Les fichiers .env sont couramment utilisés pour stocker les variables d'environnement. Plutôt que d'indiquer les variables d'environnement dans le fichier compose.yml, utilise un fichier à part dans lequel tu déclarera ces variables. Ils peuvent être lus par Docker Compose et injectés dans tes services au moment de l'exécution de ton compose.yml. Assure toi aussi de documenter clairement le rôle et l'utilisation de chaque variable d'environnement pour faciliter la compréhension et la maintenance ultérieure de ta configuration.
↗
https://docs.docker.com/compose/environment-variables/set-environment-variables/

Documentation officielle sur la façon de gérer les variables d'environnement avec Docker compose

docs.docker.com
  1. Sécurise les valeurs sensibles : Évite de stocker des valeurs sensibles directement dans des fichiers .env. Utilise plutôt des mécanismes de gestion des secrets tels que HashiCorp Vault ou Docker Secrets pour stocker et récupérer ces valeurs de manière sécurisée.
↗
https://docs.docker.com/compose/use-secrets/

Documentation officielle sur la gestion des secrets dans Docker compose.

docs.docker.com

  1. Utilise un outil de gestion de version : Par exemple Git pour te permettre de suivre l'évolution du code et des configuration. N'oublie pas d'inclure un fichier .gitignore pour exclure les fichiers et répertoires sensibles ou inutiles.

  2. Crée une arborescence de projet structurée : Crée des répertoires distincts pour les fichiers de configuration Docker, les sources de l'application, les tests, les secrets et la documentation. Organise les fichiers de manière logique pour faciliter la navigation et la localisation des éléments pertinents.

Voici un exemple d'arborescence de répertoire de projet pour un service simple utilisant Docker Compose :

bash
project/
├── compose.yml
├── .env
├── config/
│   ├── nginx/
│   │   └── nginx.conf
│   └── php/
│       └── php.ini
├── src/
│   ├── app/
│   │   └── (contenu de l'application)
│   └── Dockerfile
└── .gitignore

Explications des fichiers et répertoires :

  • compose.yml : Le fichier principal de configuration Docker Compose, qui définit les services à exécuter. Il peut référencer des variables d'environnement définies dans le fichier .env.

  • .env : Le fichier contenant les variables d'environnement pour le projet. Les variables définies ici peuvent être utilisées dans le fichier compose.yml et dans d'autres fichiers de configuration Docker.

  • config/ : Un répertoire contenant les fichiers de configuration pour les services Docker, tels que les configurations Nginx ou PHP.

  • src/ : Le répertoire contenant le code source de l'application Dockerisée. Il peut contenir des fichiers d'application, des fichiers Dockerfile, etc.

  • .gitignore : Un fichier spécifiant les fichiers et répertoires à ignorer lors de la gestion de version avec Git. Il est généralement utilisé pour exclure les fichiers volumineux ou sensibles.

:point_up: Résumé

En utilisant Docker Compose, la gestion de notre application WordPress est grandement simplifiée. Tous les services nécessaires, les réseaux et les volumes sont définis dans un seul fichier, ce qui permet un déploiement et une gestion plus cohérents et automatisés de l'application.

Docker Compose permet également de résoudre les problématiques rencontrées lors du déploiement manuel des conteneurs.

Bravo

Et comme toujours, tu peux approfondir tes connaissances en t'aidant de la documentation officielle : https://docs.docker.com/compose/compose-file/compose-file-v3/

spacer

📝 Quiz

quiz
true||true|||false
# Quel est le rôle principal de Docker Compose dans le déploiement d'applications multi-conteneurs ?
[] Gérer les conteneurs individuellement
[x] Automatiser le déploiement des applications
[] Contrôler les images Docker
[] Configurer les réseaux personnalisés
# Quelle est l'extension du fichier utilisé par Docker Compose ?
[] .dockerfile
[x] .yml
[] .compose
# Quelle commande permet de vérifier la configuration Docker Compose après le traitement des fichiers compose.yml ?
[] docker compose create
[] docker compose validate
[x] docker compose config
[] docker compose info
# Quelle commande permet de démarrer tous les services définis dans un fichier Docker Compose en arrière-plan ?
[] docker compose start
[] docker compose run
[x] docker compose up -d
[] docker compose create
# Quelle commande permet de voir l'état des services Docker Compose en cours d'exécution ?
[] docker compose status
[] docker compose show
[] docker compose list
[x] docker compose ps
# Quelle instruction est utilisée dans le fichier Docker Compose pour spécifier les images Docker utilisées pour chaque service ?
[] container_name
[] build
[x] image
[] volumes
# Quelle instruction permet de définir les dépendances entre les services dans un fichier Docker Compose ?
[] dependencies
[] required_services
[x] depends_on
[] connections

💪 Challenge

Ta tâche consiste à réorganiser l'application Wordpress utilisée dans la quête. Le fichier compose.yml est accessible via ce dépôt GitHub.

Une fois cela fait, crée ton propre dépôt Git contenant l'ensemble de ton application réorganisée et ajoute un fichier README.md expliquant comment utiliser ton application.

Fournis ensuite le lien vers ton dépôt GitHub en tant que solution au challenge.

Instructions de réorganisation :

  • Crée une arborescence de projet structurée
  • Crée un fichier .env séparé pour stocker les variables d'environnement utilisées dans ton application.
  • Assure-toi de documenter clairement le rôle et l'utilisation de chaque variable d'environnement.
  • Évite de stocker des valeurs sensibles directement dans des fichiers .env , utilise plutôt un mécanisme de gestion des secrets tels que Docker Secrets pour stocker et récupérer ces valeurs de manière sécurisée.

🧐 Critères d'acceptation

Ta solution est conforme aux instructions.