Como usar o comando docker image inspect para visualizar detalhes da imagem

Introdução

Neste laboratório, você aprenderá como usar o comando docker image inspect para visualizar informações detalhadas sobre uma imagem Docker. Você começará puxando uma imagem de exemplo. Em seguida, explorará como inspecionar a imagem usando o formato de saída padrão, o formato JSON e um template Go personalizado para extrair detalhes específicos. Essa experiência prática o equipará com as habilidades para examinar efetivamente as características e a configuração de suas imagens Docker.

Puxar uma imagem de exemplo

Nesta etapa, você aprenderá como puxar uma imagem Docker de um registro (registry). As imagens Docker são os blocos de construção dos contêineres. Elas são templates somente leitura que contêm o código da aplicação, bibliotecas, dependências e arquivos de configuração necessários para executar uma aplicação.

Para puxar uma imagem, você usa o comando docker pull seguido pelo nome da imagem. Se você não especificar uma tag, o Docker puxará a tag latest por padrão.

Vamos puxar a imagem hello-world, que é uma imagem muito pequena usada para testar se o Docker está instalado corretamente.

docker pull hello-world

Você deve ver uma saída semelhante a esta, indicando que a imagem está sendo baixada:

Using default tag: latest
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest

Esta saída mostra que o Docker está puxando a tag latest da imagem hello-world do registro Docker Hub (que é o registro padrão). As linhas com Pull complete indicam que as diferentes camadas (layers) da imagem foram baixadas.

Inspecionar a imagem com o formato padrão

Nesta etapa, você aprenderá como inspecionar uma imagem Docker para visualizar informações detalhadas sobre ela. O comando docker inspect fornece uma grande quantidade de informações sobre objetos Docker, incluindo imagens, contêineres, redes e volumes. Por padrão, ele gera a informação em um formato estruturado.

Para inspecionar uma imagem, você usa o comando docker inspect seguido pelo nome ou ID da imagem. Vamos inspecionar a imagem hello-world que você puxou na etapa anterior.

docker inspect hello-world

Este comando gerará uma grande quantidade de informações sobre a imagem hello-world em um formato padrão. A saída inclui detalhes como o ID da imagem, data de criação, arquitetura, sistema operacional e configuração.

[
  {
    "Id": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
    "RepoTags": ["hello-world:latest"],
    "RepoDigests": [
      "hello-world@sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591"
    ],
    "Parent": "",
    "Comment": "",
    "Created": "2023-03-07T21:50:09.004511104Z",
    "Container": "a928b81f51a91111111111111111111111111111111111111111111111111111",
    "ContainerConfig": {
      "Hostname": "a928b81f51a9",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": {}
    },
    "DockerVersion": "20.10.21",
    "Author": "",
    "Config": {
      "Hostname": "",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": null
    },
    "Architecture": "amd64",
    "Os": "linux",
    "Size": 1330,
    "VirtualSize": 1330,
    "GraphDriver": {
      "Data": null,
      "Name": "overlay2"
    },
    "RootFS": {
      "Type": "layers",
      "Layers": [
        "sha256:2db29710123e5455b34e722505b562504b39e55355e344405b54d3153a94650b"
      ]
    },
    "Metadata": {
      "LastTagTime": "0001-01-01T00:00:00Z"
    }
  }
]

Esta saída padrão fornece uma visão abrangente da configuração e metadados da imagem. Nas próximas etapas, você aprenderá como formatar esta saída para extrair informações específicas.

Inspecionar a imagem com formato JSON

Na etapa anterior, você inspecionou a imagem hello-world e viu o formato de saída padrão. Embora este formato seja informativo, pode ser difícil de analisar programaticamente. O comando inspect do Docker permite que você especifique o formato de saída usando a flag --format. Um formato comum e útil é o JSON.

Para inspecionar uma imagem e obter a saída em formato JSON, você usa a flag --format json com o comando docker inspect.

