Comment utiliser la commande docker buildx history open pour visualiser les détails de construction

Introduction

Dans ce lab, vous apprendrez à utiliser la commande docker buildx history open pour visualiser des informations détaillées sur vos builds Docker. Vous commencerez par construire une image Docker simple à l'aide d'un Dockerfile, qui décrit les étapes nécessaires à la création de l'image.

Après la construction de l'image, vous explorerez comment lister l'historique de vos builds. Enfin, vous utiliserez la commande docker buildx history open pour ouvrir et inspecter les détails d'un build spécifique directement dans Docker Desktop, offrant ainsi une vue visuelle et complète du processus de build.

Skills Graph

Construire une image Docker simple

Dans cette étape, vous apprendrez à construire une image Docker simple en utilisant un Dockerfile. Un Dockerfile est un document texte qui contient toutes les commandes qu'un utilisateur pourrait exécuter en ligne de commande pour assembler une image. Docker peut construire des images automatiquement en lisant les instructions d'un Dockerfile.

Commencez par naviguer vers le répertoire ~/project, qui est votre répertoire de travail pour ce lab.

cd ~/project

Maintenant, créons un simple Dockerfile. Nous allons créer un fichier nommé Dockerfile dans le répertoire ~/project.

nano Dockerfile

Dans l'éditeur nano, collez le contenu suivant :

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker!"]

Analysons ce Dockerfile :

• FROM ubuntu:latest : Cette instruction spécifie l'image de base pour notre nouvelle image. Nous commençons avec la dernière version du système d'exploitation Ubuntu.
• RUN apt-get update && apt-get install -y cowsay : Cette instruction exécute des commandes pendant le processus de construction de l'image. Nous mettons à jour la liste des paquets et installons le paquet cowsay, un programme simple qui affiche du texte dans une bulle de parole de vache.
• CMD ["cowsay", "Hello, Docker!"] : Cette instruction fournit la commande par défaut à exécuter lorsqu'un conteneur est démarré à partir de cette image. Dans ce cas, elle exécutera la commande cowsay avec l'argument "Hello, Docker!".

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

Maintenant que nous avons notre Dockerfile, nous pouvons construire l'image Docker. Utilisez la commande docker build. Le drapeau -t permet de taguer l'image avec un nom et éventuellement un tag au format name:tag. Le . à la fin de la commande indique à Docker de chercher le Dockerfile dans le répertoire courant.

docker build -t my-cowsay-image:latest .

Vous verrez une sortie indiquant que Docker construit l'image couche par couche, en exécutant les instructions du Dockerfile. Ce processus peut prendre quelques instants car il télécharge l'image de base et installe le paquet cowsay.

Une fois la construction terminée, vous pouvez vérifier que l'image a bien été créée en listant les images disponibles avec la commande docker images.

docker images

Vous devriez voir my-cowsay-image dans la sortie.

Enfin, lançons un conteneur à partir de l'image que nous venons de construire pour vérifier son fonctionnement.

docker run my-cowsay-image:latest

Vous devriez voir la sortie de la commande cowsay :

 _______
< Hello, Docker! >
 -------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Cela confirme que notre image Docker a été construite correctement et que la commande par défaut s'exécute comme prévu.

Lister l'historique de construction

Dans cette étape, vous apprendrez à visualiser l'historique d'une image Docker, qui montre les couches constituant l'image ainsi que les commandes utilisées pour créer chaque couche. Cela est utile pour comprendre comment une image a été construite et pour le débogage.

Nous utiliserons la commande docker history suivie du nom ou de l'ID de l'image. À l'étape précédente, nous avons construit une image nommée my-cowsay-image. Visualisons son historique.

docker history my-cowsay-image:latest

Le résultat affichera un tableau avec plusieurs colonnes :

• IMAGE : L'ID de la couche d'image
• CREATED : L'horodatage de création de la couche
• CREATED BY : La commande ayant créé la couche
• SIZE : La taille de la couche
• COMMENT : Tout commentaire associé à la couche

