Como usar o comando docker buildx imagetools inspect para examinar detalhes da imagem

Introdução

Neste laboratório, você aprenderá como usar o comando docker buildx imagetools inspect para examinar informações detalhadas de imagens Docker. Abordaremos a inspeção de imagens de plataforma única e de múltiplas plataformas, demonstrando como visualizar sua configuração, camadas e metadados.

Você também aprenderá como formatar a saída da inspeção usando templates Go para visualizações personalizadas e como exibir o manifesto JSON bruto de uma imagem para uma compreensão completa de sua estrutura.

Inspecionar uma imagem de plataforma única

Nesta etapa, você aprenderá como inspecionar uma imagem Docker de plataforma única usando o comando docker image inspect. Este comando fornece informações detalhadas sobre uma imagem, incluindo sua configuração, camadas e metadados.

Primeiro, vamos baixar uma imagem simples de plataforma única. Usaremos a imagem hello-world para este exemplo.

docker pull hello-world

Você deve ver uma saída indicando que a imagem está sendo baixada.

Using default tag: latest
latest: Pulling from library/hello-world
...
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest

Agora que temos a imagem, podemos inspecioná-la. Use o comando docker image inspect seguido pelo nome da imagem.

docker image inspect hello-world

Este comando irá gerar um grande objeto JSON contendo vários detalhes sobre a imagem hello-world. Você verá informações como o ID da imagem, data de criação, arquitetura, sistema operacional e configuração.

