Introduction
Dans ce labo (lab), vous apprendrez à utiliser la commande docker buildx history import pour importer l'historique de construction (build history). Nous commencerons par créer un simple Dockerfile qui construit une image basée sur Ubuntu et installe le paquet curl.
Après la création du Dockerfile, vous construirez l'image et exporterez son historique de construction. Enfin, vous importerez cet historique dans Docker Desktop et vérifierez que l'importation a réussi. Cet exercice pratique démontrera l'application concrète de l'importation d'historique de construction pour une meilleure traçabilité et un meilleur débogage de vos constructions Docker.
Créer un Dockerfile exemple
Dans cette étape, nous allons créer un Dockerfile simple. 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.
Nous allons créer un Dockerfile qui construit une image basée sur la dernière image Ubuntu et installe le paquet curl.
Tout d'abord, naviguez vers le répertoire ~/project si vous n'y êtes pas déjà.
cd ~/project
Maintenant, créez un nouveau fichier nommé Dockerfile dans le répertoire ~/project en utilisant l'éditeur nano.
nano Dockerfile
Dans l'éditeur nano, ajoutez le contenu suivant au Dockerfile:
FROM ubuntu:latest
RUN apt-get update && apt-get install -y curl
Analysons les instructions de ce Dockerfile :
FROM ubuntu:latest: Cette instruction spécifie l'image de base pour notre nouvelle image. Nous utilisons la dernière version de l'image officielle Ubuntu de Docker Hub.RUN apt-get update && apt-get install -y curl: Cette instruction exécute des commandes dans une nouvelle couche au-dessus de l'image actuelle et enregistre les résultats. Ici, nous mettons à jour la liste des paquets et installons le paquetcurlen utilisant le gestionnaire de paquetsapt-get. Le drapeau-yrépond automatiquement "oui" à toutes les invites pendant l'installation.
Après avoir ajouté le contenu, enregistrez le fichier et quittez nano en appuyant sur Ctrl + X, puis Y pour confirmer l'enregistrement, et Entrée pour confirmer le nom du fichier.
Vous pouvez vérifier le contenu du Dockerfile en utilisant la commande cat :
cat Dockerfile
Le résultat devrait afficher le contenu que vous venez d'ajouter au fichier.
Construire une image et exporter l'historique de build
Dans cette étape, nous allons construire une image Docker à partir du Dockerfile créé précédemment, puis exporter l'historique de construction de cette image.
Tout d'abord, assurez-vous d'être dans le répertoire ~/project où se trouve votre Dockerfile.
cd ~/project
Maintenant, construisons l'image Docker en utilisant la commande docker build. Nous allons étiqueter l'image avec le nom my-ubuntu-curl et le tag latest. Le . à la fin de la commande indique à Docker de chercher le Dockerfile dans le répertoire courant.
docker build -t my-ubuntu-curl:latest .
Vous verrez une sortie indiquant le processus de construction, incluant le téléchargement de l'image de base et l'exécution de la commande apt-get. Ce processus peut prendre quelques minutes selon votre connexion internet.
Une fois la construction terminée, vous pouvez vérifier que l'image a bien été créée en listant vos images Docker locales :
docker images
Vous devriez voir my-ubuntu-curl dans la liste des images.
Nous allons maintenant exporter l'historique de construction de cette image. L'historique de construction montre les couches qui composent l'image et les commandes utilisées pour créer chaque couche. Nous pouvons exporter cet historique vers un fichier en utilisant la commande docker history et en redirigeant la sortie vers un fichier.
Exportons l'historique vers un fichier nommé build_history.txt dans le répertoire ~/project.
docker history my-ubuntu-curl:latest > build_history.txt
Cette commande prend la sortie de docker history my-ubuntu-curl:latest et l'écrit dans le fichier build_history.txt.
Vous pouvez visualiser le contenu du fichier d'historique exporté en utilisant la commande cat :
cat build_history.txt
La sortie affichera un tableau avec des informations sur chaque couche de l'image, incluant l'ID de la couche, sa date de création, sa taille et la commande utilisée pour la créer.
Importer l'historique de build dans Docker Desktop
Dans cette étape, nous allons simuler l'importation de l'historique de construction exporté précédemment dans Docker Desktop. Bien que nous ne puissions pas interagir directement avec une instance graphique de Docker Desktop dans cet environnement terminal, nous pouvons démontrer le concept et le processus de transfert de fichiers.
Dans un scénario réel, après avoir exporté le fichier build_history.txt depuis votre environnement de construction (comme cette VM LabEx), vous transféreriez typiquement ce fichier vers la machine où Docker Desktop est installé. Les méthodes courantes de transfert incluent l'utilisation de scp, sftp ou des services de stockage cloud.
Pour les besoins de ce lab, nous supposerons que vous avez transféré le fichier build_history.txt vers votre machine locale où Docker Desktop est exécuté.
Une fois le fichier sur votre machine locale, vous ouvririez Docker Desktop. Docker Desktop fournit une interface graphique pour gérer vos images Docker, conteneurs et volumes. Bien qu'il n'existe pas de bouton direct "importer l'historique de construction" dans Docker Desktop qui lirait ce format spécifique de fichier texte, les informations contenues dans build_history.txt sont précieuses pour comprendre comment une image a été construite.
Les développeurs utilisent souvent cet historique de construction pour :
- Comprendre les couches d'une image
- Déboguer des problèmes de construction d'images
- Recréer le processus de construction sur une autre machine
- Documenter le processus de création d'image
Pour simuler "l'importation" et rendre l'historique de construction accessible pour l'étape de vérification suivante, nous nous assurerons simplement que le fichier build_history.txt est présent dans le répertoire ~/project, comme s'il était prêt à être examiné ou utilisé par un outil capable de l'analyser.
Vous pouvez confirmer que le fichier se trouve toujours dans le répertoire ~/project :
ls ~/project/build_history.txt
Si le fichier existe, la commande affichera son chemin. S'il n'existe pas, vous pourriez voir un message d'erreur.
Dans un environnement réel avec Docker Desktop, vous utiliseriez typiquement l'interface graphique pour inspecter les images et leurs couches, ce qui fournit une vue similaire aux informations contenues dans build_history.txt. Certains outils ou scripts avancés pourraient également être utilisés pour analyser et visualiser ces données d'historique.
Comme nous sommes dans un environnement terminal, la présence du fichier build_history.txt à l'emplacement attendu signifie l'achèvement de l'objectif de cette étape dans le contexte du lab.
Vérifier l'historique de build importé
Dans cette dernière étape, nous allons vérifier le contenu du fichier d'historique de construction que nous avons "importé" (en nous assurant de sa présence) à l'étape précédente. Cela simule le processus d'examen de l'historique de construction dans un environnement Docker Desktop ou l'utilisation d'outils pour analyser l'historique exporté.
Nous utiliserons des outils en ligne de commande simples pour vérifier si le fichier build_history.txt contient les informations attendues, en recherchant spécifiquement des preuves de l'image de base ubuntu et de la commande d'installation de curl.
Tout d'abord, assurez-vous d'être dans le répertoire ~/project.
cd ~/project
Maintenant, utilisons la commande grep pour rechercher les informations sur l'image de base dans le fichier build_history.txt. Nous nous attendons à voir une ligne indiquant l'utilisation de l'image ubuntu.
grep "ubuntu" ~/project/build_history.txt
La sortie devrait afficher une ligne contenant "ubuntu", probablement liée à l'instruction initiale FROM ubuntu:latest dans votre Dockerfile.
Ensuite, recherchons la commande qui a installé curl. Nous nous attendons à voir une ligne contenant "apt-get install -y curl".
grep "apt-get install -y curl" ~/project/build_history.txt
La sortie devrait afficher une ligne contenant la commande utilisée pour installer curl.
Ces commandes grep démontrent comment vous pourriez vérifier programmatiquement certains aspects de l'historique de construction. Dans un environnement réel avec Docker Desktop, vous inspecteriez visuellement les couches et leurs commandes associées via l'interface graphique.
Le fait de trouver avec succès ces éléments clés dans le fichier build_history.txt confirme que l'historique de construction a été correctement exporté et est disponible pour inspection, ce qui complète l'objectif de ce lab.
Résumé
Dans ce lab, nous avons appris à utiliser la commande docker buildx history import pour gérer l'historique de construction Docker. Nous avons commencé par créer un simple Dockerfile basé sur Ubuntu et installé le package curl. Cela a démontré le processus fondamental de définition des couches et instructions d'une image.
Après la création du Dockerfile, nous avons procédé à la construction de l'image et exporté son historique de construction. Cette étape est cruciale pour comprendre comment capturer et préserver les informations détaillées sur le processus de construction d'une image. Enfin, nous avons importé cet historique exporté dans Docker Desktop et vérifié que l'historique avait été intégré avec succès, démontrant ainsi l'application pratique de la commande buildx history import pour partager ou migrer des informations de construction.
