Comment utiliser la commande docker stack ps pour lister les tâches d'une pile Docker

Introduction

Dans ce laboratoire, vous apprendrez à utiliser efficacement la commande docker stack ps pour lister et gérer les tâches au sein d'une pile Docker (Docker stack). Vous commencerez par déployer une pile d'exemple à l'aide de Docker Compose, un outil puissant pour définir et exécuter des applications multi-conteneurs.

Après le déploiement de la pile, vous explorerez les diverses fonctionnalités de docker stack ps. Cela inclut la liste de toutes les tâches de la pile, le filtrage des tâches en fonction de leurs noms, la mise en forme de la sortie pour afficher des champs spécifiques d'intérêt, et enfin, l'affichage uniquement des identifiants de tâche pour une vue concise. Cette expérience pratique vous dotera des compétences nécessaires pour surveiller et comprendre l'état des tâches de votre pile Docker.

Skills Graph

Déployer une pile d'exemple

Dans cette étape, vous apprendrez à déployer une pile d'exemple à l'aide de Docker Compose. Docker Compose est un outil permettant de définir et d'exécuter des applications Docker multi-conteneurs. Avec Compose, vous utilisez un fichier YAML pour configurer les services de votre application. Ensuite, avec une seule commande, vous créez et démarrez tous les services à partir de votre configuration.

Étant donné que Docker Compose n'est pas préinstallé dans l'environnement LabEx, vous devez d'abord l'installer. Nous allons installer la version 1.29.2 de Docker Compose, qui est compatible avec la version de Docker installée.

Tout d'abord, téléchargez le binaire Docker Compose :

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

Cette commande télécharge le binaire Docker Compose depuis le dépôt GitHub officiel 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.

Ensuite, appliquez les autorisations d'exécution au binaire :

sudo chmod +x /usr/local/bin/docker-compose

Cette commande rend le fichier téléchargé exécutable.

Maintenant, vérifiez l'installation en vérifiant la version de Docker Compose :

docker-compose --version

Vous devriez voir une sortie similaire à docker-compose version 1.29.2, build 5becea4c.

Maintenant que Docker Compose est installé, créons un simple fichier Docker Compose pour définir notre pile. Nous allons créer un fichier nommé docker-compose.yml dans le répertoire ~/project.

Utilisez l'éditeur nano pour créer et éditer le fichier :

nano ~/project/docker-compose.yml

Collez le contenu suivant dans le fichier docker-compose.yml :

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  app:
    image: alpine:latest
    command: echo "Hello from Alpine"

Ce fichier docker-compose.yml définit deux services :

• web : Utilise l'image nginx:latest et mappe le port 80 de l'hôte sur le port 80 du conteneur.
• app : Utilise l'image alpine:latest et exécute une simple commande echo.

Enregistrez le fichier en appuyant sur Ctrl + S et quittez l'éditeur en appuyant sur Ctrl + X.

Avant de déployer la pile, téléchargeons les images nécessaires. Bien que Docker Compose puisse télécharger les images automatiquement lors du déploiement, le téléchargement explicite au préalable peut parfois être utile.

Téléchargez l'image nginx:latest :

docker pull nginx:latest

Téléchargez l'image alpine:latest :

docker pull alpine:latest

Maintenant, déployez la pile à l'aide de la commande docker-compose up. Le flag -d exécute les conteneurs en mode détaché (en arrière-plan).

Accédez au répertoire ~/project où vous avez créé le fichier docker-compose.yml :

cd ~/project

Ensuite, exécutez la commande :

docker-compose up -d

Cette commande lit le fichier docker-compose.yml et crée et démarre les services définis. Vous devriez voir une sortie indiquant la création et le démarrage des services web et app.

Pour vérifier que les services sont en cours d'exécution, vous pouvez lister les conteneurs en cours d'exécution :

docker ps

Vous devriez voir deux conteneurs en cours d'exécution, l'un pour le service web (basé sur nginx) et l'autre pour le service app (basé sur alpine).

