Configurer un cluster Docker Swarm

Dans ce tutoriel, on va voir comment mettre en place un cluster Docker Swarm afin d’assurer la haute disponibilité de vos conteneurs.

Jusqu’à présent sur le site, je vous ai expliqué dans de nombreux tutoriels comment mettre en place des applications avec Docker, aujourd’hui on va voir comment mettre un place un infrastructure Docker résiliente avec un cluster Docker Swarm qui va vous permettre d’avoir vos conteneur en haute disponibilité.

Sommaire

Le vocabulaire Docker Swarm

Avant de se lancer dans la technique, je vais vous aider à comprendre les différents termes de vocabulaires autour de Docker Swarm.

Swarm : groupe de serveur exécutant Docker.
Nœud : appellation d’un serveur exécutant Docker un cluster Swarm.
Manager : nœud du cluster Swarm autoriser à exécuter des commandes Docker, gérer également le cluster
Worker : noeud du cluster Swarm qui fait fonctionner les conteneurs
Service : dans un Swarm, c’est le nom utilisé pour désigner les conteneurs

Composition d’un Swarm

Dans les bonnes pratiques, afin de composer un cluster Swarm, vous aurez besoin d’avoir au minimum 4 serveurs Docker :

2 nœuds qui auront le rôle de Manager
2 nœuds qui auront le rôle de Worker

Et pour finir un stockage partagé de type NFS pour le stockage des volumes.

Dans ce tutoriel, je vais seulement mettre en place un manager avec deux workers et configurer un partage NFS qui sera monter sur les nœuds.

Voici le schéma :

Dans ce tutoriel, j’ai utilise des serveurs Ubuntu 24.04.

Configuration du serveur NFS

Afin de se lancer dans l’installation et la configuration de Docker pour la création du Swarm, on va commencer par configurer le serveur NFS.

Commencer par installer NFS :

sudo apt install nfs-kernel-server -y

Une fois installée, vérifier que le service NFS est démarré et que le démarrage automatique est activé.

sudo systemctl status nfs-kernel-server

A la racine du serveur, on va créer un dossier qui va être partagé sur les serveurs Docker.

sudo mkdir docker-data

On va maintenant configurer les accès au partage :

sudo nano /etc/exports

Dans le fichier; il faut ajouter une ligne par nœud :

/shared-folder    target-ip(rw,async,no_subtree_check,no_root_squash)

Ce qui donne dans ce cas :

Maintenant, il faut ajuster les droits :

sudo chown nobody:nogroup docker-data/ -R

Redémarrer le service NFS pour recharger la configuration

sudo systemctl restart nfs-kernel-server

Installation et configuration des nœuds Docker

Pour commencer, on va installer Docker et configurer le partage sur les nœuds Docker.

Pour installer Docker, utiliser le script qui se trouve ici : Ubuntu 24.04 : Installation de Docker et Docker compose

Ensuite installer le client NFS :

sudo apt install nfs-common -y

Créer un dossier qui va permettre le mappage du dossier du NFS :

sudo mkdir -P /containers/data

Editer le fichier /etc/fstab

sudo nano /etc/fstab

Ajouter la ligne suivante :

ip-nfs-server:/shared-folder /local/folder nfs defaults,_netdev 0 0

Tester le montage : sudo mount -a

Redémarrer le serveur est vérifier que le partage NFS remonte correctement.

Répéter l’opération sur chaque nœuds.

Création du cluster Swarm

Sur le nœuds manager, entrer la commande suivante pour initier le Swarm :

sudo docker swarm init --advertise-addr ip-server

La commande va afficher la ligne de commande à entrer pour joindre les autres nœuds, noter cette commande car elle contient le token qui va permettre d’ajouter les nœuds.

Si vous souhaitez configurer les adresses IP dédiées, il faut initier le Swarm avec le commande suivante :

sudo docker swarm init --default-addr-pool 10.151.0.0/16 --advertise-addr ip-server

Une fois le Swarm initialiser vérifier les nœuds :

sudo docker node ls

On peut voir le manager dans la liste des nœuds.

Ajouter les Workers au Swarm

Sur chaque Worker exécuter la commande qui permet la jonction au Swarm :

sudo docker swarm join --token YXZ123456789 IP-MANAGER:2377

Afficher de nouveau le liste des nœuds :

Le cluster Swarm est prêt.

Lancer votre premier service

Pour finir ce tutoriel, on va voir comment faire fonctionner votre premier service sur le cluster Swarm.

Avant de commencer, il faut savoir que les fichiers de configuration pour faire fonctionner les services en Swarm sont différents des fichiers docker-compose.yml même si au premier abord cela semble similaire.

Le cluster Swarm ne prend pas en charger les fichiers .env.

En guise d’exemple, voici le fichier qui va permettre de lancer uptime-kuma :

version: "3.13"
services:
  uptime-kuma:
    image: 'louislam/uptime-kuma:beta'
    volumes:
      - /containers/data/uptime-kuma/data-kuma:/app/data
    ports:
      - '3001:3001'
    depends_on:
      - mariadb
    deploy:
      replicas: 1
      restart_policy:
        condition: any
      placement:
        constraints: [node.role == worker]

  mariadb:
    image: 'mariadb:11'
    command: ["--max_allowed_packet=512M"]
    environment:
      MYSQL_ROOT_PASSWORD: change-me
      MYSQL_DATABASE: ukuma
      MYSQL_USER: ukuma
      MYSQL_PASSWORD: change-me
    ports:
      - '3306:3306'
    volumes:
      - /containers/data/uptime-kuma/data-mariadb:/var/lib/mysql
    deploy:
      replicas: 1
      restart_policy:
        condition: any
      placement:
        constraints: [node.role == worker]

Déployer le stack :

sudo docker stack deploy -d --compose-file compose.yml uptime-kuma

Vous avez déployer votre premier service.

A travers ce tutoriel, on a vu comment déployer un cluster Docker Swarm.