Comment utiliser la commande docker stack deploy pour gérer les services Swarm

Introduction

Dans ce laboratoire, vous apprendrez à gérer efficacement les services Docker Swarm à l'aide de la commande docker stack deploy. Nous commencerons par préparer un simple fichier docker-compose.yml, qui servira de modèle pour notre pile d'applications.

Après la préparation, vous déployerez cette pile sur votre Docker Swarm, vérifierez le déploiement réussi des services définis, puis explorerez comment mettre à jour la pile en modifiant le fichier de composition. Enfin, vous apprendrez à supprimer les services qui ne sont plus référencés dans la configuration mise à jour, afin de garantir que votre Swarm reste propre et efficace.

Préparez un simple fichier docker-compose pour le déploiement sur Swarm

Dans cette étape, nous allons préparer un simple fichier docker-compose.yml que nous utiliserons pour déployer une pile sur un Docker Swarm. Avant de pouvoir utiliser docker-compose, nous devons l'installer.

Tout d'abord, installons docker-compose. Nous allons télécharger le binaire et le rendre exécutable.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Cette commande télécharge le binaire docker-compose à partir de la page officielle des versions sur GitHub et le sauvegarde dans /usr/local/bin/docker-compose. Les parties $(uname -s) et $(uname -m) détectent automatiquement votre système d'exploitation et votre architecture. La commande chmod +x rend le fichier téléchargé exécutable.

Maintenant, vérifions l'installation en vérifiant la version.

docker-compose --version

Vous devriez voir la version installée de docker-compose affichée dans la console.

Ensuite, nous allons créer un simple fichier docker-compose.yml dans le répertoire ~/project. Ce fichier définira un seul service en utilisant l'image nginx.

nano ~/project/docker-compose.yml

Collez le contenu suivant dans l'éditeur nano :

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Analysons ce fichier docker-compose.yml :

• version: '3.8' spécifie la version du format de fichier Compose. La version 3.8 est adaptée pour les déploiements sur Swarm.
• services: définit les services qui composent votre application.
• web: est le nom de notre service. Vous pouvez choisir n'importe quel nom que vous souhaitez.
• image: nginx:latest spécifie l'image Docker à utiliser pour ce service. Nous utilisons la dernière version de l'image officielle nginx.
• ports: mappe les ports entre l'hôte et le conteneur. "80:80" mappe le port 80 de l'hôte sur le port 80 du conteneur.

Enregistrez le fichier en appuyant sur Ctrl + X, puis Y, puis Entrée.

Avant de pouvoir déployer ce service, nous devons nous assurer que l'image nginx:latest est disponible localement. Nous pouvons télécharger l'image à l'aide de la commande docker pull.

docker pull nginx:latest

Cette commande télécharge l'image nginx:latest depuis Docker Hub sur votre machine locale.

Maintenant, vous avez un simple fichier docker-compose.yml prêt pour le déploiement et l'image nécessaire téléchargée.

Déployez une pile sur le Swarm en utilisant le fichier de composition

Dans cette étape, nous allons déployer la pile définie dans notre fichier docker-compose.yml sur un Docker Swarm. Avant de pouvoir déployer une pile, nous devons initialiser un Docker Swarm.

Tout d'abord, initialisons le Swarm. Étant donné que nous utilisons une seule machine virtuelle, nous l'initialiserons en tant que Swarm à un seul nœud.

docker swarm init

Cette commande initialise un nouveau Swarm et transforme le nœud actuel en nœud gestionnaire. Vous devriez voir un message indiquant que le Swarm a été initialisé.

Maintenant que le Swarm est initialisé, nous pouvons déployer notre pile à l'aide de la commande docker stack deploy. Nous allons donner un nom à notre pile, par exemple, mywebstack.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Analysons cette commande :

• docker stack deploy est la commande utilisée pour déployer une pile sur un Swarm.
• -c ~/project/docker-compose.yml spécifie le fichier de composition à utiliser pour le déploiement. Nous utilisons le fichier que nous avons créé à l'étape précédente.
• mywebstack est le nom que nous donnons à notre pile. Ce nom sera utilisé pour identifier les services et les conteneurs appartenant à cette pile dans le Swarm.