[
    {
        "Id": "sha256:...",
        "RepoTags": [
            "hello-world:latest"
        ],
        "RepoDigests": [
            "hello-world@sha256:..."
        ],
        "Parent": "",
        "Comment": "",
        "Created": "...",
        "Container": "...",
        "ContainerConfig": {
            ...
        },
        "DockerVersion": "...",
        "Author": "",
        "Config": {
            ...
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": ...,
        "VirtualSize": ...,
        "GraphDriver": {
            ...
        },
        "RootFS": {
            ...
        },
        "Metadata": {
            ...
        }
    }
]

A saída é um array JSON, mesmo que você esteja inspecionando uma única imagem. Isso ocorre porque o comando pode aceitar vários nomes de imagem como argumentos.

Inspecionar uma imagem de múltiplas plataformas

Nesta etapa, você aprenderá como inspecionar uma imagem Docker de múltiplas plataformas. Imagens de múltiplas plataformas são projetadas para rodar em diferentes arquiteturas e sistemas operacionais. Quando você baixa uma imagem de múltiplas plataformas, o Docker seleciona automaticamente a imagem correta para a arquitetura do seu sistema.

Vamos baixar uma imagem de múltiplas plataformas. Usaremos a imagem alpine, que é uma distribuição Linux leve.

docker pull alpine

Você verá uma saída semelhante à etapa anterior, indicando que a imagem está sendo baixada.

Using default tag: latest
latest: Pulling from library/alpine
...
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest

Agora, vamos inspecionar a imagem alpine usando o comando docker image inspect.

docker image inspect alpine

A saída será novamente um objeto JSON. Observe os campos Architecture e Os. Estes refletirão a arquitetura e o sistema operacional da imagem que foi baixada para o seu ambiente específico.

[
    {
        "Id": "sha256:...",
        "RepoTags": [
            "alpine:latest"
        ],
        "RepoDigests": [
            "alpine@sha256:..."
        ],
        "Parent": "",
        "Comment": "",
        "Created": "...",
        "Container": "...",
        "ContainerConfig": {
            ...
        },
        "DockerVersion": "...",
        "Author": "",
        "Config": {
            ...
        },
        "Architecture": "amd64",
        "Os": "linux",
        "Size": ...,
        "VirtualSize": ...,
        "GraphDriver": {
            ...
        },
        "RootFS": {
            ...
        },
        "Metadata": {
            ...
        }
    }
]

Embora o comando inspect mostre os detalhes da imagem específica baixada para sua plataforma, ele não mostra diretamente as informações sobre todas as plataformas que a imagem suporta nesta visualização padrão. Exploraremos como ver mais detalhes sobre o manifesto da imagem em uma etapa posterior.

Formatar a saída usando template Go

Nesta etapa, você aprenderá como formatar a saída do comando docker image inspect usando templates Go. Isso permite que você extraia informações específicas da grande saída JSON e as exiba em um formato mais legível.

O comando docker image inspect suporta a flag --format, que recebe uma string de template Go como argumento. Templates Go permitem que você acesse campos dentro da saída JSON usando notação de ponto.

Vamos inspecionar a imagem alpine novamente, mas desta vez formataremos a saída para mostrar apenas o ID da imagem e a arquitetura.

docker image inspect --format 'ID: {{.Id}}, Architecture: {{.Architecture}}' alpine

Neste comando, {{.Id}} acessa o campo Id e {{.Architecture}} acessa o campo Architecture da saída JSON.

Você deve ver uma saída semelhante a esta, mostrando o ID e a arquitetura da imagem baixada:

ID: sha256:..., Architecture: amd64

Você também pode acessar campos aninhados. Por exemplo, para obter o sistema operacional, que está dentro do objeto principal, você usaria {{.Os}}. Vamos tentar exibir o ID, a arquitetura e o sistema operacional.

docker image inspect --format 'ID: {{.Id}}, Architecture: {{.Architecture}}, OS: {{.Os}}' alpine

A saída agora incluirá o sistema operacional:

ID: sha256:..., Architecture: amd64, OS: linux

Templates Go oferecem recursos mais avançados, como loops e declarações condicionais, mas para a extração simples de campos, a notação de ponto é suficiente. Essa formatação é muito útil quando você precisa criar scripts de operações com base em propriedades específicas da imagem.

Mostrar o manifesto JSON bruto

Nesta etapa, você aprenderá como visualizar o manifesto JSON bruto de uma imagem Docker. O manifesto fornece informações detalhadas sobre a imagem, incluindo as camadas e as configurações para diferentes arquiteturas no caso de uma imagem de múltiplas plataformas.

Para visualizar o manifesto bruto, você pode usar o comando docker manifest inspect. Este comando é particularmente útil para entender imagens de múltiplas plataformas.

Vamos inspecionar o manifesto da imagem alpine que baixamos anteriormente.

docker manifest inspect alpine

Este comando irá gerar um objeto JSON representando o manifesto da imagem. Para uma imagem de múltiplas plataformas como alpine, este manifesto será uma "lista de manifestos" (também conhecida como "índice"). Esta lista contém entradas para cada arquitetura suportada, apontando para o manifesto específico da imagem para essa arquitetura.

Você verá uma saída semelhante a esta (o conteúdo exato pode variar ligeiramente dependendo da versão da imagem e da sua configuração do Docker):

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": ...,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": ...,
         "digest": "sha256:...",
         "platform": {
            "architecture": "arm",
            "os": "linux",
            "variant": "v6"
         }
      },
      ...
   ]
}

Observe o array manifests. Cada objeto neste array representa uma imagem específica para uma plataforma específica (arquitetura e sistema operacional). Você pode ver o campo platform indicando a arquitetura e o sistema operacional para cada entrada. O campo digest é o identificador único para o manifesto daquela imagem de plataforma específica.

Este manifesto bruto fornece uma visão mais profunda de como as imagens de múltiplas plataformas são estruturadas e permite que você veja todas as diferentes variantes disponíveis sob uma única tag.

Resumo

Neste laboratório, você aprendeu como usar o comando docker image inspect para examinar os detalhes das imagens Docker. Você começou inspecionando uma imagem de plataforma única, especificamente a imagem hello-world, e viu como o comando fornece uma saída JSON abrangente contendo informações como ID da imagem, arquitetura, sistema operacional e configuração.

Em seguida, você passou a inspecionar uma imagem de múltiplas plataformas, entendendo que a saída para essas imagens inclui detalhes sobre as diferentes plataformas suportadas. Finalmente, você explorou como formatar a saída usando templates Go para extrair informações específicas e como visualizar o manifesto JSON bruto para uma análise mais aprofundada da estrutura da imagem.