Informazioni sui digest delle immagini container

Autopilot Standard

Questa pagina descrive i digest delle immagini, inclusi cosa sono, come trovarli e come applicarne l'utilizzo nei cluster Kubernetes. Questa pagina è destinata a sviluppatori e operatori che creano ed eseguono il deployment di immagini container.

Un digest di un'immagine container identifica in modo univoco e immutabile un'immagine container. Quando esegui il deployment delle immagini per digest, eviti gli svantaggi del deployment per tag immagine.

I comandi in questa pagina presuppongono che tu abbia accesso a un ambiente shell Linux o macOS con strumenti come Google Cloud CLI, Docker, cURL, jq e pack già installati. In alternativa, puoi utilizzare Cloud Shell, in cui questi strumenti sono preinstallati.

Immagini container e tag immagine

Quando lavori con le immagini container, hai bisogno di un modo per fare riferimento alle immagini che utilizzi. I tag immagine sono un modo comune per fare riferimento a diverse revisioni di un'immagine. Un approccio comune consiste nell'assegnare tag alle immagini con un identificatore di versione al momento della creazione. Ad esempio, v1.0.1 potrebbe fare riferimento a una versione che chiami 1.0.1.

I tag semplificano la ricerca delle revisioni delle immagini tramite stringhe leggibili. Tuttavia, i tag sono riferimenti modificabili, il che significa che l'immagine a cui fa riferimento un tag può cambiare, come illustrato nel seguente diagramma:

Come mostra il diagramma precedente, se pubblichi una nuova immagine utilizzando lo stesso tag di un'immagine esistente, il tag smette di puntare all'immagine esistente e inizia a puntare alla nuova immagine.

Svantaggi dei tag immagine

Poiché i tag sono modificabili, presentano i seguenti svantaggi quando li utilizzi per eseguire il deployment di un'immagine:

• In Kubernetes, il deployment per tag può produrre risultati imprevisti. Ad esempio, supponi di avere una risorsa Deployment esistente che fa riferimento a un'immagine container tramite il tag v1.0.1. Per correggere un bug o apportare una piccola modifica, il processo di compilazione crea una nuova immagine con lo stesso tag v1.0.1. I nuovi pod creati dalla risorsa Deployment possono finire per utilizzare l'immagine precedente o quella nuova, anche se non modifichi la specifica della risorsa Deployment. Questo problema si applica anche ad altre risorse Kubernetes come StatefulSet, DaemonSet, ReplicaSet e Job.

• Se utilizzi strumenti per eseguire la scansione o l'analisi delle immagini, i risultati di questi strumenti sono validi solo per l'immagine sottoposta a scansione. Per assicurarti di eseguire il deployment dell'immagine sottoposta a scansione, non puoi fare affidamento sul tag perché l'immagine a cui fa riferimento il tag potrebbe essere cambiata.

• Se utilizzi Autorizzazione binaria con Google Kubernetes Engine (GKE), il deployment basato su tag non è consentito perché è impossibile determinare l'immagine esatta utilizzata quando viene creato un pod.

Quando esegui il deployment delle immagini, puoi utilizzare un digest dell'immagine per evitare gli svantaggi dell'utilizzo dei tag. Se vuoi, puoi comunque aggiungere tag alle immagini, ma non è obbligatorio.

Struttura di un'immagine

Un'immagine è composta dai seguenti componenti:

• Un manifest dell'immagine
• Un oggetto di configurazione
• Un array di uno o più strati del file system
• Un indice immagine facoltativo

Questi componenti sono illustrati nel seguente diagramma:

L'immagine precedente mostra ulteriori dettagli sui componenti dell'immagine:

• Il manifest dell'immagine è un documento JSON che contiene un riferimento all'oggetto di configurazione, agli strati del file system e ai metadati facoltativi.
• Il manifest dell'immagine fa riferimento all'oggetto di configurazione e a ciascuno degli strati del file system utilizzando i relativi attributi digest. Il valore di un digest attributo è un hash crittografico dei contenuti a cui il digest fa riferimento, in genere calcolato utilizzando l' SHA-256 SHA-256.
• I valori del digest vengono utilizzati per creare indirizzi immutabili agli oggetti. Questa procedura è chiamata archiviazione indirizzabile in base ai contenuti, e significa che puoi recuperare manifest delle immagini, indici delle immagini, oggetti di configurazione e strati in base ai relativi digest.
• Il digest dell'immagine è l'hash dell'indice dell'immagine o del documento JSON del manifest dell'immagine.
• L'oggetto di configurazione è un documento JSON che definisce le proprietà dell'immagine, come l'architettura della CPU, il punto di ingresso, le porte esposte e le variabili di ambiente.
• L'array di strati del file system definisce l'ordine in cui il runtime del container utilizza gli strati. Gli strati vengono distribuiti come file tar, in genere compressi utilizzando l' gzip utilità.
• L'indice immagine facoltativo, a volte chiamato elenco di manifest, fa riferimento a uno o più manifest delle immagini. Il riferimento è il digest del manifest dell'immagine. Un indice immagine è utile quando produci più immagini correlate per piattaforme diverse , come le architetture amd64 e arm64.

