Aller au contenu principal

Docker Compose

Maîtriser une équipe de conteneurs comme un chef d’orchestre !

Notions théoriques​

Docker offre 3 méthodes pour créer des conteneurs :

  • utiliser une image existante,
  • ou construire votre propre image avec un Dockerfile,
  • ou utiliser Docker Compose pour des applications complexes.

info

Docker Compose permet de diriger plusieurs conteneurs comme une équipe, avec un seul fichier.

Ce fichier, appelé docker-compose.yml, est écrit en YAML (un format simple, comme une liste claire).

Dedans, tu dis qui fait quoi, comment ils se parlent, et où ils stockent leurs données.

Voici les bases :

  • Services : Ce sont tes conteneurs.

    Par exemple, un service pour ton appli Web, un autre pour ta base de données.

  • Réseaux : Ils connectent tes services pour qu’ils puissent discuter.

    Docker Compose crée un réseau automatiquement, par défaut.

  • Volumes : C’est comme une boîte où tes conteneurs stockent des données pour ne pas les perdre s’ils s’arrêtent.
  • Ports : Ils ouvrent des portes entre ton ordi et les conteneurs, pour que tu puisses voir ton site Web, par exemple.

Pour tout lancer, tu tapes docker-compose up et tes services démarrent ensemble !

Pour tout arrêter et nettoyer, docker-compose down fait le job.

Tu peux même ajouter des options, comme dire qui démarre en premier avec depends_on, ou mettre des mots de passe avec environment.

En résumé, Docker Compose, c’est un chef d’orchestre pour une symphonie de conteneurs !

Exemple pratique​

On va créer un petit duo : un site Web et une base de données.

Voici un fichier docker-compose.yml simple :

version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
  database:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: secret

Que se passe-t-il ?​

  • version: '3' : C’est la version du fichier, comme un numéro de mise à jour.
  • web : On utilise l’image nginx (un serveur Web) et on connecte le port 8080 de ton ordi au port 80 du conteneur.
  • database : On prend mysql:5.7 et on met un mot de passe root (secret).

Pour voir ça en action, sauvegarde ce fichier, ouvre un terminal dans le même dossier, et tape docker-compose up.

Tu verras les 2 conteneurs se lancer.

Va sur http://localhost:8080, et tu devrais voir la page par défaut de Nginx.

Pour tout arrêter, fais CTRL + C ou docker-compose down.

Test de mémorisation/compréhension​


À quoi sert principalement Docker Compose ?


Dans quel langage est écrit docker-compose.yml ?


Quelle commande démarre les services ?


À quoi servent les ports dans un service ?


Pourquoi utiliser des volumes ?


Que fait depends_on ?


Quel rôle joue le fichier `docker-compose.yml` dans la gestion des conteneurs ?


Dans le TP, pourquoi le service `web` dépend-il du service `db` avec `depends_on` ?


Dans l’exemple pratique, que se passe-t-il si on supprime la ligne `ports: - '8080:80'` du service `web` ?


Dans le TP, pourquoi monte-t-on le dossier local dans le conteneur `web` avec `volumes: - .:/app` ?


Quelle variable d’environnement définit le nom de la base de données dans le service `db` du TP ?


Pourquoi le script `app.py` inclut-il une boucle avec `time.sleep(2)` dans le TP ?


Dans l’exemple pratique, comment le service `web` peut-il communiquer avec `database` sans configuration réseau explicite ?


Dans le TP, pourquoi faut-il exécuter `pip install mysql-connector-python` dans le conteneur `web` après le premier lancement ?


TP pour réfléchir et résoudre des problèmes​

Création d'une application multi-conteneurs avec Docker Compose

Ce TP vous guide dans la mise en place d'une application utilisant Docker Compose pour orchestrer 2 services :

  • une application Python
  • et une base de données MySQL.

Vous allez créer :

  • un environnement reproductible,

  • écrire du code pour connecter ces services,

  • et tester leur interaction.

1) Préparer l'environnement du projet​

Objectif : Mettre en place la structure initiale du projet et s'assurer que l'environnement est prêt pour les étapes suivantes.

  1. Créer un dossier dédié au projet :

    • Ouvre un terminal adapté à ton système d'exploitation :
      • Sur Windows : utilise PowerShell ou, si tu préfères un environnement Linux, installe WSL (Windows Subsystem for Linux) et utilise un terminal Ubuntu.
      • Sur Linux ou macOS : utilise le terminal par défaut.
    • Exécute la commande suivante pour créer un dossier nommé projet-docker-compose : 
      mkdir projet-docker-compose
    • Déplace-toi dans ce dossier avec : 
      cd projet-docker-compose
    • Ce dossier servira de racine pour tous les fichiers du projet.

  2. Vérifier l'installation de Docker et Docker Compose :

    • Assure-toi que Docker est installé et en marche. Vérifie avec : 
      docker --version
      Tu devrais voir une sortie comme Docker version 20.10.17, build 100c701.
    • Vérifie aussi Docker Compose : 
      docker-compose --version
      Une réponse comme docker-compose version 1.29.2, build 5becea4c confirme qu’il est prêt.
    • Si l’un des deux n’est pas installé, consulte la documentation officielle de Docker pour ton système.

  3. Comprendre l’organisation :

    • À ce stade, le dossier projet-docker-compose est vide. Il accueillera bientôt un fichier docker-compose.yml pour définir les services, un script Python pour l’application, et éventuellement d’autres fichiers de configuration.
