Esta página foi traduzida pela API Cloud Translation.

Acerca dos resumos de imagens de contentores

Autopilot Padrão

Esta página descreve os resumos de imagens, incluindo o que são, como os encontrar e como impor a respetiva utilização em clusters do Kubernetes. Esta página destina-se a programadores e operadores que criam e implementam imagens de contentores.

Um resumo da imagem de contentor identifica de forma exclusiva e imutável uma imagem de contentor. Quando implementa imagens por digest, evita as desvantagens da implementação por etiquetas de imagens.

Os comandos nesta página pressupõem que tem acesso a um ambiente de shell do Linux ou macOS com ferramentas como a CLI Google Cloud, o Docker, o cURL, jq e o pack já instalados. Em alternativa, pode usar o Cloud Shell, que tem estas ferramentas pré-instaladas.

Imagens de contentores e etiquetas de imagens

Quando trabalha com imagens de contentores, precisa de uma forma de fazer referência às imagens que usa. As etiquetas de imagens são uma forma comum de se referir a diferentes revisões de uma imagem. Uma abordagem comum é etiquetar as imagens com um identificador de versão no momento da criação. Por exemplo, v1.0.1 pode referir-se a uma versão que denomina 1.0.1.

As etiquetas facilitam a procura de revisões de imagens através de strings legíveis. No entanto, as etiquetas são referências mutáveis, o que significa que a imagem referenciada por uma etiqueta pode mudar, conforme ilustrado no diagrama seguinte:

Etiqueta de imagem que aponta para uma imagem desatualizada.

Conforme mostra o diagrama anterior, se publicar uma nova imagem com a mesma etiqueta de uma imagem existente, a etiqueta deixa de apontar para a imagem existente e começa a apontar para a nova imagem.

Desvantagens das etiquetas de imagens

Como as etiquetas são mutáveis, têm as seguintes desvantagens quando as usa para implementar uma imagem:

No Kubernetes, a implementação por etiqueta pode resultar em resultados inesperados. Por exemplo, suponha que tem um recurso de implementação existente que faz referência a uma imagem de contentor por etiqueta v1.0.1. Para corrigir um erro ou fazer uma pequena alteração, o processo de compilação cria uma nova imagem com a mesma etiqueta v1.0.1. Os novos pods criados a partir do recurso de implementação podem acabar por usar a imagem antiga ou a nova, mesmo que não altere a especificação do recurso de implementação. Este problema também se aplica a outros recursos do Kubernetes, como StatefulSets, DaemonSets, ReplicaSets e Jobs.
Se usar ferramentas para analisar ou analisar imagens, os resultados destas ferramentas só são válidos para a imagem que foi analisada. Para garantir que implementa a imagem que foi analisada, não pode confiar na etiqueta, porque a imagem referida pela etiqueta pode ter sido alterada.
Se usar a autorização binária com o Google Kubernetes Engine (GKE), a implementação baseada em etiquetas não é permitida porque é impossível determinar a imagem exata que é usada quando um pod é criado.

Quando implementa as suas imagens, pode usar um resumo de imagem para evitar as desvantagens da utilização de etiquetas. Se quiser, pode continuar a adicionar etiquetas às suas imagens, mas não tem de o fazer.

Estrutura de uma imagem

Uma imagem é composta pelos seguintes componentes:

Um manifesto de imagens
Um objeto de configuração
Uma matriz de uma ou mais camadas do sistema de ficheiros
Um índice de imagens opcional

Estes componentes estão ilustrados no diagrama seguinte:

Componentes de uma imagem que mostra detalhes de um manifesto de imagem, um objeto de configuração, camadas do sistema de ficheiros e um índice de imagens.

A imagem anterior mostra detalhes adicionais sobre os componentes de imagem:

