Introdução
Neste laboratório, você aprenderá como usar o comando docker buildx history inspect attachment para examinar anexos associados a construções de imagens Docker. Você começará construindo uma imagem Docker e anexando um arquivo a ela usando a flag --attest.
Após a construção, você explorará como listar o histórico de construção para identificar a referência da construção contendo o anexo. Finalmente, você praticará a inspeção do arquivo anexado usando a referência obtida e refinará ainda mais a inspeção, especificando o tipo de anexo e a plataforma. Essa experiência prática demonstrará como acessar e verificar metadados incorporados em suas imagens Docker.
Construir uma imagem com um anexo
Nesta etapa, aprenderemos como construir uma imagem Docker e anexar metadados a ela. Anexos são uma maneira de incluir informações adicionais com sua imagem, como proveniência de construção, lista de materiais de software (SBOM) ou outros dados relevantes.
Primeiro, vamos criar um Dockerfile simples. Navegue para o diretório ~/project se você ainda não estiver lá.
cd ~/project
Agora, crie um arquivo chamado Dockerfile usando o editor nano.
nano Dockerfile
Adicione o seguinte conteúdo ao Dockerfile:
FROM alpine:latest
CMD ["echo", "Hello, Docker Attachments!"]
Este Dockerfile é muito simples. Ele usa a imagem alpine:latest como base e define um comando para imprimir uma mensagem quando o contêiner inicia.
Salve o arquivo e saia do nano (Pressione Ctrl + X, depois Y, depois Enter).
Em seguida, precisamos criar um arquivo que anexaremos à imagem. Vamos criar um arquivo de texto simples chamado attachment.txt.
nano attachment.txt
Adicione algum conteúdo a attachment.txt, por exemplo:
This is an example attachment for the Docker image.
It can contain any relevant metadata.
Salve o arquivo e saia do nano.
Agora, construiremos a imagem Docker e anexaremos o arquivo attachment.txt. Usaremos o comando docker build com a flag --attest. A flag --attest permite que você especifique um anexo para incluir com a construção da imagem. O formato é type=type,dest=destination,src=source.
Em nosso caso, usaremos type=sbom (Lista de Materiais de Software) como o tipo, dest=/sbom/attachment.txt como o caminho de destino dentro do anexo e src=attachment.txt como o arquivo de origem em nosso sistema de arquivos local. Também marcaremos a imagem como my-attached-image:latest.
Antes de construir, certifique-se de ter o plugin buildx necessário instalado. Caso contrário, pode ser necessário instalá-lo. No entanto, para anexos básicos, o construtor integrado deve ser suficiente.
Vamos construir a imagem:
docker build -t my-attached-image:latest --attest type=sbom,dest=/sbom/attachment.txt,src=attachment.txt .
O . no final do comando especifica o contexto de construção, que é o diretório atual (~/project).
Você deve ver a saída indicando que a imagem está sendo construída e o anexo está sendo processado.
Após a conclusão da construção, você pode verificar se a imagem foi criada listando suas imagens locais.
docker images
Você deve ver my-attached-image na lista.
Listar o histórico de construção para encontrar a referência
Na etapa anterior, construímos uma imagem Docker com um anexo. Agora, precisamos encontrar a referência a este anexo para que possamos inspecioná-lo. Anexos estão associados ao histórico de construção, não diretamente com a tag final da imagem.
Podemos usar o comando docker buildx imagetools inspect para visualizar informações sobre a imagem e seus anexos associados. Este comando requer a referência da imagem.
Vamos inspecionar a imagem que construímos, my-attached-image:latest.
docker buildx imagetools inspect my-attached-image:latest
Este comando exibirá informações detalhadas sobre o manifesto da imagem. Procure a seção attestations na saída. Esta seção lista os anexos associados à imagem.
Dentro da seção attestations, você encontrará entradas para cada anexo. Cada entrada terá um campo ref. Esta ref é a referência que precisamos para inspecionar o conteúdo do anexo. Ele terá uma aparência semelhante a sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
Copie o valor do campo ref para o anexo que você adicionou (aquele com type=sbom). Esta é a referência que usaremos na próxima etapa.
Por exemplo, se a saída mostrar:
{
"manifest": {
...
},
"attestations": [
{
"ref": "sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
"type": "sbom",
"platform": {
"architecture": "amd64",
"os": "linux"
}
}
]
}
A referência que você precisa é sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890. Observe que sua referência real será diferente.
Mantenha esta referência à mão para a próxima etapa.
Inspecionar o anexo usando a referência
Na etapa anterior, encontramos a referência para o anexo associado à nossa imagem Docker usando docker buildx imagetools inspect. Agora, usaremos esta referência para inspecionar o conteúdo do anexo.
Podemos usar o comando docker buildx attestation inspect para visualizar os detalhes de um anexo específico usando sua referência.
Recorde a referência que você obteve na etapa anterior. Ela deve estar no formato sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
Substitua <attachment_reference> pela referência real que você copiou.
docker buildx attestation inspect <attachment_reference>
Por exemplo, se sua referência fosse sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890, o comando seria:
docker buildx attestation inspect sha256:abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890
Este comando exibirá o conteúdo do anexo. Você deve ver o texto que adicionou ao arquivo attachment.txt na Etapa 1.
A saída provavelmente incluirá alguns metadados sobre o anexo, seguido pelo conteúdo real. Procure a seção que contém o texto "This is an example attachment...".
Isso demonstra como você pode recuperar o conteúdo de um anexo usando sua referência única. Isso é útil para verificar a integridade e o conteúdo dos dados anexados.
Inspecionar o anexo especificando tipo e plataforma
Na etapa anterior, inspecionamos um anexo usando sua referência direta. No entanto, você também pode inspecionar anexos associados a uma imagem, especificando o tipo de anexo e a plataforma para a qual ele foi construído. Isso é particularmente útil quando uma imagem tem vários anexos de diferentes tipos ou para diferentes arquiteturas.
Usaremos o comando docker buildx attestation inspect novamente, mas desta vez forneceremos a referência da imagem, o tipo de anexo e a plataforma.
A referência da imagem é my-attached-image:latest.
O tipo de anexo que usamos foi sbom.
A plataforma para nossa construção é tipicamente linux/amd64 no ambiente LabEx.
O formato do comando é docker buildx attestation inspect <image_reference> --type <attachment_type> --platform <platform>.
Vamos inspecionar o anexo usando este método:
docker buildx attestation inspect my-attached-image:latest --type sbom --platform linux/amd64
Este comando também deve exibir o conteúdo do anexo, de forma semelhante à etapa anterior. Isso confirma que você pode recuperar as informações do anexo, especificando a imagem, o tipo e a plataforma.
Este método é mais conveniente quando você sabe o tipo de anexo que está procurando e a plataforma da imagem, pois você não precisa primeiro encontrar a referência específica do anexo usando imagetools inspect.
Você agora aprendeu como construir uma imagem Docker com um anexo e como inspecionar esse anexo usando sua referência direta e especificando a imagem, o tipo e a plataforma.
Resumo
Neste laboratório, aprendemos como construir uma imagem Docker com um arquivo anexado usando o comando docker build com a flag --attest, especificando o tipo de anexo, o destino dentro do anexo e o arquivo de origem. Em seguida, exploramos como listar o histórico de construção usando docker buildx history para identificar a referência para a construção contendo o anexo.
Finalmente, praticamos a inspeção do arquivo anexado usando o comando docker buildx history inspect attachment, primeiro fornecendo a referência da construção e o destino do anexo e, subsequentemente, também especificando o tipo de anexo e a plataforma para uma inspeção mais direcionada. Este processo demonstrou como incluir e acessar metadados adicionais associados a uma construção de imagem Docker.
