Comment utiliser la commande docker compose alpha publish pour publier une application compose

Introduction

Dans ce lab, vous apprendrez à utiliser la commande docker compose alpha publish pour publier une application Docker Compose. Nous commencerons par préparer une application multi-conteneurs simple en utilisant un fichier docker-compose.yaml.

Après cette préparation, vous explorerez différentes méthodes pour publier l'application vers un dépôt (repository), y compris la publication avec des digestes d'images résolus (resolved image digests) et l'inclusion de variables d'environnement dans l'artefact publié. Cette expérience pratique vous guidera à travers le processus d'empaquetage et de partage de vos applications Compose.

Skills Graph

Préparer une application Docker Compose simple

Dans cette étape, nous allons préparer une application Docker Compose simple. Docker Compose est un outil permettant de définir et d'exécuter des applications multi-conteneurs Docker. 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.

Tout d'abord, nous devons installer Docker Compose. Comme il n'est pas préinstallé dans l'environnement LabEx, 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

Après le téléchargement et l'attribution des droits d'exécution, vérifiez l'installation en contrôlant la version.

docker-compose --version

Vous devriez voir une sortie similaire à Docker Compose version v2.20.2.

Maintenant, créons une application Docker Compose simple. Nous allons créer un fichier docker-compose.yaml dans le répertoire ~/project. Ce fichier définira un service unique exécutant un serveur web Nginx.

Utilisez l'éditeur nano pour créer et modifier le fichier.

nano ~/project/docker-compose.yaml

Ajoutez le contenu suivant au fichier docker-compose.yaml:

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

Dans ce fichier docker-compose.yaml :

• version: '3.8' spécifie la version du format de fichier Compose.
• services: définit les services de votre application.
• web: est le nom de notre service.
• 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 de la machine hôte vers le conteneur. "80:80" mappe le port 80 de l'hôte vers le port 80 du conteneur.

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

Avant d'exécuter l'application, nous devons récupérer l'image nginx:latest.

docker pull nginx:latest

Maintenant, nous pouvons démarrer l'application avec la commande docker-compose up. Le flag -d exécute les conteneurs en mode détaché (en arrière-plan).

docker-compose up -d

Vous devriez voir une sortie indiquant que le service est en cours de création et de démarrage.

Pour vérifier que le conteneur est en cours d'exécution, utilisez la commande docker ps.

docker ps

Vous devriez voir une entrée pour le service web avec l'image nginx et un statut Up.

Enfin, vous pouvez tester le serveur Nginx en y accédant. Comme le port 80 du conteneur est mappé au port 80 de l'hôte, vous pouvez utiliser curl pour accéder à localhost.

curl localhost

Vous devriez voir le code HTML de la page d'accueil par défaut de Nginx.

Publier l'application Compose dans un dépôt

Dans cette étape, nous allons apprendre à publier notre application Docker Compose dans un dépôt. La publication d'une application Compose implique généralement le partage du fichier docker-compose.yaml et la garantie que les images Docker requises sont accessibles depuis un registre de conteneurs.

D'abord, arrêtons l'application Docker Compose en cours d'exécution depuis l'étape précédente. Naviguez vers le répertoire ~/project si vous n'y êtes pas déjà.

cd ~/project

Maintenant, stoppez les services en cours d'exécution avec la commande docker-compose down. Cette commande arrête et supprime les conteneurs, réseaux et volumes créés par up.

docker-compose down

Vous devriez voir une sortie indiquant que les services sont en cours d'arrêt et de suppression.

Pour publier l'application Compose, nous devons partager le fichier docker-compose.yaml. Dans un scénario réel, vous stockeriez généralement ce fichier dans un système de contrôle de version comme Git et le pousseriez vers un dépôt (par exemple GitHub, GitLab, Bitbucket).

Pour ce lab, nous simulerons la publication en créant un simple fichier texte contenant le contenu de notre fichier docker-compose.yaml. Cela démontre l'idée principale du partage de configuration.

Créons un fichier nommé compose_app.txt dans le répertoire ~/project et copions-y le contenu de docker-compose.yaml.

cat ~/project/docker-compose.yaml > ~/project/compose_app.txt

Maintenant, vous pouvez visualiser le contenu du nouveau fichier pour confirmer qu'il est identique à docker-compose.yaml.

cat ~/project/compose_app.txt

Vous devriez voir le contenu YAML de votre fichier Compose.

Dans un scénario réel de publication, vous devriez également vous assurer que les images Docker référencées dans votre fichier docker-compose.yaml sont disponibles dans un registre de conteneurs accessible par d'autres. Dans notre cas, l'image nginx:latest est publiquement disponible sur Docker Hub, donc aucune étape supplémentaire n'est nécessaire pour cette image spécifique. Si vous utilisiez des images personnalisées, vous devriez les construire et les pousser vers un registre.

