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.
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'imagenginx:latestet mappe le port 80 de l'hôte sur le port 80 du conteneur.app: Utilise l'imagealpine:latestet exécute une simple commandeecho.
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 ID des 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.