O manifesto de imagem é um documento JSON que contém uma referência ao objeto de configuração, às camadas do sistema de ficheiros e aos metadados opcionais.
O manifesto de imagem faz referência ao objeto de configuração e a cada uma das camadas do sistema de ficheiros através dos respetivos atributos digest. O valor de um atributo digest é um hash criptográfico do conteúdo a que o resumo se refere, normalmente calculado através do algoritmo SHA-256.
Os valores de resumo são usados para construir endereços imutáveis para os objetos. Este processo chama-se armazenamento endereçável por conteúdo, e significa que pode obter manifestos de imagens, índices de imagens, objetos de configuração e camadas com base nos respetivos resumos.
O resumo da imagem é o hash do índice da imagem ou do documento JSON do manifesto da imagem.
O objeto de configuração é um documento JSON que define as propriedades da imagem, como a arquitetura da CPU, o ponto de entrada, as portas expostas e as variáveis de ambiente.
A matriz da camada do sistema de ficheiros define a ordem que o tempo de execução do contentor usa para sobrepor as camadas. As camadas são distribuídas como ficheiros TAR, normalmente comprimidos através do utilitário gzip.
O índice de imagens opcional, por vezes denominado lista de manifestos, refere-se a um ou mais manifestos de imagens. A referência é o resumo do manifesto da imagem. Um índice de imagens é útil quando produz várias imagens relacionadas para diferentes plataformas, como as arquiteturas amd64 e arm64.

Para mais informações, consulte a secção Explorar manifestos, resumos e etiquetas de imagens.

Encontrar resumos de imagens

Para usar resumos de imagens para a implementação, tem de encontrar primeiro o resumo. Em seguida, pode usar o resumo com o comando de implementação ou incluí-lo nos manifestos do Kubernetes.

Pode obter o resumo de uma imagem de várias formas, consoante a sua situação atual. As secções seguintes contêm exemplos para diferentes produtos e ferramentas.

Nas secções seguintes, execute os comandos no Cloud Shell ou num ambiente de shell com ferramentas como a CLI gcloud, o Docker, o cURL e o jq já instalados.

Artifact Registry

Para imagens armazenadas no Artifact Registry, pode usar o comando gcloud artifacts docker images describe.
```
gcloud artifacts docker images describe \
    LOCATION-docker.pkg.dev/PROJECT/REPOSITORY/IMAGE:TAG \
    --format 'value(image_summary.digest)'
```
Substitua o seguinte:
- LOCATION: a localização regional ou multirregional do seu repositório
- PROJECT: o seu Google Cloud ID do projeto
- REPOSITORY: o nome do seu repositório
- IMAGE: o nome da imagem
- TAG: a sua etiqueta de imagem

Container Registry

Para imagens armazenadas no Container Registry, pode usar o comando gcloud container images describe para obter o resumo de uma imagem, indicando o nome e uma etiqueta. Use a --format flag para apresentar apenas o resumo:
```
gcloud container images describe \
    gcr.io/google-containers/pause-amd64:3.2 \
    --format 'value(image_summary.digest)'
```
A saída tem um aspeto semelhante ao seguinte, embora o valor de resumo possa ser diferente:
```
sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108
```

Cloud Build

Para imagens criadas com o Cloud Build, pode obter o resumo da imagem através do comando gcloud builds describe com a flag --format. Esta abordagem funciona independentemente do registo que usou para publicar a sua imagem.

Para uma compilação já concluída, faça o seguinte:
1. Obtenha uma lista de compilações para o seu projeto:
```
gcloud builds list
```
  Toma nota de um BUILD_ID.
2. Aceda ao resumo de imagens:
```
gcloud builds describe BUILD_ID \
    --format 'value(results.images[0].digest)'
```
  Substitua BUILD_ID pelo ID exclusivo que o Cloud Build atribuiu à sua compilação.

Obtenha o nome e o resumo da imagem para a compilação mais recente do Cloud Build para o seu projeto atual:

gcloud builds describe \
    $(gcloud builds list --limit 1 --format 'value(id)') \
    --format 'value[separator="@"](results.images[0].name,results.images[0].digest)'

Se a sua compilação tiver produzido várias imagens, filtre o resultado e obtenha o resumo de uma das imagens:
```
gcloud builds describe BUILD_ID --format json \
    | jq -r '.results.images[] | select(.name=="YOUR_IMAGE_NAME") | .digest'
```
Substitua YOUR_IMAGE_NAME pelo nome de uma das imagens do ficheiro cloudbuild.yaml.
Se enviar uma compilação para o Cloud Build através do comando gcloud builds submit, pode capturar o resumo da imagem a partir do resultado numa variável de ambiente:
```
IMAGE_DIGEST=$(gcloud builds submit \
    --format 'value(results.images[0].digest)' | tail -n1)
```

