Docker Compose: Orchestration d'applications et dépendances

1. Qu'est-ce que Docker Compose ?

Imaginez que votre Dockerfile est la recette pour construire une brique (un conteneur). Docker Compose est le plan d'architecte qui explique comment assembler plusieurs briques (conteneurs) pour construire une maison (votre application complète).

C'est un outil qui permet de définir et de gérer des applications multi-conteneurs à l'aide d'un simple fichier de configuration au format YAML : le docker-compose.yml. Ce fichier décrit les services qui composent votre application, comment les construire, et comment ils interagissent.

2. La structure d'un fichier docker-compose.yml

Le fichier docker-compose.yml est le cœur de l'orchestration. Il s'organise autour de quelques clés principales. Une vidéo vous guidera à travers la mise en place initiale de ce fichier.

Pour résumer ce que vous venez de voir, les trois sections principales sont :

• services : C'est ici que vous définissez chaque composant de votre application (ex: votre backend, votre base de données). Chaque service correspondra à un conteneur.
• volumes : Les conteneurs sont éphémères. Si vous supprimez un conteneur de base de données, vous perdez toutes vos données. Les volumes permettent de stocker les données de manière persistante sur la machine hôte, en dehors du cycle de vie du conteneur.
• networks : Pour que vos conteneurs puissent communiquer entre eux de manière sécurisée et isolée, Docker Compose crée un réseau privé. Les services peuvent s'appeler par leur nom, comme s'ils étaient sur le même réseau local.

3. Définir les services dépendants : MySQL et Redis

Commençons par configurer les dépendances de notre application : une base de données MySQL pour la persistance et un cache Redis pour la performance.

Le service de base de données MySQL

La configuration d'un service avec état comme une base de données requiert une attention particulière. La vidéo que vous avez commencée détaille parfaitement ce processus.

Voici une analyse des points clés abordés dans la vidéo :

• image: mysql:8 : Utilise l'image officielle MySQL version 8 depuis Docker Hub.
• environment : Permet de configurer le conteneur MySQL au démarrage. Les variables comme MYSQL_ROOT_PASSWORD et MYSQL_DATABASE sont essentielles.
• volumes: - mysql-data:/var/lib/mysql : C'est la ligne qui assure la persistance. Elle lie un volume nommé mysql-data (défini à la racine du fichier) au dossier interne du conteneur où MySQL stocke ses données.
• ports: - "3308:3306" : Mappe le port 3306 du conteneur au port 3308 de votre machine. Cela vous permet de vous connecter à la base de données depuis votre machine locale (par exemple avec un client SQL) via localhost:3308, tout en évitant les conflits si vous avez déjà un MySQL local tournant sur le port 3306.
• healthcheck : Une pratique essentielle. Docker va périodiquement exécuter une commande (mysqladmin ping) pour vérifier que la base de données est non seulement lancée, mais qu'elle est aussi prête à accepter des connexions.

Le service de cache Redis

Conformément à l'objectif d'apprentissage, ajoutons un service de cache. Redis est un choix très courant. Sa configuration est beaucoup plus simple.

services:



  # ... service mysql
  redis:
    image: redis:7-alpine  # Utilise une image Redis légère (basée sur Alpine)
    restart: always
    ports:
      - "6379:6379"  # Mappe le port Redis par défaut
    networks:
      - app-network  # Le connecte au même réseau

Ici, pas besoin de variables d'environnement complexes ou de volume persistant pour un usage de cache en développement.

4. Intégrer votre application Spring Boot

Maintenant que nos dépendances sont définies, il est temps d'ajouter le service principal : notre application Spring Boot, en utilisant le Dockerfile que vous avez créé lors de la leçon précédente.

Le chaînon manquant : depends_on et la communication réseau

Cette partie est cruciale. Comme vous l'avez vu, la communication entre les conteneurs n'est pas magique.

