Comment utiliser la commande docker stack config pour inspecter les fichiers Compose fusionnés

Introduction

Dans ce laboratoire, vous apprendrez à utiliser la commande docker stack config pour inspecter la configuration finale fusionnée de vos fichiers Docker Compose. Cette compétence est essentielle pour comprendre comment Docker interprète vos définitions Compose, en particulier lorsqu'il s'agit de plusieurs fichiers ou de variables d'environnement. Vous commencerez par afficher la configuration à partir d'un seul fichier Compose, y compris les étapes nécessaires pour installer Docker Compose dans l'environnement LabEx.

Ensuite, vous explorerez comment fusionner et afficher la configuration à partir de plusieurs fichiers Compose, démontrant ainsi comment Docker combine les définitions provenant de différentes sources. Vous apprendrez également à afficher la configuration directement à partir de l'entrée standard et à ignorer l'interpolation des variables d'environnement lors de la génération de la sortie de configuration. Ces étapes vous permettront de comprendre de manière approfondie les capacités de la commande docker stack config pour le débogage et la vérification de vos configurations Docker Compose.

Skills Graph

Afficher la configuration finale à partir d'un seul fichier Compose

Dans cette étape, vous apprendrez à afficher la configuration finale à partir d'un seul fichier Docker Compose. Cela est utile pour le débogage ou pour comprendre l'état final de votre fichier Compose après avoir traité toutes les variables et extensions.

Tout d'abord, installons Docker Compose. Comme il n'est pas préinstallé dans l'environnement de la machine virtuelle (VM) LabEx, nous devons le télécharger et l'installer. Nous allons télécharger la dernière version stable.

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

Cette commande télécharge le binaire Docker Compose depuis le dépôt GitHub officiel. $(uname -s) et $(uname -m) sont utilisés pour obtenir le système d'exploitation et l'architecture de la VM, afin de vous assurer de télécharger le bon binaire.

Ensuite, nous devons attribuer les droits d'exécution au binaire téléchargé.

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

Cette commande rend la commande docker-compose 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.

Avant de pouvoir afficher la configuration, nous avons besoin d'un fichier Docker Compose. Créons-en un simple dans le répertoire ~/project.

nano ~/project/docker-compose.yaml

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

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

Il s'agit d'un simple fichier Compose qui définit un seul service nommé web utilisant l'image nginx:latest et mappant le port 80 de l'hôte sur le port 80 du conteneur.

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

Maintenant, accédez au répertoire ~/project où vous avez enregistré le fichier docker-compose.yaml.

cd ~/project

Pour afficher la configuration finale à partir de ce fichier Compose, nous utilisons la commande docker-compose config.

docker-compose config

Cette commande lit le fichier docker-compose.yaml dans le répertoire actuel et affiche la configuration finale fusionnée sur la sortie standard. Vous devriez voir le contenu YAML de votre fichier docker-compose.yaml affiché, éventuellement avec quelques valeurs par défaut supplémentaires ajoutées par Docker Compose.

Fusionner et afficher la configuration à partir de plusieurs fichiers Compose

Dans cette étape, vous apprendrez à fusionner les configurations de plusieurs fichiers Docker Compose et à afficher la configuration finale combinée. Il s'agit d'une fonctionnalité puissante qui vous permet de définir une configuration de base, puis de la remplacer ou de l'étendre avec des fichiers supplémentaires. Cela est utile pour gérer différents environnements (par exemple, développement, préproduction, production).

Nous continuerons à travailler dans le répertoire ~/project. Dans l'étape précédente, nous avons créé un fichier docker-compose.yaml. Maintenant, créons un autre fichier Compose pour étendre la configuration de base. Nous l'appellerons docker-compose.override.yaml.

nano ~/project/docker-compose.override.yaml

Collez le contenu suivant dans le fichier docker-compose.override.yaml :

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html

Ce fichier de substitution modifie le service web défini dans docker-compose.yaml. Il change le mappage de port hôte de 80 à 8080 et ajoute un montage de volume pour servir le contenu HTML statique depuis un répertoire local nommé html.

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

Maintenant, créons le répertoire html et un simple fichier index.html à l'intérieur.

mkdir ~/project/html
nano ~/project/html/index.html

Collez le contenu suivant dans ~/project/html/index.html :

<h1>Hello from Nginx!</h1>

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

Par défaut, Docker Compose recherche automatiquement docker-compose.yaml et docker-compose.override.yaml dans le répertoire actuel et les fusionne. Les configurations du fichier de substitution ont la priorité.

Pour voir la configuration fusionnée, assurez-vous d'être dans le répertoire ~/project et exécutez à nouveau la commande docker-compose config.

cd ~/project
docker-compose config

Vous devriez maintenant voir la configuration combinée, où le service web a le mappage de port 8080:80 et le montage de volume ./html:/usr/share/nginx/html.

Vous pouvez également spécifier explicitement quels fichiers Compose utiliser avec l'option -f. L'ordre dans lequel vous spécifiez les fichiers est important, car les fichiers suivants remplacent les précédents.

Par exemple, pour fusionner explicitement docker-compose.yaml et docker-compose.override.yaml, vous pouvez exécuter :