Par exemple, si vous aviez une image personnalisée nommée my-custom-app, vous la construiriez avec docker build puis la pousseriez vers un registre comme Docker Hub avec docker push votre-nom-dockerhub/my-custom-app.

Pour simuler le partage du fichier Compose, imaginez que vous partagez le fichier compose_app.txt avec quelqu'un. Cette personne pourrait alors télécharger ce fichier et l'utiliser pour exécuter l'application sur sa propre machine, à condition qu'elle ait Docker et Docker Compose installés et puisse accéder aux images requises.

Pour démontrer cela, supprimons le fichier original docker-compose.yaml puis recréons-le à partir de compose_app.txt.

rm ~/project/docker-compose.yaml
cat ~/project/compose_app.txt > ~/project/docker-compose.yaml

Maintenant, vous pouvez vérifier que le fichier docker-compose.yaml a été recréé.

cat ~/project/docker-compose.yaml

Vous devriez voir le même contenu YAML qu'auparavant.

Cette étape s'est concentrée sur le concept de partage du fichier Compose. Dans les prochaines étapes, nous explorerons des aspects plus avancés de la publication, comme l'utilisation de digestes d'images et la gestion des variables d'environnement.

Publier l'application Compose avec des digestes d'image résolus

Dans cette étape, nous allons apprendre à publier une application Compose en utilisant des digestes d'image résolus. L'utilisation de digestes d'image plutôt que de tags (comme latest) offre une méthode plus fiable pour garantir que vous utilisez toujours exactement la même version d'image. Les tags peuvent être mis à jour pour pointer vers une nouvelle image, tandis qu'un digeste identifie de manière unique une couche d'image spécifique.

D'abord, récupérons le digeste de l'image nginx:latest que nous avons utilisée dans les étapes précédentes. Nous pouvons utiliser la commande docker inspect pour obtenir des informations détaillées sur l'image.

docker inspect nginx:latest --format='{{.RepoDigests}}'

Cette commande affichera les digestes du dépôt pour l'image nginx:latest. Le résultat ressemblera à [nginx@sha256:...]. La partie après @ est le digeste de l'image. Copiez ce digeste.

Maintenant, nous allons modifier notre fichier docker-compose.yaml pour utiliser le digeste d'image au lieu du tag. Ouvrez le fichier docker-compose.yaml dans le répertoire ~/project avec nano.

nano ~/project/docker-compose.yaml

Modifiez la ligne image de image: nginx:latest en image: nginx@<votre_digeste_image>, en remplaçant <votre_digeste_image> par le digeste que vous avez copié. Par exemple, si votre digeste était sha256:abcdef123456..., la ligne deviendrait image: nginx@sha256:abcdef123456....

version: "3.8"
services:
  web:
    image: nginx@sha256:votre_digeste_image_ici
    ports:
      - "80:80"

Enregistrez le fichier avec Ctrl + S et quittez l'éditeur avec Ctrl + X.

Désormais, lorsque vous partagerez ce fichier docker-compose.yaml, toute personne l'utilisant récupérera exactement l'image identifiée par le digeste, indépendamment de ce vers quoi le tag latest pourrait pointer actuellement.

Pour démontrer que Compose utilise bien le digeste, relançons l'application avec le fichier docker-compose.yaml modifié.

docker-compose up -d

Compose utilisera l'image spécifiée par le digeste. Si l'image n'est pas déjà présente sur le système, elle sera téléchargée.

Vous pouvez vérifier que le conteneur fonctionne et utilise bien l'image spécifiée par le digeste en inspectant le conteneur en cours d'exécution. D'abord, trouvez l'ID du conteneur avec docker ps.

docker ps

Recherchez le conteneur exécutant l'image nginx et notez son ID. Puis, utilisez docker inspect avec l'ID du conteneur et formatez la sortie pour afficher le digeste de l'image.

docker inspect < container_id > --format='{{.Image}}'

Remplacez <container_id> par l'ID réel de votre conteneur Nginx en cours d'exécution. Le résultat devrait correspondre au digeste d'image que vous avez spécifié dans le fichier docker-compose.yaml.

L'utilisation de digestes d'image dans vos fichiers Compose est une bonne pratique pour garantir la reproductibilité et éviter les modifications inattendues de votre application dues aux mises à jour d'images.

Publier l'application Compose avec variables d'environnement

Dans cette étape, nous allons apprendre à intégrer des variables d'environnement dans notre application Docker Compose et comment cela affecte la publication. Les variables d'environnement sont une méthode courante pour configurer des applications, et Docker Compose offre plusieurs moyens de les gérer.

D'abord, arrêtons le conteneur Nginx en cours d'exécution depuis l'étape précédente. Naviguez vers le répertoire ~/project si vous n'y êtes pas déjà.

cd ~/project

Arrêtez les services en cours d'exécution avec la commande docker-compose down.

docker-compose down