Per ulteriori informazioni, consulta la sezione Esplorare manifest, digest e tag delle immagini.

Trovare i digest delle immagini

Per utilizzare i digest delle immagini per il deployment, devi prima trovare il digest. Poi puoi utilizzare il digest con il comando di deployment o includerlo nei manifest di Kubernetes.

Puoi ottenere il digest di un'immagine in vari modi, a seconda della tua situazione attuale. Le sezioni seguenti contengono esempi per diversi prodotti e strumenti.

Nelle sezioni seguenti, esegui i comandi in Cloud Shell o in un ambiente shell con strumenti come gcloud CLI, Docker, cURL e jq già installati.

Artifact Registry

• Per le immagini archiviate in Artifact Registry, puoi utilizzare il gcloud artifacts docker images describe comando.

  gcloud artifacts docker images describe \
      LOCATION-docker.pkg.dev/PROJECT/REPOSITORY/IMAGE:TAG \
      --format 'value(image_summary.digest)'
  

  Sostituisci quanto segue:

  • LOCATION: la località regionale o multiregionale del repository
  • PROJECT: il tuo Google Cloud ID progetto
  • REPOSITORY: il nome del repository
  • IMAGE: il nome dell'immagine
  • TAG: il tag immagine

Container Registry

Attenzione: Container Registry è stato deprecato. A partire dal 18 marzo 2025, Container Registry è stato chiuso e la scrittura di immagini in Container Registry non è disponibile. Per dettagli sul ritiro e su come eseguire la migrazione ad Artifact Registry, consulta Ritiro di Container Registry.

• Per le immagini archiviate in Container Registry, puoi utilizzare il gcloud container images describe comando per ottenere il digest di un'immagine fornendo il nome e un tag. Utilizza il --format flag per visualizzare solo il digest:

  gcloud container images describe \
      gcr.io/google-containers/pause-amd64:3.2 \
      --format 'value(image_summary.digest)'
  

  L'output è simile al seguente, anche se il valore del digest potrebbe essere diverso:

  sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108
  

Cloud Build

Per le immagini create utilizzando Cloud Build, puoi ottenere il digest dell'immagine utilizzando il gcloud builds describe comando con il flag --format. Questo approccio funziona indipendentemente dal registro utilizzato per pubblicare l'immagine.

• Per una build già completata:

  1. Ottieni un elenco di build per il tuo progetto:

     gcloud builds list
     

     Prendi nota di un BUILD_ID.

  2. Ottieni il digest dell'immagine:

     gcloud builds describe BUILD_ID \
         --format 'value(results.images[0].digest)'
     

     Sostituisci BUILD_ID con l'ID univoco assegnato da Cloud Build alla tua build.

• Ottieni il nome e il digest dell'immagine per l'ultima build di Cloud Build per il progetto corrente:

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

• Se la build ha prodotto più immagini, filtra l'output e ottieni il digest di una delle immagini:

  gcloud builds describe BUILD_ID --format json \
      | jq -r '.results.images[] | select(.name=="YOUR_IMAGE_NAME") | .digest'
  

  Sostituisci YOUR_IMAGE_NAME con il nome di una delle immagini del cloudbuild.yaml file.

• Se invii una build a Cloud Build utilizzando il gcloud builds submit comando, puoi acquisire il digest dell'immagine dall'output in una variabile di ambiente:

  IMAGE_DIGEST=$(gcloud builds submit \
      --format 'value(results.images[0].digest)' | tail -n1)
  

Cloud Native Buildpacks

• Se utilizzi Cloud Native Buildpacks e il Google Cloud builder per creare e pubblicare immagini, puoi acquisire il nome e il digest dell'immagine utilizzando il flag --quiet con il pack comando:

  pack build --builder gcr.io/buildpacks/builder:v1 --publish --quiet \
      LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE \
      > image-with-digest.txt
  

  Sostituisci quanto segue:

  • LOCATION: la località regionale o multiregionale del repository
  • PROJECT_ID: l'ID progetto Google Cloud
  • REPOSITORY: il nome del repository
  • IMAGE: il nome dell'immagine

  Il file image-with-digest.txt contiene il nome e il digest dell'immagine.

  Utilizza il flag --tag se vuoi aggiungere tag all'immagine.