Cloud Native Buildpacks

Se usar os Cloud Native Buildpacks e o criador para criar e publicar imagens, pode capturar o nome e o resumo da imagem através do sinalizador --quiet com o comando pack: Google Cloud
```
pack build --builder gcr.io/buildpacks/builder:v1 --publish --quiet \
    LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE \
    > image-with-digest.txt
```
Substitua o seguinte:
- LOCATION: a localização regional ou multirregional do seu repositório
- PROJECT_ID: o seu Google Cloud ID do projeto
- REPOSITORY: o nome do seu repositório
- IMAGE: o nome da imagem
O ficheiro image-with-digest.txt contém o nome e o resumo da imagem.

Use a flag --tag se quiser adicionar etiquetas à imagem.

Cliente Docker

O subcomando manifest do cliente de linha de comandos pode obter manifestos de imagens e listas de manifestos de registos de imagens de contentores.docker

Obtenha o resumo da lista de manifestos da imagem registry.k8s.io/pause:3.9, para a arquitetura de CPU amd64 e o sistema operativo linux:

docker manifest inspect --verbose registry.k8s.io/pause:3.9 | \
    jq -r 'if type=="object"
        then .Descriptor.digest
        else .[] | select(.Descriptor.platform.architecture=="amd64" and
        .Descriptor.platform.os=="linux") | .Descriptor.digest
        end'

O resultado tem um aspeto semelhante ao seguinte:

sha256:8d4106c88ec0bd28001e34c975d65175d994072d65341f62a8ab0754b0fafe10

Para imagens armazenadas no daemon do Docker local e que foram extraídas ou enviadas para um registo de imagens, pode usar a ferramenta de linha de comandos do Docker para obter o resumo da imagem:
1. Extraia a imagem para o seu daemon do Docker local:
```
docker pull docker.io/library/debian:bookworm
```
2. Aceda ao resumo de imagens:
```
docker inspect docker.io/library/debian:bookworm \
    | jq -r '.[0].RepoDigests[0]' \
    | cut -d'@' -f2
```
  A saída tem um aspeto semelhante ao seguinte, embora o valor de resumo possa ser diferente:
```
sha256:3d868b5eb908155f3784317b3dda2941df87bbbbaa4608f84881de66d9bb297b
```
Liste todas as imagens e resumos no seu daemon Docker local:
```
docker images --digests
```
O resultado mostra resumos de imagens que têm um valor de resumo. As imagens só têm um valor de resumo se tiverem sido extraídas ou enviadas para um registo de imagens.

`crane` e `gcrane`

Pode usar as ferramentas de linha de comandos de código aberto crane e gcrane para obter o resumo de uma imagem sem transferir a imagem para um daemon Docker local.

Transfira crane e gcrane para o seu diretório atual:

