Comment utiliser la commande docker buildx history inspect attachment pour inspecter les pièces jointes de build

Introduction

Dans ce lab, vous apprendrez à utiliser la commande docker buildx history inspect attachment pour examiner les pièces jointes associées aux builds d'images Docker. Vous commencerez par construire une image Docker et y attacher un fichier en utilisant le flag --attest.

Après le build, vous explorerez comment lister l'historique des builds pour identifier la référence du build contenant la pièce jointe. Enfin, vous pratiquerez l'inspection du fichier attaché en utilisant la référence obtenue, et affinerez cette inspection en spécifiant le type de pièce jointe et la plateforme. Cette expérience pratique démontrera comment accéder et vérifier les métadonnées intégrées dans vos images Docker.

Skills Graph

Construire une image avec une pièce jointe

Dans cette étape, nous allons apprendre à construire une image Docker et y attacher des métadonnées. Les pièces jointes permettent d'inclure des informations supplémentaires avec votre image, telles que la provenance du build, la liste des composants logiciels (SBOM - Software Bill of Materials) ou d'autres données pertinentes.

Commencez par créer un Dockerfile simple. Naviguez vers le répertoire ~/project si vous n'y êtes pas déjà.

cd ~/project

Maintenant, créez un fichier nommé Dockerfile en utilisant l'éditeur nano.

nano Dockerfile

Ajoutez le contenu suivant au Dockerfile :

FROM alpine:latest
CMD ["echo", "Hello, Docker Attachments!"]

Ce Dockerfile est très simple. Il utilise l'image alpine:latest comme base et définit une commande pour afficher un message lorsque le conteneur démarre.

Enregistrez le fichier et quittez nano (Appuyez sur Ctrl + X, puis Y, puis Entrée).

Ensuite, nous devons créer un fichier que nous attacherons à l'image. Créons un simple fichier texte nommé attachment.txt.

nano attachment.txt

Ajoutez du contenu à attachment.txt, par exemple :

This is an example attachment for the Docker image.
It can contain any relevant metadata.

Enregistrez le fichier et quittez nano.

Maintenant, nous allons construire l'image Docker et attacher le fichier attachment.txt. Nous utiliserons la commande docker build avec le flag --attest. Le flag --attest permet de spécifier une pièce jointe à inclure avec le build de l'image. Le format est type=type,dest=destination,src=source.

Dans notre cas, nous utiliserons type=sbom (Software Bill of Materials) comme type, dest=/sbom/attachment.txt comme chemin de destination dans la pièce jointe, et src=attachment.txt comme fichier source sur notre système de fichiers local. Nous taguerons également l'image comme my-attached-image:latest.

Avant de construire, assurez-vous d'avoir le plugin buildx nécessaire installé. Si ce n'est pas le cas, vous devrez peut-être l'installer. Cependant, pour les pièces jointes basiques, le builder intégré devrait suffire.

Construisons l'image :

docker build -t my-attached-image:latest --attest type=sbom,dest=/sbom/attachment.txt,src=attachment.txt .

Le . à la fin de la commande spécifie le contexte de build, qui est le répertoire courant (~/project).

Vous devriez voir une sortie indiquant que l'image est en cours de construction et que la pièce jointe est traitée.

Une fois le build terminé, vous pouvez vérifier que l'image a été créée en listant vos images locales.

docker images

Vous devriez voir my-attached-image dans la liste.

Lister l'historique de build pour trouver la référence

Dans l'étape précédente, nous avons construit une image Docker avec une pièce jointe. Maintenant, nous devons trouver la référence de cette pièce jointe pour pouvoir l'inspecter. Les pièces jointes sont associées à l'historique de build, et non directement au tag final de l'image.

Nous pouvons utiliser la commande docker buildx imagetools inspect pour visualiser les informations sur l'image et ses pièces jointes associées. Cette commande nécessite la référence de l'image.

Inspectons l'image que nous avons construite, my-attached-image:latest.

docker buildx imagetools inspect my-attached-image:latest

Cette commande affichera des informations détaillées sur le manifeste de l'image. Recherchez la section attestations dans la sortie. Cette section liste les pièces jointes associées à l'image.

Dans la section attestations, vous trouverez des entrées pour chaque pièce jointe. Chaque entrée possède un champ ref. Ce ref est la référence dont nous avons besoin pour inspecter le contenu de la pièce jointe. Elle ressemblera à quelque chose comme sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.

