Como usar o comando docker manifest inspect para visualizar manifestos de imagem

Introdução

Neste laboratório, você aprenderá como usar o comando docker manifest inspect para visualizar manifestos de imagens. Começaremos puxando uma imagem Docker de múltiplas arquiteturas, especificamente a imagem alpine, para entender como o Docker lida com imagens em diferentes arquiteturas.

Após o pull da imagem, você usará docker manifest inspect para examinar a lista de manifestos associada à imagem de múltiplas arquiteturas. Em seguida, você se aprofundará, inspecionando um manifesto de imagem específico dentro dessa lista e, finalmente, explorará a opção de saída verbose do comando docker manifest inspect para obter uma compreensão abrangente dos detalhes do manifesto da imagem.

Puxar uma imagem de multi-arquitetura

Nesta etapa, aprenderemos como puxar uma imagem Docker de múltiplas arquiteturas. Uma imagem de múltiplas arquiteturas é uma única tag de imagem que pode ser usada em diferentes arquiteturas (como amd64, arm64, etc.). Quando você puxa uma imagem de múltiplas arquiteturas, o Docker seleciona automaticamente a camada de imagem correta para a arquitetura do seu sistema.

Vamos puxar a imagem alpine, que é uma distribuição Linux leve comumente usada em contêineres Docker. A imagem alpine está disponível como uma imagem de múltiplas arquiteturas.

Para puxar a imagem alpine, abra seu terminal e execute o seguinte comando:

docker pull alpine

Este comando instrui o Docker a baixar a versão mais recente da imagem alpine do Docker Hub. Como alpine é uma imagem de múltiplas arquiteturas, o Docker baixará as camadas de imagem apropriadas para a arquitetura da sua VM LabEx.

Você deve ver uma saída semelhante a esta, indicando que o Docker está puxando a imagem:

Using default tag: latest
latest: Pulling from library/alpine
... (output showing download progress)
Digest: sha256:...
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest

A linha Digest mostra o identificador único para o manifesto de imagem específico que foi puxado para sua arquitetura.

Após a conclusão do comando, a imagem alpine estará disponível em sua VM LabEx e pronta para ser usada para executar contêineres.

Inspecionar a lista de manifestos da imagem de multi-arquitetura

Na etapa anterior, puxamos a imagem alpine. Como alpine é uma imagem de múltiplas arquiteturas, a tag alpine:latest na verdade se refere a uma lista de manifestos (manifest list). Uma lista de manifestos é uma lista de manifestos de imagem, cada um para uma arquitetura diferente. Quando você puxa uma imagem de múltiplas arquiteturas, o Docker usa a lista de manifestos para encontrar o manifesto de imagem correto para o seu sistema.

Para ver a lista de manifestos para a imagem alpine:latest, podemos usar o comando docker manifest inspect. Este comando permite que você visualize os detalhes de um manifesto de imagem ou de uma lista de manifestos.

Execute o seguinte comando em seu terminal:

docker manifest inspect alpine:latest

Este comando produzirá um documento JSON representando a lista de manifestos para a imagem alpine:latest. A saída mostrará uma lista de manifests, cada um correspondendo a uma arquitetura diferente (como amd64, arm64, arm/v7, etc.). Cada manifesto na lista terá detalhes como a platform (arquitetura e sistema operacional) e o digest (um identificador único para o manifesto de imagem daquela arquitetura específica).

Você verá uma saída semelhante a esta (os digests exatos e o número de manifestos podem variar):

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

Esta saída confirma que alpine:latest é de fato uma lista de manifestos contendo manifestos para várias arquiteturas. É assim que o Docker sabe qual imagem específica puxar para o seu sistema quando você usa uma tag de múltiplas arquiteturas.

Inspecionar um manifesto de imagem específico na lista

Na etapa anterior, inspecionamos a lista de manifestos para alpine:latest. Esta lista continha várias entradas, cada uma apontando para um manifesto de imagem específico para uma arquitetura diferente. Agora, vamos inspecionar um desses manifestos de imagem específicos.