Maintenant, modifions notre fichier docker-compose.yaml pour utiliser une variable d'environnement. Nous allons ajouter une simple variable d'environnement au service web. Ouvrez le fichier docker-compose.yaml dans le répertoire ~/project avec nano.

nano ~/project/docker-compose.yaml

Ajoutez une section environment à la définition du service web. Nous ajouterons une variable nommée MY_VARIABLE avec une valeur.

version: "3.8"
services:
  web:
    image: nginx@sha256:your_image_digest_here ## Remplacez par votre vrai digeste
    ports:
      - "80:80"
    environment:
      - MY_VARIABLE=HelloFromCompose

N'oubliez pas de remplacer your_image_digest_here par le véritable digeste d'image obtenu à l'étape précédente.

Enregistrez le fichier avec Ctrl + S et quittez l'éditeur avec Ctrl + X.

Désormais, lorsque vous démarrez l'application avec docker-compose up, la variable d'environnement MY_VARIABLE sera définie dans le conteneur Nginx.

docker-compose up -d

Pour vérifier que la variable d'environnement est bien définie dans le conteneur, nous pouvons exécuter une commande à l'intérieur du conteneur en cours d'exécution avec docker exec. D'abord, trouvez l'ID du conteneur avec docker ps.

docker ps

Notez l'ID du conteneur Nginx en cours d'exécution. Puis, utilisez docker exec pour exécuter la commande printenv dans le conteneur et filtrer le résultat pour MY_VARIABLE.

docker exec < container_id > printenv | grep MY_VARIABLE

Remplacez <container_id> par l'ID réel de votre conteneur Nginx en cours d'exécution. Vous devriez voir un résultat similaire à MY_VARIABLE=HelloFromCompose.

Lors de la publication d'une application Compose utilisant des variables d'environnement, vous devez considérer comment ces variables seront fournies dans l'environnement cible.

Une approche courante consiste à utiliser un fichier .env. Docker Compose recherche automatiquement un fichier nommé .env dans le répertoire où se trouve le fichier docker-compose.yaml. Vous pouvez définir des variables d'environnement dans ce fichier, et Compose les chargera.

Créons un fichier .env dans le répertoire ~/project.

nano ~/project/.env

Ajoutez le contenu suivant au fichier .env:

ANOTHER_VARIABLE=ThisIsFromDotEnv

Enregistrez le fichier et quittez nano.

Maintenant, modifions le fichier docker-compose.yaml pour utiliser cette nouvelle variable d'environnement. Ouvrez à nouveau le fichier docker-compose.yaml.

nano ~/project/docker-compose.yaml

Ajoutez ANOTHER_VARIABLE à la section environment.

version: "3.8"
services:
  web:
    image: nginx@sha256:your_image_digest_here ## Remplacez par votre vrai digeste
    ports:
      - "80:80"
    environment:
      - MY_VARIABLE=HelloFromCompose
      - ANOTHER_VARIABLE

Notez que pour ANOTHER_VARIABLE, nous avons simplement listé le nom de la variable. Compose cherchera cette variable dans l'environnement où docker-compose up est exécuté, y compris les variables chargées depuis le fichier .env.

Enregistrez le fichier et quittez nano.

Maintenant, arrêtez et redémarrez l'application Compose pour prendre en compte les modifications.

docker-compose down
docker-compose up -d

Obtenez le nouvel ID de conteneur avec docker ps.

docker ps

Maintenant, utilisez docker exec pour vérifier les deux variables d'environnement dans le conteneur.

docker exec < container_id > printenv | grep MY_VARIABLE
docker exec < container_id > printenv | grep ANOTHER_VARIABLE

Remplacez <container_id> par le nouvel ID de conteneur. Vous devriez voir à la fois MY_VARIABLE=HelloFromCompose et ANOTHER_VARIABLE=ThisIsFromDotEnv dans le résultat.

Lors de la publication, vous partageriez typiquement le fichier docker-compose.yaml et fourniriez des instructions sur comment définir les variables d'environnement nécessaires, soit via un fichier .env, soit en les définissant directement dans l'environnement où Compose est exécuté. Les informations sensibles ne devraient pas être codées en dur dans les fichiers docker-compose.yaml ou .env et devraient être gérées avec des solutions de gestion de secrets.

Résumé

Dans ce lab, nous avons appris à préparer une application simple avec Docker Compose. Cela a impliqué l'installation de Docker Compose, la vérification de son installation, et la création d'un fichier docker-compose.yaml pour définir un service web Nginx basique. Nous avons également téléchargé l'image Docker nécessaire (nginx:latest) en préparation de l'exécution de l'application.

Les étapes suivantes, qui n'étaient pas entièrement détaillées dans le contenu fourni, couvriraient probablement la publication de cette application Compose vers un dépôt en utilisant la commande docker compose alpha publish. Cela inclurait l'exploration d'options comme la publication avec des digestes d'image résolus et l'inclusion de variables d'environnement dans la définition de l'application publiée.