Lister toutes les tâches de la pile

Dans cette étape, vous apprendrez à lister toutes les tâches (conteneurs) associées à la pile que vous avez déployée à l'étape précédente. Dans Docker Swarm ou Kubernetes, le terme "tâche" est souvent utilisé pour désigner une instance en cours d'exécution d'un service. Bien que nous utilisions ici Docker Compose, qui n'utilise pas techniquement le concept de "tâche" de la même manière que Swarm, nous pouvons toujours lister les conteneurs qui composent notre pile déployée.

La commande docker-compose ps est utilisée pour lister les conteneurs gérés par Docker Compose pour le projet actuel (le répertoire contenant le fichier docker-compose.yml).

Assurez-vous que vous êtes toujours dans le répertoire ~/project où se trouve votre fichier docker-compose.yml :

cd ~/project

Maintenant, exécutez la commande docker-compose ps :

docker-compose ps

Cette commande affichera une liste des conteneurs définis dans votre fichier docker-compose.yml, ainsi que leur état actuel, leur commande et leurs ports.

Vous devriez voir une sortie similaire à ceci (les noms et les identifiants des conteneurs varieront) :

      Name                     Command               State          Ports
--------------------------------------------------------------------------------
project_app_1       /bin/sh -c echo "Hello fr ...   Exit 0
project_web_1       /docker-entrypoint.sh ngin ...   Up      0.0.0.0:80->80/tcp

Cette sortie montre les deux services définis dans votre docker-compose.yml : app et web. La colonne State indique si le conteneur est en cours d'exécution (Up) ou s'il a terminé son exécution (Exit 0). La colonne Ports montre le mappage de ports pour le service web.

Le conteneur app a terminé son exécution car sa commande echo "Hello from Alpine" a fini de s'exécuter. Le conteneur web est toujours en cours d'exécution car le serveur Nginx est conçu pour fonctionner en continu.

Cette commande est utile pour voir rapidement quels services de votre pile sont en cours d'exécution et leur statut de base.

Filtrer les tâches par nom

Dans cette étape, vous apprendrez à filtrer la liste des conteneurs gérés par Docker Compose en fonction du nom de leur service. Cela est utile lorsque vous avez une grande pile avec de nombreux services et que vous ne voulez voir que le statut d'un service spécifique.

La commande docker-compose ps vous permet de spécifier le nom du service en tant qu'argument pour filtrer la sortie.

Assurez-vous que vous êtes dans le répertoire ~/project :

cd ~/project

Pour lister uniquement le conteneur du service web, exécutez la commande suivante :

docker-compose ps web

Cette commande n'affichera que les informations concernant le conteneur associé au service web défini dans votre docker-compose.yml.

Vous devriez voir une sortie similaire à ceci :

      Name                     Command               State          Ports
--------------------------------------------------------------------------------
project_web_1       /docker-entrypoint.sh ngin ...   Up      0.0.0.0:80->80/tcp

De même, pour lister uniquement le conteneur du service app, exécutez :

docker-compose ps app

Cela affichera les informations concernant le conteneur app :

      Name                     Command               State          Ports
--------------------------------------------------------------------------------
project_app_1       /bin/sh -c echo "Hello fr ...   Exit 0

Le filtrage par nom de service est un moyen simple mais efficace de gérer et de surveiller les composants individuels de votre pile Docker Compose.

Formater la sortie pour afficher des champs spécifiques

Dans cette étape, vous apprendrez à formater la sortie de la commande docker-compose ps pour n'afficher que des champs spécifiques. Cela est utile lorsque vous avez besoin d'extraire des informations particulières sur vos services, telles que leurs noms ou leur statut, pour des scripts ou un traitement ultérieur.

La commande docker-compose ps prend en charge le drapeau --format, qui vous permet de spécifier le format de sortie en utilisant des modèles Go.

Assurez-vous que vous êtes dans le répertoire ~/project :

cd ~/project

