TP8 : Mise en place d'un cluster Docker Swarm et Rolling Update

Objectif du TP

Initialiser un cluster Swarm et y déployer un service répliqué.
Mettre à l’échelle un service et réaliser un rolling update sans interruption.

Rendu attendu

Commandes exécutées (swarm init, stack deploy, service scale, service update).
Captures de docker service ps montrant les réplicas et la mise à jour.

Questions d'ouverture

Quelle différence entre un docker service Swarm et un simple conteneur ?
Comment garantir un rolling update sans interruption visible pour l’utilisateur ?

1. Introduction

Dans ce TP, vous allez :

Créer un cluster Swarm avec plusieurs nœuds.
Déployer un service simple « ping » avec Nginx.
Mettre à l’échelle ce service.
Effectuer une mise à jour progressive vers un service « pong ».
Visualiser la répartition des conteneurs.

Focus : Services, réplicas et mises à jour

Swarm orchestre des services (pas des conteneurs “manuels”) avec réplicas, placement et stratégie d’update.
Les images doivent être accessibles à tous les nœuds (registre commun).
Éviter les bind mounts locaux non partagés.

Mise en pratique

2.1. Préparation du cluster

Activer un point d’accès Wi-Fi sur un téléphone pour connecter tous vos PC.

Initialiser le Swarm sur un premier nœud (manager) :

docker swarm init --advertise-addr <IP_MANAGER>

Rejoindre le cluster depuis les autres nœuds (workers) :

docker swarm join --token <TOKEN> <IP_MANAGER>:2377

Vérifier les nœuds :
```
docker node ls
```

2.2. Déploiement d’un service

Note : Nous utilisons une image personnalisée au lieu de l'image Nginx par défaut afin de mieux contrôler son contenu, notamment pour y inclure nos propres fichiers HTML et assurer une mise à jour cohérente lors du rolling update.

Attention - En mode Swarm, évitez les bind mounts locaux : tous les nœuds doivent pouvoir accéder aux mêmes données. Privilégiez des images qui embarquent les fichiers nécessaires ou des volumes compatibles multi-nœuds. - Assurez-vous que l’image est poussée sur un registre accessible par tous les nœuds du cluster.

Créer un fichier docker-compose.yml :

 version: '3.8'

 services:
    web:
       image: <REGISTRY_URL>/mon-image:ping
       deploy:
          replicas: 3
       ports:
          - "8080:80"

Dans le dossier html, créer un fichier index.html avec le texte "ping".

Construire et tagger l’image avant le déploiement :

docker build -t mon-image:ping . # Assurez-vous que le Dockerfile est présent dans le répertoire courant
docker tag mon-image:ping <REGISTRY_URL>/mon-image:ping # Remplacez <REGISTRY_URL> par l'adresse de votre registre

Pousser l’image vers un registre (obligatoire) :
```
docker push <REGISTRY_URL>/mon-image:ping
```

Déployer la stack :

docker stack deploy -c docker-compose.yml tp8stack

Tester l’accès :
Ouvrez un navigateur sur http://<IP_MANAGER>:8080 : vous devriez voir "ping".

2.3. Scaling

Monter à 10 réplicas :
```
docker service scale tp8stack_web=10
```
Vérifier la répartition :
```
docker service ps tp8stack_web
```
Redescendre à 4 réplicas :
```
docker service scale tp8stack_web=4
```

2.4. Rolling Update vers « pong »

Modifier votre page web pour afficher "pong" :
Modifiez votre contenu dans le Dockerfile (ou les sources) pour que l’image publiée affiche « pong ».

Construire et tagger l’image mise à jour :

docker build -t mon-image:pong .
docker tag mon-image:pong <REGISTRY_URL>/mon-image:pong

Pousser l’image vers un registre (obligatoire) :
```
docker push <REGISTRY_URL>/mon-image:pong
```

Mettre à jour le service :

 docker service update \
    --image <REGISTRY_URL>/mon-image:pong \
    tp8stack_web

Vérifier la transition progressive :

docker service ps tp8stack_web

Le service doit passer de « ping » à « pong » sans interruption.
Comment vérifier s’il y a une interruption ? À vous d’essayer quelques méthodes (rafraîchir en continu, watch -n1 curl ..., etc.).

2.5. Visualisation

Déployer Docker Swarm Visualizer :
À vous de jouer ;)
Aller sur http://<IP_MANAGER>:9000 pour voir la répartition des conteneurs.

2.6. Nettoyage

Supprimer la stack :
```
docker stack rm tp8stack
```
Optionnel : quitter le Swarm sur chaque nœud (sauf manager) :
```
docker swarm leave
```
Sur le manager :
```
docker swarm leave --force
```

Conclusion

Vous avez initialisé un cluster Swarm, déployé, scalé et mis à jour un service.
Vous avez vérifié une mise à jour progressive sans interruption.