Para inspecionar um manifesto específico, precisamos do seu digest. Na saída de docker manifest inspect alpine:latest, encontre o digest para a arquitetura que corresponde à sua VM LabEx (que é amd64). O digest terá uma aparência semelhante a sha256:....

Depois de ter o digest para o manifesto amd64, você pode inspecioná-lo usando o comando docker manifest inspect seguido pelo nome da imagem e o digest, separados por um símbolo @.

Substitua YOUR_AMD64_DIGEST pelo digest real que você encontrou para a plataforma amd64 na saída da etapa anterior.

docker manifest inspect alpine@YOUR_AMD64_DIGEST

Por exemplo, se o digest amd64 fosse sha256:f70734b6a266dcb51c52a820c34f3204cc6897445f6510b7a5be74d30a72f227, o comando seria:

docker manifest inspect alpine@sha256:f70734b6a266dcb51c52a820c34f3204cc6897445f6510b7a5be74d30a72f227

Este comando produzirá um documento JSON que representa o manifesto de imagem específico para a arquitetura amd64. Este manifesto contém detalhes sobre as camadas da imagem (identificadas por seus digests) e a configuração da imagem (também identificada por um digest).

Você verá uma saída semelhante a esta:

{
  "schemaVersion": 2,
  "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
  "config": {
    "mediaType": "application/vnd.docker.container.image.v1+json",
    "size": 1510,
    "digest": "sha256:..."
  },
  "layers": [
    {
      "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
      "size": 2803897,
      "digest": "sha256:..."
    }
  ]
}

Esta saída mostra a estrutura de um único manifesto de imagem, listando a configuração e as camadas que compõem a imagem para aquela arquitetura específica.

Inspecionar o manifesto com saída detalhada

Nas etapas anteriores, inspecionamos a lista de manifestos e um manifesto de imagem específico. A saída padrão de docker manifest inspect fornece um resumo do manifesto ou da lista de manifestos. Para obter informações mais detalhadas, incluindo a configuração completa da imagem, podemos usar a flag --verbose.

Vamos inspecionar a lista de manifestos para alpine:latest novamente, mas desta vez com a flag --verbose. Isso mostrará a lista de manifestos e, para cada manifesto na lista, também mostrará os detalhes completos da configuração.

Execute o seguinte comando em seu terminal:

docker manifest inspect --verbose alpine:latest

Este comando produzirá um documento JSON mais extenso. Para cada entrada na lista manifests, você agora verá um campo adicional chamado Config. Este campo Config contém a configuração completa da imagem para aquela arquitetura específica, incluindo detalhes como o ponto de entrada (entrypoint), comando, variáveis de ambiente, diretório de trabalho (working directory) e muito mais.

Você verá uma saída semelhante a esta (os detalhes exatos na seção Config variarão):

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         },
         "Config": {
            "Env": [
               "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Entrypoint": [
               "/bin/sh"
            ],
            "Cmd": null,
            "WorkingDir": "/",
            ...
         }
      },
      ...
   ]
}

Usar a flag --verbose é útil quando você precisa ver a configuração detalhada das imagens dentro de uma lista de manifestos, o que pode ser útil para depurar ou entender como uma imagem específica é configurada.

Resumo

Neste laboratório, aprendemos como usar o comando docker manifest inspect para visualizar manifestos de imagem. Começamos puxando uma imagem de multi-arquitetura, alpine, entendendo que uma única tag pode representar imagens para diferentes arquiteturas.

Em seguida, usamos docker manifest inspect para visualizar a lista de manifestos associada à imagem de multi-arquitetura, que detalha os manifestos de imagem disponíveis para várias arquiteturas. Finalmente, exploramos como inspecionar um manifesto de imagem específico dentro da lista e como obter informações mais detalhadas usando a opção de saída detalhada (verbose).