docker-compose -f docker-compose.yaml -f docker-compose.override.yaml config

Cela produira la même sortie fusionnée que l'exécution de docker-compose config sans l'option -f dans ce cas, car docker-compose.override.yaml est automatiquement détecté et fusionné après docker-compose.yaml.

Afficher la configuration à partir de l'entrée standard (stdin)

Dans cette étape, vous apprendrez à afficher la configuration finale à partir d'un fichier Docker Compose fourni via l'entrée standard (stdin). Cela est utile lorsque vous souhaitez générer un fichier Compose de manière dynamique ou acheminer la sortie d'une autre commande directement vers docker-compose config.

Nous continuerons à travailler dans le répertoire ~/project. Au lieu de lire à partir d'un fichier, nous acheminerons le contenu d'une configuration Compose directement vers la commande docker-compose config.

Utilisons la commande cat pour afficher le contenu de notre fichier docker-compose.yaml et l'acheminer vers docker-compose config.

cd ~/project
cat docker-compose.yaml | docker-compose config -f -

Dans cette commande :

• cat docker-compose.yaml affiche le contenu du fichier docker-compose.yaml sur la sortie standard.
• | est l'opérateur de canalisation (pipe), qui redirige la sortie standard de la commande cat vers l'entrée standard de la commande docker-compose config.
• docker-compose config -f - indique à docker-compose config de lire la configuration à partir de l'entrée standard (-) au lieu d'un fichier.

Vous devriez voir la même sortie que lorsque vous avez exécuté docker-compose config dans la première étape, qui est la configuration issue de docker-compose.yaml.

Vous pouvez également acheminer directement une autre configuration. Par exemple, acheminons une simple configuration pour un service redis.

echo "version: '3.8'\nservices:\n  redis:\n    image: redis:latest" | docker-compose config -f -

Dans cette commande :

• echo "version: '3.8'\nservices:\n redis:\n image: redis:latest" affiche la chaîne YAML pour un simple fichier Compose avec un service redis. Le \n crée des sauts de ligne dans la sortie.
• | achemine cette chaîne vers la commande docker-compose config.
• docker-compose config -f - lit la configuration à partir de l'entrée standard.

La sortie devrait être la configuration YAML pour le service redis.

Cette méthode est particulièrement utile lorsque vous générez des configurations Compose de manière programmée ou lorsque vous souhaitez tester rapidement une configuration sans la sauvegarder dans un fichier.

Afficher la configuration fusionnée en sautant l'interpolation

Dans cette étape, vous apprendrez à afficher la configuration fusionnée à partir de plusieurs fichiers Docker Compose tout en sautant l'interpolation des variables. Par défaut, docker-compose config interpole les variables d'environnement. Ignorer l'interpolation peut être utile lorsque vous souhaitez voir la configuration brute avec les variables toujours présentes, par exemple, lors du débogage ou de la génération d'un modèle.

Nous continuerons à travailler dans le répertoire ~/project avec nos fichiers docker-compose.yaml et docker-compose.override.yaml.

Tout d'abord, ajoutons une variable d'environnement à notre fichier docker-compose.yaml pour démontrer l'interpolation.

nano ~/project/docker-compose.yaml

Modifiez le fichier docker-compose.yaml pour inclure une variable d'environnement dans le nom de l'image :

version: "3.8"
services:
  web:
    image: nginx:${NGINX_VERSION:-latest}
    ports:
      - "80:80"

Ici, ${NGINX_VERSION:-latest} est une variable qui sera remplacée par la valeur de la variable d'environnement NGINX_VERSION. Si NGINX_VERSION n'est pas définie, elle prendra la valeur par défaut latest.

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

Maintenant, définissons la variable d'environnement NGINX_VERSION puis exécutons docker-compose config pour voir l'interpolation en action.

cd ~/project
export NGINX_VERSION=1.21
docker-compose config

Vous devriez voir la configuration fusionnée, et le nom de l'image pour le service web devrait maintenant être nginx:1.21.

Pour afficher la configuration fusionnée sans interpoler les variables, nous utilisons l'option --no-interpolate avec la commande docker-compose config.

docker-compose --no-interpolate config

Cette fois, la sortie devrait montrer le nom de l'image comme nginx:${NGINX_VERSION:-latest}, avec le placeholder de la variable toujours présent, même si la variable d'environnement NGINX_VERSION est définie.

Cette option est utile lorsque vous souhaitez voir la configuration exacte telle qu'elle est écrite dans vos fichiers Compose, avant toute substitution de variable.

Résumé

Dans ce laboratoire, vous avez appris à utiliser la commande docker-compose config pour inspecter la configuration finale des fichiers Docker Compose. Vous avez commencé par installer Docker Compose dans l'environnement de la machine virtuelle (VM) LabEx, en vous assurant de télécharger le bon binaire pour l'architecture du système et en lui accordant les droits d'exécution. Vous avez ensuite vérifié l'installation en vérifiant la version.

Après l'installation, vous avez créé un simple fichier docker-compose.yaml définissant un service web de base. Vous avez ensuite utilisé la commande docker-compose config pour afficher la configuration finale à partir de ce seul fichier Compose, démontrant ainsi comment visualiser l'état traité de votre définition Compose.