Vous verrez des entrées correspondant aux instructions de notre Dockerfile : l'image de base Ubuntu, les commandes apt-get, et l'instruction CMD. Chaque instruction RUN dans un Dockerfile crée une nouvelle couche dans l'image.

Comprendre l'historique vous permet de voir comment chaque instruction de votre Dockerfile contribue à l'image finale. Ceci est particulièrement utile pour optimiser la taille des images ou résoudre des problèmes de construction.

Par exemple, vous pouvez voir la taille ajoutée par chaque commande, ce qui peut aider à identifier des couches volumineuses potentiellement inutiles.

Essayons maintenant de visualiser l'historique de l'image de base ubuntu:latest que nous avons utilisée.

docker history ubuntu:latest

Cela affichera l'historique de l'image officielle Ubuntu, qui est beaucoup plus long et complexe que notre historique d'image simple. Cela démontre comment les images de base sont construites à partir de multiples couches.

La commande docker history fournit des informations précieuses sur la composition de vos images Docker.

Ouvrir une construction spécifique dans Docker Desktop

Dans cette étape, nous allons expliquer comment vous pourriez visualiser les détails d'une construction d'image spécifique en utilisant Docker Desktop. Bien que l'environnement LabEx fournisse une interface en ligne de commande, Docker Desktop est un outil graphique populaire qui offre une manière plus visuelle d'interagir avec Docker.

Remarque : Docker Desktop est une application graphique qui s'exécute sur votre machine locale (Windows, macOS ou Linux avec un environnement de bureau). L'environnement LabEx est une machine virtuelle basée sur le cloud accessible via un navigateur web, qui ne dispose pas d'environnement de bureau graphique pour exécuter Docker Desktop. Par conséquent, vous ne pouvez pas directement "ouvrir une construction spécifique dans Docker Desktop" dans cet environnement LabEx.

Cependant, il est important de comprendre comment cela serait fait dans une configuration de développement typique utilisant Docker Desktop.

Dans Docker Desktop, vous navigueriez vers la section "Images". Ici, vous verriez une liste de toutes les images Docker sur votre système. Vous pouvez trouver l'image que vous avez construite, my-cowsay-image:latest.

En cliquant sur le nom de l'image, vous ouvrirez une vue détaillée de celle-ci. Cette vue comprend généralement :

• Vue d'ensemble : Informations de base sur l'image, telles que sa taille, sa date de création et son ID.
• Couches : Une représentation visuelle des couches de l'image, similaire au résultat de docker history mais souvent avec plus de détails et une interface graphique. Vous pouvez inspecter chaque couche pour voir les commandes qui ont été exécutées et les fichiers qui ont été ajoutés ou modifiés.
• Tags : Une liste des tags associés à l'image.
• Vulnérabilités : Informations sur les vulnérabilités de sécurité connues dans l'image (si l'analyse est activée).

Cette interface graphique dans Docker Desktop facilite l'exploration du contenu et de l'historique d'une image par rapport à la sortie en ligne de commande, en particulier pour les images complexes avec de nombreuses couches.

Bien que vous ne puissiez pas effectuer cette action dans l'environnement LabEx actuel, comprendre cette capacité de Docker Desktop est précieux pour votre parcours d'apprentissage global de Docker.

Pour compléter cette étape dans l'environnement LabEx, nous allons simplement reconnaître le concept.

Résumé

Dans ce labo, vous avez appris à construire une image Docker simple en utilisant un Dockerfile. Vous avez créé un Dockerfile avec des instructions pour utiliser Ubuntu comme image de base, installer le paquet cowsay et définir la commande par défaut pour exécuter cowsay. Vous avez ensuite utilisé la commande docker build pour construire l'image et lui attribuer un tag.

Après la construction de l'image, vous avez exploré comment lister l'historique des constructions en utilisant docker buildx history, puis utilisé la commande docker buildx history open pour visualiser les détails d'une construction spécifique directement dans Docker Desktop, offrant ainsi une interface visuelle pour inspecter le processus de construction et ses artefacts.