Une solution

2) Deux services avec Docker Compose​

Objectif : Créer un fichier docker-compose.yml qui définit 2 services interconnectés :

  • une application Python (web)
  • et une base de données MySQL (db).

  1. Créer le fichier docker-compose.yml :

    • Dans le dossier projet-docker-compose, crée un fichier nommé docker-compose.yml. Utilise une commande ou ton éditeur de texte préféré :
      • Sur Windows (PowerShell) : echo "" > docker-compose.yml
      • Sur Linux/macOS : touch docker-compose.yml
    • Ouvre ce fichier avec un éditeur comme VS Code, Vim ou Notepad++.

  2. Définir la structure de base :

    • Commence par spécifier la version de la syntaxe Docker Compose. La version '3' est stable et largement compatible : 
      version: '3'
    • Ajoute une section services pour lister les conteneurs : 
      services:

  3. Configurer le service web :

    • Sous services, définis un service nommé web pour l’application Python :
      • Utilise l’image officielle python:3.9 pour avoir un environnement Python prêt à l’emploi.
      • Monte le dossier local dans le conteneur avec volumes pour synchroniser le code.
      • Défini un répertoire de travail avec working_dir.
      • Spécifie une commande par défaut avec command.
      • Ajoute une dépendance avec depends_on pour attendre le service db.
    • Voici un exemple : 
      web:
        image: python:3.9
        volumes:
          - .:/app
        working_dir: /app
        command: python app.py
        depends_on:
          - db

  4. Configurer le service db :

    • Ajoute un service nommé db pour la base de données MySQL :
      • Utilise l’image mysql:5.7, une version stable et bien documentée.
      • Configure des variables d’environnement pour initialiser la base :
        • MYSQL_ROOT_PASSWORD : mot de passe root.
        • MYSQL_DATABASE : nom de la base par défaut.
    • Exemple : 
      db:
        image: mysql:5.7
        environment:
          MYSQL_ROOT_PASSWORD: monpass
          MYSQL_DATABASE: test_db

  5. Vérifier la syntaxe :

    • Assure-toi que l’indentation est correcte (2 espaces en YAML, pas de tabulations). Une erreur ici peut empêcher Docker Compose de fonctionner.
Une solution

3) Développer l’application Python​

Objectif : Écrire un script Python qui se connecte à la base de données MySQL et gère les délais de démarrage du conteneur db.

  1. Créer le fichier app.py :

    • Dans le dossier projet-docker-compose, crée un fichier nommé app.py :
      • Sur Windows (PowerShell) : echo "" > app.py
      • Sur Linux/macOS : touch app.py
    • Ouvre ce fichier dans ton éditeur.

  2. Installer les dépendances nécessaires :

    • Le script utilisera mysql-connector-python pour se connecter à MySQL. Pour l’installer dans le conteneur, tu ajouteras une commande plus tard. Pour l’instant, concentre-toi sur le code.

  3. Écrire le script Python :

    • Importe les modules nécessaires : mysql.connector pour la connexion et time pour gérer les délais.
    • Crée une boucle qui tente de se connecter à la base de données :
      • Utilise host="db" (le nom du service dans docker-compose.yml).
      • Spécifie user="root", password="monpass", et database="test_db" (conformes au service db).
    • Gère les erreurs avec un try/except et attends 2 secondes entre chaque tentative si la connexion échoue.

  4. Tester localement (optionnel) :

    • Si tu veux tester le code hors Docker, installe mysql-connector-python localement avec : 
      pip install mysql-connector-python
    • Adapte le host à une instance MySQL locale si nécessaire.
Une solution

4) Lancer et tester les services​

Objectif : Démarrer les conteneurs, installer les dépendances Python dans le conteneur web, et vérifier que tout fonctionne.

  1. Lancer Docker Compose :

    • Dans le dossier projet-docker-compose, exécute : 
      docker-compose up
    • Cette commande télécharge les images (python:3.9 et mysql:5.7), construit les conteneurs, et affiche leurs logs en temps réel.

  2. Installer mysql-connector-python dans le conteneur web :

    • Le conteneur web échouera au démarrage car app.py nécessite mysql-connector-python.
    • Ouvre un second terminal, trouve l’ID du conteneur web avec : 
      docker ps
    • Accède au conteneur avec : 
      docker exec -it <ID_du_conteneur_web> bash
    • Installe la dépendance : 
      pip install mysql-connector-python
    • Quitte le conteneur avec exit, puis redémarre les services : 
      docker-compose down && docker-compose up

  3. Analyser les logs :

    • Observe les logs dans le terminal où docker-compose up est actif :
      • Le service db affiche des messages indiquant son démarrage.
      • Le service web montre les tentatives de connexion, suivies du message de succès une fois que db est prêt.

  4. Arrêter les services :

    • Quand tu as terminé, arrête les conteneurs avec Ctrl+C dans le terminal, ou dans un autre terminal : 
      docker-compose down
    • Pour supprimer aussi les volumes persistants, ajoute --volumes : 
      docker-compose down --volumes
Une solution