Après avoir exécuté cette commande, Docker Swarm créera les services définis dans le fichier docker-compose.yml. Vous devriez voir un message indiquant que les services sont en cours de création ou de mise à jour.

Pour vérifier que la pile a été déployée, nous pouvons lister les piles en cours d'exécution.

docker stack ls

Cette commande affichera la liste de toutes les piles déployées dans votre Swarm. Vous devriez voir mywebstack dans la liste.

Nous pouvons également lister les services en cours d'exécution dans notre pile.

docker stack services mywebstack

Cette commande affichera les services associés à la pile mywebstack. Vous devriez voir le service mywebstack_web dans la liste, ainsi que des informations sur ses réplicas et son image.

Enfin, vérifions l'état des tâches du service.

docker service ps mywebstack_web

Cette commande affiche les tâches (conteneurs en cours d'exécution) pour le service mywebstack_web. Vous devriez voir au moins une tâche avec l'état Running.

Vous avez maintenant initialisé avec succès un Docker Swarm et déployé une pile à l'aide d'un fichier docker-compose.yml.

Vérifiez les services déployés

Dans cette étape, nous allons vérifier que les services déployés à l'étape précédente fonctionnent correctement et sont accessibles. Nous avons déployé un serveur web Nginx, qui devrait écouter sur le port 80.

Tout d'abord, utilisons la commande docker service ls pour voir la liste des services en cours d'exécution dans le Swarm.

docker service ls

Vous devriez voir le service mywebstack_web répertorié avec 1/1 réplica, indiquant qu'une instance du service est en cours d'exécution.

Ensuite, nous pouvons utiliser curl pour accéder au serveur web Nginx en cours d'exécution à l'intérieur du conteneur. Étant donné que nous avons mappé le port 80 de l'hôte sur le port 80 du conteneur, nous pouvons y accéder via localhost sur le port 80.

curl localhost:80

Cette commande envoie une requête HTTP à localhost sur le port 80. Si le serveur Nginx fonctionne correctement, vous devriez recevoir le code HTML de la page d'accueil par défaut de Nginx en sortie. Cela confirme que le service est en cours d'exécution et accessible depuis la machine hôte.

Pour inspecter plus en détail le conteneur en cours d'exécution pour le service web, nous pouvons utiliser la commande docker ps.

docker ps

Cette commande liste tous les conteneurs en cours d'exécution. Vous devriez voir un conteneur exécutant l'image nginx, avec un nom similaire à mywebstack_web.1.<task_id>. La colonne PORTS devrait afficher 0.0.0.0:80->80/tcp, confirmant le mappage de ports.

Nous pouvons également inspecter les détails du service à l'aide de la commande docker service inspect.

docker service inspect mywebstack_web

Cette commande fournit des informations détaillées sur le service mywebstack_web, y compris sa configuration, ses tâches et ses paramètres réseau. Vous pouvez faire défiler la sortie pour voir divers détails sur le service.

En effectuant ces vérifications, nous avons vérifié que notre service Nginx déployé fonctionne comme prévu et est accessible.

Mettez à jour la pile avec un fichier de composition modifié

Dans cette étape, nous allons modifier notre fichier docker-compose.yml pour mettre à jour la pile déployée. Nous allons changer la version de l'image Nginx et ajouter un deuxième service.

Tout d'abord, éditons le fichier docker-compose.yml.

nano ~/project/docker-compose.yml

Modifiez le fichier pour inclure un deuxième service, par exemple, un service alpine, et changez la version de l'image Nginx en 1.21.6. Le fichier mis à jour devrait ressembler à ceci :

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"
  alpine:
    image: alpine:latest
    command: ["sleep", "infinity"]

Examinons les modifications :

• Nous avons changé l'image du service web de nginx:latest à nginx:1.21.6.
• Nous avons ajouté un nouveau service nommé alpine.
• Le service alpine utilise l'image alpine:latest.
• La commande command: ["sleep", "infinity"] maintient le conteneur alpine en cours d'exécution indéfiniment.

Enregistrez le fichier modifié en appuyant sur Ctrl + X, puis Y, puis Entrée.

Avant de déployer la pile mise à jour, nous devons télécharger les nouvelles images nginx:1.21.6 et alpine:latest.

docker pull nginx:1.21.6
docker pull alpine:latest

Maintenant, nous pouvons déployer la pile mise à jour en utilisant la même commande docker stack deploy et le même nom de pile. Docker Swarm détectera les modifications dans le fichier docker-compose.yml et mettra à jour la pile existante.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Docker Swarm effectuera une mise à jour progressive pour le service web, remplaçant l'ancien conteneur nginx:latest par un nouveau utilisant nginx:1.21.6. Il créera également le nouveau service alpine et son conteneur correspondant. Vous devriez voir un message indiquant que les services sont en cours de mise à jour ou de création.

Pour vérifier la mise à jour, listons à nouveau les services de la pile.

docker stack services mywebstack

Vous devriez maintenant voir les services mywebstack_web et mywebstack_alpine répertoriés. Le service mywebstack_web devrait afficher l'image mise à jour nginx:1.21.6.

Vous avez mis à jour avec succès votre pile déployée en modifiant le fichier docker-compose.yml et en le redéployant.

Nettoyez les services non référencés dans le fichier de composition

Dans cette étape, nous allons modifier à nouveau notre fichier docker-compose.yml, cette fois en supprimant un service. Lorsque nous redéployons la pile, Docker Swarm détectera qu'un service n'est plus défini dans le fichier de composition et le supprimera. Ce processus est parfois appelé « nettoyage » (pruning en anglais) des services.

Tout d'abord, éditons le fichier docker-compose.yml pour supprimer le service alpine.

nano ~/project/docker-compose.yml

Supprimez toute la section alpine: du fichier. Le fichier devrait revenir à son état initial, ne définissant que le service web :

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"

Enregistrez le fichier modifié en appuyant sur Ctrl + X, puis Y, puis Entrée.

Maintenant, déployez à nouveau la pile en utilisant le fichier docker-compose.yml modifié.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Docker Swarm comparera l'état actuel de la pile mywebstack avec la définition dans le fichier docker-compose.yml mis à jour. Il remarquera que le service alpine n'est plus présent dans le fichier et supprimera le service correspondant et ses tâches du Swarm. Vous devriez voir un message indiquant que le service alpine est en cours de suppression.

Pour vérifier que le service alpine a été supprimé, listez à nouveau les services de la pile.

docker stack services mywebstack

Vous devriez maintenant ne voir que le service mywebstack_web répertorié. Le service mywebstack_alpine devrait avoir disparu.

Enfin, pour nettoyer l'environnement Swarm, nous pouvons supprimer toute la pile.

docker stack rm mywebstack

Cette commande supprime la pile mywebstack, y compris tous ses services et tâches. Vous devriez voir un message confirmant la suppression.

Pour vérifier que la pile a été supprimée, listez à nouveau les piles.

docker stack ls

La pile mywebstack ne devrait plus être répertoriée.

Vous avez réussi à supprimer un service de votre pile en le supprimant du fichier docker-compose.yml et en le redéployant, puis à nettoyer l'environnement en supprimant toute la pile.

Résumé

Dans ce laboratoire, nous avons appris à utiliser la commande docker stack deploy pour gérer les services Docker Swarm. Nous avons commencé par préparer un simple fichier docker-compose.yml, qui est la méthode standard pour définir des applications multi-services pour Docker. Cela a impliqué l'installation de docker-compose et la création d'un fichier YAML de base définissant un seul service Nginx avec un mappage de ports.

Après la préparation, nous avons déployé cette pile sur un Docker Swarm en utilisant docker stack deploy, vérifié le déploiement réussi du service, puis nous avons pratiqué la mise à jour de la pile en modifiant le fichier docker-compose.yml et en le redéployant. Enfin, nous avons appris à supprimer (pruning en anglais) les services qui ne sont plus définis dans le fichier de composition mis à jour, afin de garantir que notre environnement Swarm reste propre et reflète la définition actuelle de l'application.