Client Docker

• Il manifest sottocomando del docker client a riga di comando può recuperare i manifest delle immagini e gli elenchi di manifest dai registri delle immagini container.

  Ottieni il digest dall'elenco di manifest dell'immagine registry.k8s.io/pause:3.9, per l'architettura della CPU amd64 e il 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'
  

  L'output è simile al seguente:

  sha256:8d4106c88ec0bd28001e34c975d65175d994072d65341f62a8ab0754b0fafe10
  

• Per le immagini archiviate nel daemon Docker locale, e che sono state estratte da o inserite in un registro delle immagini, puoi utilizzare lo strumento a riga di comando Docker per ottenere il digest dell'immagine:

  1. Estrai l'immagine nel daemon Docker locale Docker:

     docker pull docker.io/library/debian:bookworm
     

  2. Ottieni il digest dell'immagine:

     docker inspect docker.io/library/debian:bookworm \
         | jq -r '.[0].RepoDigests[0]' \
         | cut -d'@' -f2
     

     L'output è simile al seguente, anche se il valore del digest potrebbe essere diverso:

     sha256:3d868b5eb908155f3784317b3dda2941df87bbbbaa4608f84881de66d9bb297b
     

• Elenca tutte le immagini e i digest nel daemon Docker locale:

  docker images --digests
  

  L'output mostra i digest delle immagini che hanno un valore di digest. Le immagini hanno un valore di digest solo se sono state estratte da o inserite in un registro delle immagini.

crane e gcrane

Puoi utilizzare gli strumenti a riga di comando open source crane e gcrane per ottenere il digest di un'immagine senza estrarla in un daemon Docker locale.

1. Scarica crane e gcrane nella directory corrente:

   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
   

2. Ottieni i digest delle immagini:

   ./gcrane digest gcr.io/distroless/static-debian11:nonroot
   

   crane e gcrane hanno altre funzionalità che non rientrano nell'ambito di questa pagina. Per ulteriori informazioni, consulta la documentazione di crane e gcrane.

Applicare l'utilizzo dei digest delle immagini nei deployment di Kubernetes

Se vuoi applicare l'utilizzo dei digest per le immagini di cui esegui il deployment nei tuoi cluster Kubernetes, puoi utilizzare Policy Controller o Open Policy Agent (OPA) Gatekeeper. Policy Controller è basato sul progetto open source OPA Gatekeeper.

Policy Controller e OPA Gatekeeper si basano entrambi sul motore di policy OPA. Policy Controller e OPA Gatekeeper forniscono un webhook di ammissione di convalida di Kubernetes per applicare le policy e definizioni di risorse personalizzate (CRD) per modelli di vincoli e vincoli.

I modelli di vincoli contengono la logica delle policy espressa utilizzando un linguaggio dichiarativo di alto livello chiamato Rego. Di seguito è riportato un modello di vincolo che convalida che i container, i container di inizializzazione, e i container temporanei in una specifica di risorsa Kubernetes utilizzino immagini con digest:

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)
          }

La policy precedente contiene un'espressione regolare come input della re_match funzione. Questa espressione regolare corrisponde al digest dell'immagine container ed è basata su il formato del digest nella specifica dell'immagine Open Container Initiative.

I vincoli applicano la policy alle risorse Kubernetes in base ad attributi come kind e namespace. Il seguente vincolo di esempio applica la policy dal modello di vincolo a tutte le risorse Pod nello spazio dei nomi default.

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

Dopo aver creato il modello di vincolo e il vincolo, tutti i nuovi pod nello spazio dei nomi default devono utilizzare i digest delle immagini per fare riferimento alle immagini container.

Per l'esempio completo, consulta la imagedigestspolicy nella libreria di policy di Gatekeeper.

Informazioni su manifest, digest e tag delle immagini

In questa sezione imparerai a esplorare le immagini esistenti nei registri utilizzando strumenti a riga di comando come curl e docker. Esegui i comandi in Cloud Shell o in un ambiente shell con strumenti come gcloud CLI, Docker, cURL e jq già installati. I seguenti comandi utilizzano immagini pubbliche in Artifact Registry.

• Ottieni il manifest dell'immagine gcr.io/google-containers/pause-amd64:3.2 utilizzando cURL e l' URL del manifest:

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

  L'output è simile al seguente:

  {
     "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"
        }
     ]
  }
  

  La sezione config ha un attributo digest e puoi utilizzare questo valore per recuperare l'oggetto di configurazione. Allo stesso modo, ogni strato ha un attributo digest che puoi utilizzare per recuperare il file tar per quello strato.