Copiez la valeur du champ ref pour la pièce jointe que vous avez ajoutée (celle avec type=sbom). C'est la référence que nous utiliserons dans l'étape suivante.

Par exemple, si la sortie affiche :

{
  "manifest": {
    ...
  },
  "attestations": [
    {
      "ref": "sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
      "type": "sbom",
      "platform": {
        "architecture": "amd64",
        "os": "linux"
      }
    }
  ]
}

La référence dont vous avez besoin est sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890. Notez que votre référence réelle sera différente.

Gardez cette référence à portée de main pour l'étape suivante.

Inspecter la pièce jointe en utilisant la référence

Dans l'étape précédente, nous avons trouvé la référence de la pièce jointe associée à notre image Docker en utilisant docker buildx imagetools inspect. Maintenant, nous allons utiliser cette référence pour inspecter le contenu de la pièce jointe.

Nous pouvons utiliser la commande docker buildx attestation inspect pour visualiser les détails d'une pièce jointe spécifique en utilisant sa référence.

Rappelez-vous la référence que vous avez obtenue à l'étape précédente. Elle devrait être au format sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.

Remplacez <attachment_reference> par la référence que vous avez copiée.

docker buildx attestation inspect <attachment_reference>

Par exemple, si votre référence était sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890, la commande serait :

docker buildx attestation inspect sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890

Cette commande affichera le contenu de la pièce jointe. Vous devriez voir le texte que vous avez ajouté au fichier attachment.txt dans l'Étape 1.

La sortie inclura probablement des métadonnées sur la pièce jointe, suivies du contenu réel. Recherchez la section contenant le texte "This is an example attachment...".

Cela démontre comment vous pouvez récupérer le contenu d'une pièce jointe en utilisant sa référence unique. Ceci est utile pour vérifier l'intégrité et le contenu des données attachées.

Inspecter la pièce jointe en spécifiant le type et la plateforme

Dans l'étape précédente, nous avons inspecté une pièce jointe en utilisant sa référence directe. Cependant, vous pouvez également inspecter les pièces jointes associées à une image en spécifiant le type de pièce jointe et la plateforme pour laquelle elle a été construite. Ceci est particulièrement utile lorsqu'une image possède plusieurs pièces jointes de types différents ou pour différentes architectures.

Nous allons à nouveau utiliser la commande docker buildx attestation inspect, mais cette fois en fournissant la référence de l'image, le type de pièce jointe et la plateforme.

La référence de l'image est my-attached-image:latest.
Le type de pièce jointe que nous avons utilisé est sbom.
La plateforme pour notre build est typiquement linux/amd64 dans l'environnement LabEx.

Le format de la commande est docker buildx attestation inspect <image_reference> --type <attachment_type> --platform <platform>.

Inspectons la pièce jointe en utilisant cette méthode :

docker buildx attestation inspect my-attached-image:latest --type sbom --platform linux/amd64

Cette commande devrait également afficher le contenu de la pièce jointe, similairement à l'étape précédente. Cela confirme que vous pouvez récupérer les informations de la pièce jointe en spécifiant l'image, le type et la plateforme.

Cette méthode est plus pratique lorsque vous connaissez le type de pièce jointe recherché et la plateforme de l'image, car vous n'avez pas besoin de trouver d'abord la référence spécifique de la pièce jointe avec imagetools inspect.

Vous avez maintenant appris à construire une image Docker avec une pièce jointe et comment inspecter cette pièce jointe en utilisant soit sa référence directe, soit en spécifiant l'image, le type et la plateforme.

Résumé

Dans ce lab, nous avons appris à construire une image Docker avec un fichier joint en utilisant la commande docker build avec le flag --attest, en spécifiant le type de pièce jointe, sa destination dans l'attestation et le fichier source. Nous avons ensuite exploré comment lister l'historique des builds avec docker buildx history pour identifier la référence du build contenant la pièce jointe.

Enfin, nous avons pratiqué l'inspection du fichier joint en utilisant la commande docker buildx history inspect attachment, d'abord en fournissant la référence du build et la destination de la pièce jointe, puis en spécifiant également le type de pièce jointe et la plateforme pour une inspection plus ciblée. Ce processus a démontré comment inclure et accéder aux métadonnées supplémentaires associées à un build d'image Docker.