Comment utiliser la commande docker service create pour déployer et gérer des services

DockerDockerBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous aurez l'opportunité de gagner une expérience pratique en utilisant la commande docker service create pour déployer et gérer des services au sein d'un Docker Swarm. Vous apprendrez à créer et à inspecter différents types de services, notamment des services répliqués simples pour une haute disponibilité et une évolutivité, ainsi que des services globaux qui s'exécutent sur chaque nœud.

En outre, vous explorerez des configurations de service avancées telles que la mise en œuvre de politiques de mise à jour progressive pour des déploiements sans interruption, l'utilisation de montages liés (bind mounts) et de variables d'environnement pour la persistance des données et la configuration, et l'application de contraintes et de préférences de placement pour contrôler où vos tâches de service s'exécutent au sein du swarm. En effectuant ces étapes, vous développerez une solide compréhension de la gestion efficace des applications conteneurisées dans un environnement Docker Swarm.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker/ContainerOperationsGroup -.-> docker/run("Run a Container") docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/ps("List Running Containers") docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") subgraph Lab Skills docker/run -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} docker/ls -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} docker/ps -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} docker/exec -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} docker/inspect -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} docker/create -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} docker/pull -.-> lab-555224{{"Comment utiliser la commande docker service create pour déployer et gérer des services"}} end

Créer un service répliqué simple

Dans cette étape, vous apprendrez à créer un service répliqué simple dans Docker Swarm. Un service répliqué est un service qui exécute plusieurs tâches identiques dans le swarm. Cela offre une haute disponibilité et une évolutivité.

Tout d'abord, assurons-nous que Docker est en cours d'exécution et que vous êtes dans le bon répertoire.

docker version
pwd

Vous devriez voir une sortie indiquant la version de Docker et votre répertoire actuel /home/labex/project.

Avant de créer un service, nous devons télécharger l'image Docker nécessaire. Nous utiliserons l'image nginx pour cet exemple.

docker pull nginx:latest

Cette commande télécharge la dernière version de l'image nginx depuis Docker Hub.

Maintenant, créons un service répliqué simple nommé my-nginx-service avec 3 réplicas.

docker service create --name my-nginx-service --replicas 3 nginx:latest

Cette commande crée un nouveau service nommé my-nginx-service en utilisant l'image nginx:latest et définit le nombre de réplicas souhaités à 3. Docker Swarm distribuera ensuite ces 3 tâches sur les nœuds disponibles dans le swarm.

Pour vérifier l'état du service et de ses tâches, vous pouvez utiliser les commandes docker service ls et docker service ps.

docker service ls
docker service ps my-nginx-service