Pour afficher uniquement le nom du service et l'état du conteneur, vous pouvez utiliser la commande suivante :

docker-compose ps --format "table {{.Service}}\t{{.State}}"

Décortiquons le drapeau --format :

• "table": Cela spécifie que la sortie doit être au format tableau avec des en-têtes.
• {{.Service}}: C'est un espace réservé de modèle Go qui représente le nom du service.
• \t: C'est un caractère de tabulation, utilisé ici pour séparer les colonnes.
• {{.State}}: C'est un espace réservé de modèle Go qui représente l'état du conteneur.

La sortie ressemblera à ceci :

SERVICE         STATE
app             Exit 0
web             Up

Vous pouvez également inclure d'autres champs dans la chaîne de format. Par exemple, pour afficher le nom du service, l'image et l'état :

docker-compose ps --format "table {{.Service}}\t{{.Image}}\t{{.State}}"

La sortie sera :

SERVICE         IMAGE           STATE
app             alpine:latest   Exit 0
web             nginx:latest    Up

L'utilisation du drapeau --format offre une grande flexibilité dans la façon dont vous visualisez et traitez les informations sur vos services Docker Compose.

Afficher uniquement les identifiants de tâches

Dans cette étape, vous apprendrez à afficher uniquement les identifiants de conteneurs pour les services de votre pile Docker Compose. Cela est particulièrement utile lorsque vous avez besoin de passer les identifiants de conteneurs à d'autres commandes à des fins d'automatisation ou de scripting.

Nous allons de nouveau utiliser le drapeau --format avec la commande docker-compose ps, mais cette fois-ci nous allons spécifier uniquement le champ de l'identifiant de conteneur.

Assurez-vous que vous êtes dans le répertoire ~/project :

cd ~/project

Pour afficher uniquement les identifiants de conteneurs, utilisez la commande suivante :

docker-compose ps -q

Le drapeau -q est un raccourci pour --quiet, qui affiche uniquement les identifiants de conteneurs.

Alternativement, vous pouvez obtenir le même résultat en utilisant le drapeau --format :

docker-compose ps --format "{{.ID}}"

Cette commande utilise le modèle Go {{.ID}} pour extraire uniquement l'identifiant de conteneur de chaque service.

La sortie de l'une ou l'autre commande sera une liste d'identifiants de conteneurs, un par ligne :

<container_id_for_app>
<container_id_for_web>

(Les identifiants réels seront différents dans votre environnement).

Afficher uniquement les identifiants est une exigence courante lorsque vous avez besoin d'interagir de manière programmée avec vos conteneurs, par exemple, pour les arrêter ou les supprimer.

Enfin, nettoyons la pile déployée en l'arrêtant. Cela arrêtera et supprimera les conteneurs et les réseaux créés par docker-compose up.

Assurez-vous que vous êtes dans le répertoire ~/project :

cd ~/project

Exécutez la commande suivante :

docker-compose down

Cette commande arrêtera et supprimera les conteneurs des services web et app. Vous devriez voir une sortie indiquant que les conteneurs et le réseau sont en cours de suppression.

Après avoir exécuté docker-compose down, vous pouvez vérifier que les conteneurs ne sont plus en cours d'exécution en utilisant docker ps :

docker ps

Cette commande ne devrait maintenant afficher aucun conteneur en cours d'exécution.

Résumé

Dans ce laboratoire, vous avez appris à déployer une pile d'exemple à l'aide de Docker Compose. Cela a impliqué l'installation de Docker Compose, la création d'un fichier docker-compose.yml pour définir les services, puis le déploiement de la pile.

Après le déploiement, vous avez appris à utiliser la commande docker stack ps pour lister toutes les tâches de la pile déployée. Vous avez également exploré comment filtrer ces tâches par nom, formater la sortie pour afficher des champs spécifiques et afficher uniquement les identifiants de tâches, ce qui démontre la flexibilité de la commande docker stack ps pour la surveillance et la gestion des tâches de la pile.