1. L'ordre de démarrage avec depends_on
   La section depends_on garantit que Docker Compose démarre les conteneurs dans le bon ordre.

   depends_on:
     mysql-db:
       condition: service_healthy
   

   Cette configuration est très robuste. Elle indique à Docker Compose d'attendre que le healthcheck du service mysql-db soit positif avant de lancer le conteneur de l'application. Votre application ne démarrera donc jamais avant que la base de données ne soit réellement prête.

2. La communication via le nom de service
   C'est le point qui déroute le plus souvent les débutants. Dans les variables d'environnement de votre application, l'URL de la base de données n'est pas jdbc:mysql://localhost:3306/....

En bref, depuis l'intérieur du réseau Docker, chaque service est accessible via son **nom de service**. Si vous avez nommé votre service de base de données `mysql-db`, alors pour votre application Spring Boot, le nom d'hôte de la base de données est `mysql-db`.

5. Assemblage final et exécution

Voici à quoi pourrait ressembler un fichier docker-compose.yml complet, intégrant votre application, une base de données MySQL et un cache Redis. Cet exemple s'inspire des bonnes pratiques que nous avons vues.

En adaptant ce modèle à notre stack Spring Boot / MySQL, voici notre fichier docker-compose.yml final :

version: '3.8'

services:



  # Service Backend Spring Boot
  backend-app:
    build: . # Construit l'image à partir du Dockerfile à la racine
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql-db:3306/appdb
      - SPRING_DATASOURCE_USERNAME=user
      - SPRING_DATASOURCE_PASSWORD=password
      - SPRING_DATA_REDIS_HOST=redis
      - SPRING_DATA_REDIS_PORT=6379
    depends_on:
      mysql-db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - app-network




  # Service Base de Données MySQL
  mysql-db:
    image: mysql:8.0
    environment:
      - MYSQL_DATABASE=appdb
      - MYSQL_USER=user
      - MYSQL_PASSWORD=password
      - MYSQL_ROOT_PASSWORD=rootpassword
    ports:
      - "3308:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network




  # Service de Cache Redis
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network

volumes:
  mysql-data:

networks:
  app-network:
    driver: bridge

(Note : il est nécessaire d'adapter le fichier application.properties de votre projet Spring Boot ou d'utiliser des profils pour que ces variables d'environnement soient prises en compte.)

Pour lancer l'ensemble de la stack, placez-vous à la racine de votre projet (là où se trouvent le Dockerfile et le docker-compose.yml) et exécutez :

docker compose up --build -d

• up : Démarre les services.
• --build : Force la reconstruction de l'image de votre application si son code ou son Dockerfile a changé.
• -d : (detached) Lance les conteneurs en arrière-plan.

Quelques autres commandes utiles :

• docker compose ps : Voir l'état de vos conteneurs.
• docker compose logs -f backend-app : Suivre les logs de votre application en temps réel.
• docker compose down : Arrêter et supprimer les conteneurs.
• docker compose down -v : Idem, mais supprime aussi les volumes nommés (attention, cela efface vos données de base de données !).

Conclusion

Félicitations ! Vous avez fait un grand pas en avant, passant de la conteneurisation d'un seul service à l'orchestration d'une application multi-services complète.

Points clés à retenir :

• Docker Compose utilise un fichier docker-compose.yml pour définir et gérer une application composée de plusieurs conteneurs.
• Les services communiquent entre eux via un réseau privé, en utilisant leur nom de service comme nom d'hôte.
• Les volumes nommés sont essentiels pour assurer la persistance des données des services avec état, comme les bases de données.
• La combinaison de depends_on et healthcheck est la méthode la plus robuste pour gérer l'ordre de démarrage des services et s'assurer que les dépendances sont prêtes.

Prochaine étape :

Dans notre fichier docker-compose.yml, nous avons écrit des mots de passe en clair. C'est acceptable pour du développement local rapide, mais c'est une très mauvaise pratique pour tout environnement partagé ou de production. Dans la prochaine leçon, nous aborderons justement comment gérer les secrets et les variables d'environnement de manière sécurisée dans un contexte conteneurisé.