VERSION=$(curl -sL https://api.github.com/repos/google/go-containerregistry/releases/latest | jq -r .tag_name)
curl -L "https://github.com/google/go-containerregistry/releases/download/${VERSION}/go-containerregistry_$(uname -s)_$(uname -m).tar.gz" | tar -zxf - crane gcrane

Receber resumos de imagens:
```
./gcrane digest gcr.io/distroless/static-debian11:nonroot
```
crane e gcrane têm outras funcionalidades que estão fora do âmbito desta página. Para mais informações, consulte a documentação para crane e gcrane.

Impor a utilização de resumos de imagens em implementações do Kubernetes

Se quiser aplicar a utilização de resumos para imagens que implementa nos seus clusters do Kubernetes, pode usar o Policy Controller ou o Open Policy Agent (OPA) Gatekeeper. O Policy Controller é criado a partir do projeto de código aberto OPA Gatekeeper.

O Policy Controller e o OPA Gatekeeper baseiam-se no motor de políticas OPA. O Policy Controller e o OPA Gatekeeper fornecem um webhook de admissão de validação do Kubernetes para aplicar políticas e definições de recursos personalizados (CRDs) para modelos de restrições e restrições.

Os modelos de restrições contêm lógica de políticas expressa através de uma linguagem declarativa de alto nível denominada Rego. Segue-se um modelo de restrição que valida se os contentores, contentores de inicialização, e contentores efémeros numa especificação de recursos do Kubernetes usam imagens com resumos:

apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8simagedigests
  annotations:
    metadata.gatekeeper.sh/title: "Image Digests"
    metadata.gatekeeper.sh/version: 1.0.1
    description: >-
      Requires container images to contain a digest.

      https://kubernetes.io/docs/concepts/containers/images/
spec:
  crd:
    spec:
      names:
        kind: K8sImageDigests
      validation:
        openAPIV3Schema:
          type: object
          description: >-
            Requires container images to contain a digest.

            https://kubernetes.io/docs/concepts/containers/images/
          properties:
            exemptImages:
              description: >-
                Any container that uses an image that matches an entry in this list will be excluded
                from enforcement. Prefix-matching can be signified with `*`. For example: `my-image-*`.

                It is recommended that users use the fully-qualified Docker image name (e.g. start with a domain name)
                in order to avoid unexpectedly exempting images from an untrusted repository.
              type: array
              items:
                type: string
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8simagedigests

        import data.lib.exempt_container.is_exempt

        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not is_exempt(container)
          not regex.match("@[a-z0-9]+([+._-][a-z0-9]+)*:[a-zA-Z0-9=_-]+", container.image)
          msg := sprintf("container <%v> uses an image without a digest <%v>", [container.name, container.image])
        }

        violation[{"msg": msg}] {
          container := input.review.object.spec.initContainers[_]
          not is_exempt(container)
          not regex.match("@[a-z0-9]+([+._-][a-z0-9]+)*:[a-zA-Z0-9=_-]+", container.image)
          msg := sprintf("initContainer <%v> uses an image without a digest <%v>", [container.name, container.image])
        }

        violation[{"msg": msg}] {
          container := input.review.object.spec.ephemeralContainers[_]
          not is_exempt(container)
          not regex.match("@[a-z0-9]+([+._-][a-z0-9]+)*:[a-zA-Z0-9=_-]+", container.image)
          msg := sprintf("ephemeralContainer <%v> uses an image without a digest <%v>", [container.name, container.image])
        }
      libs:
        - |
          package lib.exempt_container

          is_exempt(container) {
              exempt_images := object.get(object.get(input, "parameters", {}), "exemptImages", [])
              img := container.image
              exemption := exempt_images[_]
              _matches_exemption(img, exemption)
          }

          _matches_exemption(img, exemption) {
              not endswith(exemption, "*")
              exemption == img
          }

          _matches_exemption(img, exemption) {
              endswith(exemption, "*")
              prefix := trim_suffix(exemption, "*")
              startswith(img, prefix)
          }

A política anterior contém uma expressão regular como entrada para a função re_match. Esta expressão regular corresponde ao resumo da imagem de contentor e baseia-se no formato de resumo na especificação de imagem da Open Container Initiative.

As restrições aplicam a política aos recursos do Kubernetes através da correspondência com atributos como kind e namespace. A restrição de exemplo seguinte aplica a política do modelo de restrição a todos os recursos Pod no espaço de nomes default.

apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sImageDigests
metadata:
  name: container-image-must-have-digest
spec:
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]
    namespaces:
      - "default"

Depois de criar o modelo de restrição e a restrição, todos os novos pods no espaço de nomes default têm de usar resumos de imagens para fazer referência a imagens de contentores.

Para ver o exemplo completo, consulte a política de imagedigests na biblioteca de políticas do Gatekeeper.

Acerca dos manifestos, resumos e etiquetas de imagens

Nesta secção, vai aprender a explorar imagens existentes em registos através de ferramentas de linha de comandos , como curl e docker. Execute os comandos no Cloud Shell ou num ambiente de shell com ferramentas como a CLI gcloud, o Docker, o cURL e o jq já instalados. Os comandos seguintes usam imagens públicas no Artifact Registry.