Vamos inspecionar a imagem hello-world novamente, mas desta vez, formataremos a saída como JSON.

docker inspect --format json hello-world

Este comando gerará as mesmas informações de antes, mas será formatado como um array JSON contendo um único objeto JSON.

[
  {
    "Id": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
    "RepoTags": ["hello-world:latest"],
    "RepoDigests": [
      "hello-world@sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591"
    ],
    "Parent": "",
    "Comment": "",
    "Created": "2023-03-07T21:50:09.004511104Z",
    "Container": "a928b81f51a91111111111111111111111111111111111111111111111111111",
    "ContainerConfig": {
      "Hostname": "a928b81f51a9",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": {}
    },
    "DockerVersion": "20.10.21",
    "Author": "",
    "Config": {
      "Hostname": "",
      "Domainname": "",
      "User": "",
      "AttachStdin": false,
      "AttachStdout": false,
      "AttachStderr": false,
      "Tty": false,
      "OpenStdin": false,
      "StdinOnce": false,
      "Env": [
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
      ],
      "Cmd": ["/hello"],
      "Image": "sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591",
      "Volumes": null,
      "WorkingDir": "",
      "Entrypoint": null,
      "OnBuild": null,
      "Labels": null
    },
    "Architecture": "amd64",
    "Os": "linux",
    "Size": 1330,
    "VirtualSize": 1330,
    "GraphDriver": {
      "Data": null,
      "Name": "overlay2"
    },
    "RootFS": {
      "Type": "layers",
      "Layers": [
        "sha256:2db29710123e5455b34e722505b562504b39e55355e344405b54d3153a94650b"
      ]
    },
    "Metadata": {
      "LastTagTime": "0001-01-01T00:00:00Z"
    }
  }
]

O formato JSON é particularmente útil quando você deseja processar a saída com outras ferramentas ou scripts.

Inspecionar a imagem com um template Go personalizado

Além dos formatos padrão e JSON, o comando docker inspect permite que você use um template Go para formatar a saída. Isso é muito poderoso, pois permite que você extraia campos específicos e formate a saída exatamente como você precisa.

A flag --format aceita uma string de template Go. Você pode acessar os campos do objeto inspecionado usando a notação de ponto. Por exemplo, para acessar o ID da imagem, você usaria .Id. Para acessar campos aninhados, você pode encadear os pontos, como .Config.Cmd para obter o comando que o container executará.

Vamos inspecionar a imagem hello-world e extrair o ID da imagem e o comando que o container executará.

docker inspect --format 'ID: {{.Id}} Command: {{.Config.Cmd}}' hello-world

Neste comando, estamos usando uma string de template Go 'ID: {{.Id}} Command: {{.Config.Cmd}}'.

• {{.Id}} acessa o campo Id do objeto imagem.
• {{.Config.Cmd}} acessa o campo Cmd dentro do objeto Config.

A saída será formatada de acordo com o template:

ID: sha256:f5233545e4356188889db81cd1e163ee0d68e4b9b2863974888a98019dbf8591 Command: [/hello]

Você pode usar templates Go para extrair qualquer informação disponível na saída padrão do docker inspect. Isso é muito útil para scripting e automatização de tarefas.

Resumo

Neste laboratório, você aprendeu como usar o comando docker pull para baixar uma imagem Docker de um registro (registry), especificamente puxando a imagem hello-world como exemplo. Em seguida, você explorou o comando docker inspect para visualizar informações detalhadas sobre a imagem baixada.

Você praticou a inspeção da imagem usando o formato de saída padrão, que fornece uma visão geral abrangente das características da imagem. Os passos subsequentes, embora não totalmente detalhados no conteúdo fornecido, provavelmente envolveriam a exploração de como formatar a saída do docker inspect usando JSON e templates Go personalizados para extrair informações específicas, demonstrando a flexibilidade do comando para analisar detalhes da imagem.