TP 6 Composer des stacks multi-services avec Docker Compose

1.1 Introduction à Docker Compose

docker compose (ou docker-compose) permet de décrire des services, réseaux et volumes dans un fichier YAML.
On lance le tout par docker compose up -d.
Une application peut comporter une base de données, un backend et un frontend.
But de Docker Compose : Lancer, connecter et gérer tous ces services en une seule commande, avec gestion automatique des volumes et réseaux.

Concepts clés

Services : Chaque service dans docker-compose.yml correspond à un conteneur.
Volumes : Permettent de persister ou de partager des données entre services.
Réseaux : Docker Compose crée automatiquement un réseau pour les services, mais vous pouvez définir des réseaux personnalisés.
depends_on : Définit l’ordre de démarrage des services, mais ne garantit pas qu’un service soit prêt à être utilisé (exemple : une base de données peut prendre du temps à démarrer).

1.4 Manipuler une stack de services avec Docker Compose

Démarrer une stack :
```
docker compose up -d
```
Arrêter une stack et supprimer les conteneurs associés :
```
docker compose down
```

Afficher les logs des services :
```
docker compose logs -f
```
Lister les conteneurs de la stack :
```
docker compose ps
```

1.5 Gérer volumes et réseaux avec Docker Compose

Définir des volumes nommés dans le fichier docker-compose.yml :
```
volumes:
  dbdata:
```

Les utiliser dans un service :

services:
  db:
    image: mysql:5.7
    volumes:
      - dbdata:/var/lib/mysql

Créer un réseau personnalisé :
```
networks:
  mynet:
```

Et l’associer à un service :

services:
  app:
    networks:
      - mynet

Exemple

services:
  db:
    # We use a mariadb image which supports both amd64 & arm64 architecture
    image: mariadb:10.6.4-focal
    # If you really want to use MySQL, uncomment the following line
    #image: mysql:8.0.27
    command: '--default-authentication-plugin=mysql_native_password'
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=somewordpress
      - MYSQL_DATABASE=wordpress
      - MYSQL_USER=wordpress
      - MYSQL_PASSWORD=wordpress
    expose:
      - 3306
      - 33060
  wordpress:
    image: wordpress:latest
    volumes:
      - wp_data:/var/www/html
    ports:
      - 80:80
    restart: always
    environment:
      - WORDPRESS_DB_HOST=db
      - WORDPRESS_DB_USER=wordpress
      - WORDPRESS_DB_PASSWORD=wordpress
      - WORDPRESS_DB_NAME=wordpress
volumes:
  db_data:
  wp_data:

1.6 Tour d’horizon des outils de gestion multi-conteneurs

Docker Compose : Pour gérer des services locaux ou des stacks simples.
Docker Swarm : Orchestration intégrée à Docker, utile pour des environnements distribués simples.
Kubernetes : Un orchestrateur avancé, mais plus complexe à mettre en place.

1.7 Construire une stack multi-services

L’objectif de cet exercice est de créer une stack comprenant deux services : 1. Un backend Node.js. 2. Un reverse proxy Nginx.

Exercice : Mini-stack multi-services (Node.js + reverse proxy Nginx)

Objectif

Mettre en place un service Node.js comme backend.
Configurer un reverse proxy Nginx pour rediriger les requêtes vers le backend.
Gérer les deux services via Docker Compose.

1. Préparer l’application Node.js

Créer le fichier index.js :

const http = require('http');
const port = 3000;

const requestListener = (req, res) => {
 res.writeHead(200, { 'Content-Type': 'text/plain' });
 res.end('Hello from Node.js!');
};

const server = http.createServer(requestListener);
server.listen(port, () => {
 console.log(`Server running on port ${port}`);
});

Créer le fichier Dockerfile pour Node.js :

FROM node:18-alpine
WORKDIR /app
COPY index.js .
EXPOSE 3000
CMD ["node", "index.js"]

2. Préparer la configuration Nginx

Créer le fichier default.conf (configuration du reverse proxy) :

server {
   listen 80;
   location / {
       proxy_pass http://app:3000/;
   }
}

Cette configuration redirige toutes les requêtes reçues sur le port 80 vers le service app (Node.js) sur le port 3000.

2. Créer le fichier `docker-compose.yml`

version: "3.8"

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: app
    networks:
      - mynet

  proxy:
    image: nginx:alpine
    container_name: proxy
    volumes:
      - ./default.conf:/etc/nginx/conf.d/default.conf:ro
    ports:
      - "80:80"
    depends_on:
      - app
    networks:
      - mynet

networks:
  mynet:

app : Le backend Node.js.
proxy : Le reverse proxy Nginx.
depends_on : Assure que app est lancé avant proxy (mais pas forcément prêt).
mynet : Réseau personnalisé permettant aux deux services de communiquer.

3. Lancer et tester la stack

Lancer la stack :
```
docker compose up -d
```

Vérifier l’état :

docker compose ps
docker compose logs -f

Tester dans un navigateur :
Accédez à http://localhost.
Vous devriez voir Hello from Node.js!.

4. Nettoyer

Arrêter et supprimer la stack :
```
docker compose down
```
Supprimer les images locales non utilisées :
```
docker image prune
```