• Se l'immagine include l'indice immagine facoltativo, una richiesta HTTP GET all'URL del manifest utilizzando un tag restituisce l'indice immagine anziché il manifest dell'immagine.

  Ottieni l'indice immagine dell'immagine gcr.io/google-containers/pause:3.2:

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

  L'output è simile al seguente:

  {
     "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"
           }
        }
     ]
  }
  

• Filtra il risultato per estrarre il digest dell'immagine per la piattaforma che ti interessa. Ottieni il digest del manifest dell'immagine per l'architettura della CPU amd64 e il 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'
  

  Il filtro in questo comando simula il modo in cui i runtime dei container, come containerd, selezionano l'immagine che corrisponde alla piattaforma di destinazione dall'indice immagine.

  L'output è simile al seguente:

  sha256:4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108
  

  Il digest dell'immagine è il risultato dell'applicazione di un hash resistente alle collisioni all'indice immagine o al manifest dell'immagine, in genere l' SHA-256.

• Ottieni il digest dell'immagine 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
  

  L'output è simile al seguente:

  4a1c4b21597c1b4415bdbecb28a3296c6b5e23ca4f9feeb599860a1dac6a0108
  

  Puoi fare riferimento a questa immagine utilizzando il valore del digest dell'immagine nel seguente modo:

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

• Utilizzando il concetto di archiviazione indirizzabile in base ai contenuti, ottieni il manifest dell'immagine utilizzando il digest come riferimento:

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

• Molti registri di immagini container restituiscono il digest di manifest, indici immagine, oggetti di configurazione e strati del file system nell'intestazione Docker-Content-Digest in risposta alle richieste HTTP HEAD. Ottieni il digest dell'indice immagine dell'immagine 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
  

  L'output è simile al seguente:

  sha256:927d98197ec1141a368550822d18fa1c60bdae27b78b0c004f705f548c07814f
  

  L'intestazione Docker-Content-Digest non è obbligatoria dalle specifiche di distribuzione di Open Container Initiative, pertanto questo approccio potrebbe non funzionare con tutti i registri di immagini container. Puoi utilizzarlo con Artifact Registry e Container Registry.

• Per recuperare un oggetto di configurazione dell'immagine utilizzando il valore del digest dal manifest dell'immagine:

  1. Ottieni il digest della configurazione:

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

  2. Utilizza il digest della configurazione per recuperare l'oggetto di configurazione e utilizza jq per formattare l'output in modo da renderlo più facile da leggere:

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

     L'output è simile al seguente:

     {
       "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"
         ]
       }
     }
     

• Per recuperare gli strati del file system utilizzando i valori del digest dal manifest dell'immagine:

  1. Ottieni il digest dello strato che vuoi recuperare:

     LAYER_DIGEST=$(curl -s https://gcr.io/v2/google-containers/pause-amd64/manifests/3.2 \
         | jq -r '.layers[0].digest')
     

  2. Utilizza il digest dello strato per recuperare il file tar dello strato ed elencarne i contenuti:

     curl -sL https://gcr.io/v2/google-containers/pause-amd64/blobs/$LAYER_DIGEST \
         | tar --list
     

     Questo strato ha un solo file, chiamato pause.

• Per cercare i tag associati a un digest dell'immagine:

  1. Definisci il digest che vuoi cercare:

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

     La variabile di ambiente IMAGE_DIGEST contiene il digest dell'immagine a cui fa riferimento il tag 3.2.

  2. Utilizza l' endpoint dell'elenco dei tag immagine, /tags/list, per elencare le informazioni sui tag ed estrarre i tag per il valore del digest:

     curl -s "https://gcr.io/v2/google-containers/pause-amd64/tags/list?n=1" \
         | jq ".manifest.\"sha256:$IMAGE_DIGEST\".tag"
     

     L'output è simile al seguente:

     [
       "3.2"
     ]
     

• Per ottenere il manifest di un'immagine da un repository di immagini container di Artifact Registry utilizzando cURL, includi un token di accesso nell'intestazione della richiesta Authorization:

  curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      https://LOCATION-docker.pkg.dev/v2/PROJECT_ID/REPOSITORY/IMAGE/manifests/DIGEST
  

  Sostituisci quanto segue:

  • LOCATION: la località regionale o multiregionale del repository
  • PROJECT_ID: l'ID progetto Google Cloud
  • REPOSITORY: il nome del repository
  • IMAGE: il nome dell'immagine
  • DIGEST: il digest dell'immagine nel formato sha256:DIGEST_VALUE

Passaggi successivi

• Per saperne di più sulle immagini, consulta le specifiche del formato Immagine e Distribuzione.