La commande docker service ls répertorie tous les services en cours d'exécution dans le swarm, affichant leur ID, leur nom, leur mode, le nombre de réplicas et l'image. La commande docker service ps my-nginx-service affiche les tâches associées au service my-nginx-service, y compris leur état (par exemple, En cours d'exécution, Arrêté), l'état souhaité et le nœud sur lequel elles s'exécutent. Vous devriez voir 3 tâches dans l'état "En cours d'exécution".

Créer un service global et inspecter ses tâches

Dans cette étape, vous apprendrez à créer un service global dans Docker Swarm. Contrairement aux services répliqués qui exécutent un nombre spécifié de tâches, un service global exécute exactement une tâche sur chaque nœud du swarm qui répond aux contraintes du service. Cela est utile pour des services tels que des agents de surveillance ou des collecteurs de journaux qui doivent s'exécuter sur chaque nœud.

Nous utiliserons l'image busybox pour cet exemple. Téléchargeons d'abord l'image.

docker pull busybox:latest

Cette commande télécharge la dernière version de l'image busybox.

Maintenant, créons un service global nommé my-global-service.

docker service create --name my-global-service --mode global busybox:latest sleep infinity

Cette commande crée un nouveau service nommé my-global-service en utilisant l'image busybox:latest. Le paramètre --mode global spécifie qu'il s'agit d'un service global. La commande sleep infinity est utilisée pour maintenir le conteneur en cours d'exécution indéfiniment.

Pour inspecter les tâches du service global, vous pouvez utiliser la commande docker service ps.

docker service ps my-global-service

Cette commande affichera les tâches associées au service my-global-service. Étant donné qu'il s'agit d'un service global, vous devriez voir une tâche en cours d'exécution pour chaque nœud de votre swarm. Dans cet environnement de laboratoire (Lab), vous verrez probablement une seule tâche car il n'y a qu'un seul nœud. La sortie affichera l'état de la tâche, l'état souhaité et le nœud sur lequel elle s'exécute.

Vous pouvez également inspecter la configuration du service en utilisant la commande docker service inspect.

docker service inspect my-global-service

Cette commande fournit des informations détaillées sur le service, y compris son mode, le nombre de réplicas (qui sera de 0 pour un service global dans la liste des services, mais docker service ps affichera les tâches par nœud) et d'autres détails de configuration.

Créer un service avec des réplicas et une politique de mise à jour progressive

Dans cette étape, vous apprendrez à créer un service répliqué et à configurer sa politique de mise à jour progressive (rolling update). Les mises à jour progressives vous permettent de mettre à jour votre service vers une nouvelle version sans temps d'arrêt en remplaçant progressivement les tâches par la nouvelle version.

Nous continuerons à utiliser l'image nginx. Créons un service répliqué nommé my-nginx-update-service avec 5 réplicas et une politique de mise à jour progressive.

docker service create \
  --name my-nginx-update-service \
  --replicas 5 \
  --update-delay 10s \
  --update-parallelism 2 \
  nginx:latest

Cette commande crée un service avec les configurations suivantes :

  • --name my-nginx-update-service : Définit le nom du service.
  • --replicas 5 : Définit le nombre de réplicas souhaité à 5.
  • --update-delay 10s : Définit le délai entre la mise à jour de chaque groupe de tâches à 10 secondes.
  • --update-parallelism 2 : Définit le nombre de tâches à mettre à jour simultanément à 2.

Ces paramètres de mise à jour définissent comment le service sera mis à jour lorsque vous déployez une nouvelle version de l'image. Docker Swarm mettra à jour 2 tâches à la fois, en attendant 10 secondes avant de mettre à jour le prochain lot.

Vous pouvez vérifier l'état du service et ses tâches en utilisant les commandes docker service ls et docker service ps.

docker service ls
docker service ps my-nginx-update-service

Vous devriez voir my-nginx-update-service répertorié avec 5/5 réplicas et les tâches dans l'état "En cours d'exécution".

Maintenant, simulons une mise à jour en changeant l'image pour une version différente. Nous utiliserons l'image nginx:1.21. Tout d'abord, téléchargez l'image.

docker pull nginx:1.21

Maintenant, mettez à jour le service pour utiliser l'image nginx:1.21.

docker service update --image nginx:1.21 my-nginx-update-service

Cette commande lance une mise à jour progressive. Docker Swarm commencera à remplacer les tâches nginx:latest par des tâches nginx:1.21 selon les paramètres --update-parallelism et --update-delay que vous avez configurés précédemment.

Vous pouvez observer le processus de mise à jour progressive en exécutant plusieurs fois la commande docker service ps my-nginx-update-service.

docker service ps my-nginx-update-service

Vous verrez les tâches passer de l'état "En cours d'exécution" avec l'ancienne image à l'état "Arrêté", puis de nouvelles tâches démarrer avec la nouvelle image et entrer dans l'état "En cours d'exécution". La mise à jour se fera par lots de 2 tâches avec un délai de 10 secondes entre les lots.

Créer un service avec des montages bind et des variables d'environnement

Dans cette étape, vous apprendrez à créer un service qui utilise des montages bind (montages liés) pour conserver des données et des variables d'environnement pour configurer l'application à l'intérieur du conteneur. Les montages bind vous permettent de monter un fichier ou un répertoire de la machine hôte dans un conteneur, rendant les données accessibles au conteneur et persistantes même si le conteneur est supprimé. Les variables d'environnement sont un moyen courant de passer des informations de configuration aux applications.

Tout d'abord, créons un répertoire sur la machine hôte que nous monterons dans le conteneur.

mkdir -p ~/project/html

Cette commande crée un répertoire nommé html à l'intérieur de votre répertoire ~/project.

Maintenant, créons un simple fichier HTML à l'intérieur de ce répertoire.

echo "<h1>Hello from Bind Mount!</h1>" > ~/project/html/index.html

Cette commande crée un fichier nommé index.html dans le répertoire ~/project/html avec le contenu "

Hello from Bind Mount!

".

Nous allons à nouveau utiliser l'image nginx. Créons un service répliqué nommé my-nginx-volume-service avec 1 réplica, en montant le répertoire ~/project/html sur le répertoire racine web par défaut de Nginx à l'intérieur du conteneur (/usr/share/nginx/html), et en définissant une variable d'environnement.

docker service create \
  --name my-nginx-volume-service \
  --replicas 1 \
  --publish published=8080,target=80 \
  --mount type=bind,source=/home/labex/project/html,target=/usr/share/nginx/html \
  --env MY_VARIABLE=hello \
  nginx:latest

Décortiquons les nouvelles options :

  • --publish published=8080,target=80 : Cela mappe le port 8080 sur la machine hôte au port 80 à l'intérieur du conteneur, vous permettant d'accéder au serveur web Nginx depuis votre machine hôte.
  • --mount type=bind,source=/home/labex/project/html,target=/usr/share/nginx/html : Cela crée un montage bind. type=bind spécifie le type de montage. source=/home/labex/project/html est le chemin sur la machine hôte. target=/usr/share/nginx/html est le chemin à l'intérieur du conteneur où le répertoire hôte sera monté.
  • --env MY_VARIABLE=hello : Cela définit une variable d'environnement nommée MY_VARIABLE avec la valeur hello à l'intérieur du conteneur.

Vérifiez l'état du service et les tâches :

docker service ls
docker service ps my-nginx-volume-service

Attendez que la tâche soit dans l'état "En cours d'exécution".

Maintenant, vous pouvez accéder au serveur web Nginx en cours d'exécution dans le conteneur en visitant http://localhost:8080 dans un navigateur web ou en utilisant curl.

curl http://localhost:8080

Vous devriez voir le contenu du fichier index.html que vous avez créé : <h1>Hello from Bind Mount!</h1>. Cela confirme que le montage bind fonctionne correctement.

Pour vérifier la variable d'environnement, vous pouvez exécuter une commande à l'intérieur du conteneur en cours d'exécution. Tout d'abord, trouvez l'ID de la tâche du service en cours d'exécution.

docker service ps my-nginx-volume-service

Notez l'ID de la tâche dans la sortie. Ensuite, utilisez docker exec pour exécuter une commande à l'intérieur du conteneur. Remplacez <task_id> par l'ID de la tâche réel.

docker exec < task_id > env | grep MY_VARIABLE

Cette commande exécute la commande env à l'intérieur du conteneur associé à l'ID de la tâche et envoie la sortie à grep MY_VARIABLE pour trouver la variable d'environnement. Vous devriez voir MY_VARIABLE=hello dans la sortie.

Créer un service avec des contraintes et des préférences de placement

Dans cette étape, vous apprendrez à utiliser les contraintes et les préférences de placement pour contrôler où les tâches de votre service sont déployées au sein du Docker Swarm. Les contraintes de placement sont des exigences strictes qu'un nœud doit respecter pour qu'une tâche puisse être planifiée sur lui. Les préférences de placement sont des exigences souples qui influencent la planification, mais qui n'empêchent pas une tâche d'être planifiée si aucun nœud ne répond à la préférence.

Tout d'abord, examinons le nœud actuel pour voir ses étiquettes (labels). Les étiquettes sont des paires clé-valeur que vous pouvez attacher aux nœuds pour fournir des métadonnées.

docker node inspect self --format '{{ .Spec.Labels }}'

Cette commande examine le nœud actuel (identifié par self) et formate la sortie pour afficher ses étiquettes. Par défaut, il n'y a peut-être pas d'étiquettes personnalisées.

Ajoutons une étiquette au nœud actuel. Nous allons ajouter l'étiquette node_type=app.

docker node update --label-add node_type=app self

Cette commande met à jour le nœud actuel et ajoute l'étiquette node_type=app.

Vérifions maintenant que l'étiquette a été ajoutée.

docker node inspect self --format '{{ .Spec.Labels }}'

Vous devriez voir map[node_type:app] dans la sortie, indiquant que l'étiquette a été ajoutée avec succès.

Maintenant, créons un service répliqué nommé my-constrained-service avec une contrainte de placement qui exige que le nœud ait l'étiquette node_type=app. Nous allons utiliser l'image nginx.

docker service create \
  --name my-constrained-service \
  --replicas 1 \
  --constraint 'node.labels.node_type == app' \
  nginx:latest

Cette commande crée un service avec une contrainte. --constraint 'node.labels.node_type == app' spécifie que les tâches de ce service ne peuvent être planifiées que sur les nœuds où l'étiquette node_type est égale à app. Étant donné que nous avons ajouté cette étiquette au nœud actuel, la tâche devrait être planifiée ici.

Vérifiez l'état du service et les tâches :

docker service ls
docker service ps my-constrained-service

Vous devriez voir my-constrained-service répertorié et sa tâche en cours d'exécution sur le nœud actuel.

Maintenant, créons un autre service avec une préférence de placement. Les préférences de placement sont utilisées pour guider l'ordonnanceur, mais ne sont pas strictement appliquées. Nous allons utiliser l'image busybox et préférer les nœuds avec l'étiquette node_type=database. Étant donné que notre nœud actuel n'a pas cette étiquette, la tâche sera toujours planifiée sur le nœud actuel, mais s'il y avait d'autres nœuds avec cette étiquette, l'ordonnanceur les préférerait.

Tout d'abord, téléchargez l'image busybox.

docker pull busybox:latest

Maintenant, créez le service avec une préférence de placement.

docker service create \
  --name my-preferred-service \
  --replicas 1 \
  --placement-pref 'spread=node.labels.node_type' \
  busybox:latest sleep infinity

L'option --placement-pref 'spread=node.labels.node_type' indique à l'ordonnanceur de répartir les tâches entre les nœuds en fonction de la valeur de l'étiquette node_type. Dans un swarm multi-nœud avec différentes étiquettes node_type, cela distribuerait les tâches plus uniformément. Dans cet environnement mono-nœud, la tâche sera simplement planifiée sur le nœud disponible.

Vérifiez l'état du service et les tâches :

docker service ls
docker service ps my-preferred-service

Vous devriez voir my-preferred-service répertorié et sa tâche en cours d'exécution sur le nœud actuel.

Résumé

Dans ce laboratoire (lab), nous avons appris à utiliser la commande docker service create pour déployer et gérer des services dans Docker Swarm. Nous avons commencé par créer un simple service répliqué en utilisant l'image nginx, en spécifiant le nombre de réplicas souhaité pour garantir une haute disponibilité et une bonne évolutivité. Nous avons ensuite utilisé docker service ls et docker service ps pour vérifier l'état du service et examiner les tâches en cours d'exécution.

Ensuite, nous avons exploré la création d'un service global, en comprenant son comportement consistant à exécuter une tâche sur chaque nœud éligible du swarm. Cela a démontré la flexibilité de Docker Swarm dans le déploiement de services en fonction de différentes exigences.