Obtenha o manifesto da imagem gcr.io/google-containers/pause-amd64:3.2 através do cURL e do URL do manifesto:

curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/3.2

O resultado é semelhante ao seguinte:

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

A secção config tem um atributo de resumo e pode usar este valor para obter o objeto de configuração. Da mesma forma, cada camada tem um digestatributo que pode usar para obter o ficheiro TAR dessa camada.

Se a imagem incluir o índice de imagens opcional, um pedido HTTP GET ao URL do manifesto através de uma etiqueta devolve o índice de imagens em vez do manifesto de imagens.

Obtenha o índice da imagem gcr.io/google-containers/pause:3.2:

curl -s https://gcr.io/v2/google-containers/pause/manifests/3.2

O resultado é semelhante ao seguinte:

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 526,
         "digest": "sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 526,
         "digest": "sha256:bbb7780ca6592cfc98e601f2a5e94bbf748a232f9116518643905aa30fc01642",
         "platform": {
            "architecture": "arm",
            "os": "linux",
            "variant": "v7"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 526,
         "digest": "sha256:31d3efd12022ffeffb3146bc10ae8beb890c80ed2f07363515580add7ed47636",
         "platform": {
            "architecture": "arm64",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 526,
         "digest": "sha256:7f82fecd72730a6aeb70713476fb6f7545ed1bbf32cadd7414a77d25e235aaca",
         "platform": {
            "architecture": "ppc64le",
            "os": "linux"
         }
      },
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 526,
         "digest": "sha256:1175fd4d728641115e2802be80abab108b8d9306442ce35425a4e8707ca60521",
         "platform": {
            "architecture": "s390x",
            "os": "linux"
         }
      }
   ]
}

Filtre o resultado para extrair o resumo da imagem para a plataforma que quer. Obtenha o resumo do manifesto de imagens para a amd64arquitetura da CPU e o sistema operativo linux:
```
curl -s https://gcr.io/v2/google-containers/pause/manifests/3.2 | \
    jq -r '.manifests[] | select(.platform.architecture=="amd64" and .platform.os=="linux") | .digest'
```
A filtragem neste comando imita a forma como os tempos de execução do contentor, como o containerd, selecionam a imagem que corresponde à plataforma de destino a partir do índice de imagens.

O resultado é semelhante ao seguinte:
```
sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108
```
O resumo da imagem é o resultado da aplicação de um hash resistente a colisões ao índice da imagem ou ao manifesto da imagem, normalmente o algoritmo SHA-256.

Obtenha o resumo da imagem gcr.io/google-containers/pause-amd64:3.2:

curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/3.2 \
    | shasum -a 256 \
    | cut -d' ' -f1

O resultado é semelhante ao seguinte:

4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108

Pode fazer referência a esta imagem através do valor de resumo da imagem da seguinte forma:

gcr.io/google-containers/pause-amd64@sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108

Usando o conceito de armazenamento endereçável por conteúdo, obtenha o manifesto de imagens usando o resumo como referência:

curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108

Muitos registos de imagens de contentores devolvem o resumo dos manifestos, dos índices de imagens, dos objetos de configuração e das camadas do sistema de ficheiros no cabeçalho Docker-Content-Digest em resposta a pedidos HTTP HEAD. Obtenha o resumo do índice de imagens da imagem gcr.io/google-containers/pause-amd64:3.2:
```
curl -s --head https://gcr.io/v2/google-containers/pause/manifests/3.2 \
    | grep -i Docker-Content-Digest \
    | cut -d' ' -f2
```
O resultado é semelhante ao seguinte:
```
sha256:927d98197ec1141a368550822d18fa1c60bdae27b78b0c004f705f548c07814f
```
O cabeçalho Docker-Content-Digest não é obrigatório pelas especificações de distribuição da Open Container Initiative, pelo que esta abordagem pode não funcionar com todos os registos de imagens de contentores. Pode usá-lo com o Artifact Registry e o Container Registry.

Para obter um objeto de configuração de imagem através do valor de resumo do manifesto de imagem, faça o seguinte:

Obtenha o resumo da configuração:

CONFIG_DIGEST=$(curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/3.2 \
    | jq -r '.config.digest')

Use o resumo da configuração para obter o objeto de configuração e use jq para formatar o resultado de modo a facilitar a leitura:

curl -sL https://gcr.io/v2/google-containers/pause-amd64/blobs/$CONFIG_DIGEST \
    | jq

O resultado é semelhante ao seguinte:

{
  "architecture": "amd64",
  "config": {
    "Env": [
      "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
    ],
    "Entrypoint": [
      "/pause"
    ],
    "WorkingDir": "/",
    "OnBuild": null
  },
  "created": "2020-02-14T10:51:50.60182885-08:00",
  "history": [
    {
      "created": "2020-02-14T10:51:50.60182885-08:00",
      "created_by": "ARG ARCH",
      "comment": "buildkit.dockerfile.v0",
      "empty_layer": true
    },
    {
      "created": "2020-02-14T10:51:50.60182885-08:00",
      "created_by": "ADD bin/pause-amd64 /pause # buildkit",
      "comment": "buildkit.dockerfile.v0"
    },
    {
      "created": "2020-02-14T10:51:50.60182885-08:00",
      "created_by": "ENTRYPOINT [\"/pause\"]",
      "comment": "buildkit.dockerfile.v0",
      "empty_layer": true
    }
  ],
  "os": "linux",
  "rootfs": {
    "type": "layers",
    "diff_ids": [
      "sha256:ba0dae6243cc9fa2890df40a625721fdbea5c94ca6da897acdd814d710149770"
    ]
  }
}

Para obter camadas do sistema de ficheiros através de valores de hash do manifesto da imagem, faça o seguinte:
1. Obtenha o resumo da camada que quer recuperar:
```
LAYER_DIGEST=$(curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/3.2 \
    | jq -r '.layers[0].digest')
```
2. Use o resumo da camada para obter o ficheiro TAR da camada e liste o conteúdo:
```
curl -sL https://gcr.io/v2/google-containers/pause-amd64/blobs/$LAYER_DIGEST \
    | tar --list
```
  Esta camada tem apenas um ficheiro denominado pause.
Para procurar etiquetas associadas a um resumo de imagens, faça o seguinte:
1. Defina o resumo que quer procurar:
```
IMAGE_DIGEST=$(curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/3.2 \
    | shasum -a 256 \
    | cut -d' ' -f1)
```
  A variável de ambiente IMAGE_DIGEST contém o resumo da imagem referenciada pela etiqueta 3.2.
2. Use o ponto final da lista de etiquetas de imagens/tags/list, para listar informações de etiquetas e extrair as etiquetas para o valor de resumo:
```
curl -s "https://gcr.io/v2/google-containers/pause-amd64/tags/list?n=1" \
    | jq ".manifest.\"sha256:$IMAGE_DIGEST\".tag"
```
  O resultado é semelhante ao seguinte:
```
[
  "3.2"
]
```
Para obter o manifesto de uma imagem de um repositório de imagens de contentores do Artifact Registry através do cURL, inclua um token de acesso no cabeçalho do pedido Authorization:
```
curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://LOCATION-docker.pkg.dev/v2/PROJECT_ID/REPOSITORY/IMAGE/manifests/DIGEST
```
Substitua o seguinte:
- LOCATION: a localização regional ou multirregional do seu repositório
- PROJECT_ID: o seu Google Cloud ID do projeto
- REPOSITORY: o nome do seu repositório
- IMAGE: o nome da imagem
- DIGEST: o resumo da imagem no formato sha256:DIGEST_VALUE

O que se segue?

Para saber mais acerca das imagens, consulte as especificações de formato de imagem e distribuição da Open Container Initiative.

Acerca dos resumos de imagens de contentores Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Imagens de contentores e etiquetas de imagens

Desvantagens das etiquetas de imagens

Estrutura de uma imagem

Encontrar resumos de imagens

Artifact Registry

Container Registry

Cloud Build

Cloud Native Buildpacks

Cliente Docker

crane e gcrane

Impor a utilização de resumos de imagens em implementações do Kubernetes

Acerca dos manifestos, resumos e etiquetas de imagens

O que se segue?

Acerca dos resumos de imagens de contentores

`crane` e `gcrane`