Crea immagini container

Questa pagina descrive come configurare Cloud Build per creare e archiviare le immagini Docker. Se non hai mai utilizzato Cloud Build, leggi prima le guide rapide e la panoramica sulla configurazione della build.

Cloud Build fornisce immagini predefinite che puoi fare riferimento in un file di configurazione di Cloud Build per eseguire le tue attività. Queste immagini sono supportate e gestite da Google Cloud. Puoi utilizzare l'immagine Docker preimpostata supportata per eseguire comandi Docker e creare immagini Docker.

Prima di iniziare

Le istruzioni in questa pagina presuppongono che tu abbia familiarità con Docker. Inoltre:

  • Tieni a portata di mano il codice sorgente dell'applicazione e Dockerfile.
  • Avere un repository Docker per l'archiviazione delle immagini in Artifact Registry o crea un nuovo repository.
  • Se vuoi utilizzare i comandi gcloud in questa pagina, installa Google Cloud CLI.
  • Se vuoi eseguire le immagini, installa Docker
  • Se vuoi firmare le immagini con cosign, segui le istruzioni riportate in Autorizzare l'accesso service-to-service per creare un account di servizio specificato dall'utente e concedere le autorizzazioni necessarie per generare token ID.

Crea con un file di configurazione di compilazione

Per creare la tua immagine Docker utilizzando un file di configurazione di compilazione:

  1. Nella stessa directory che contiene il codice sorgente dell'applicazione, crea un file denominato cloudbuild.yaml o cloudbuild.json.

  2. Nel file di configurazione della build:

    • Aggiungi un campo name e specifica l'immagine Docker predefinita. L'immagine predefinita viene archiviata in gcr.io/cloud-builders/docker. Nel file di configurazione di esempio riportato di seguito, il campo name specifica che l'immagine Docker predefinita viene utilizzata da Cloud Build per eseguire l'attività indicata dal campo args.

    • Nel campo args, aggiungi gli argomenti per creare l'immagine.

      YAML 

      steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]

      JSON 

      {
 "steps": [
  {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
        "."
       ]
   }
   ]
 }

      Sostituisci i valori segnaposto nella configurazione di compilazione precedente con quanto segue:

    • LOCATION: la località a una o più regioni del tuo repository Docker in Artifact Registry.

    • PROJECT_ID: l'ID del tuo progetto Google Cloud.

    • REPOSITORY: il nome del tuo repository Docker in Artifact Registry.

    • IMAGE_NAME: il nome dell'immagine container.

      Se Dockerfile e il codice sorgente si trovano in directory diverse, aggiungi -f e il percorso di Dockerfile all'elenco di argomenti nel campo args:

      YAML 

      steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '-f', 'DOCKERFILE_PATH', '.' ]

      JSON 

      {
 "steps": [
  {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME", '-f', 'DOCKERFILE_PATH', "."
       ]
   }
   ]
 }

      Sostituisci i valori segnaposto nella configurazione di compilazione precedente con quanto segue:

      • LOCATION: la località a una o più regioni del tuo repository.
      • PROJECT_ID: l'ID del tuo progetto Google Cloud.
      • REPOSITORY: il nome del tuo repository Artifact Registry.
      • IMAGE_NAME: il nome dell'immagine container.
      • DOCKERFILE_PATH: percorso del Dockerfile.

  3. Avvia la build utilizzando il file di configurazione della build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Sostituisci i valori segnaposto del comando precedente con i seguenti:

    • CONFIG_FILE_PATH: il percorso del file di configurazione della build.
    • SOURCE_DIRECTORY: il percorso o l'URL del codice sorgente.

    Se non specifichi CONFIG_FILE_PATH e SOURCE_DIRECTORY nel comando gcloud builds submit, Cloud Build presuppone che il file di configurazione e il codice sorgente si trovino nella directory di lavoro attuale.

Crea con un Dockerfile

Cloud Build ti consente di creare un'immagine Docker utilizzando solo un Dockerfile. Non è necessario un file di configurazione della build separato.

Per creare utilizzando un Dockerfile, esegui questo comando dalla directory contenente il tuo codice sorgente e Dockerfile:

    gcloud builds submit --tag LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME

Sostituisci i valori segnaposto del comando precedente con i seguenti:

  • LOCATION: la località a una o più regioni del tuo repository.
  • PROJECT_ID: l'ID del tuo progetto Google Cloud.
  • REPOSITORY: il nome del tuo repository Artifact Registry.
  • IMAGE_NAME: il nome dell'immagine container.

Crea con i buildpack di Google Cloud

Cloud Build ti consente di creare un'immagine senza un Dockerfile o un file di configurazione della build. Puoi farlo utilizzando i buildpack di Google Cloud.

Per creare utilizzando buildpack, esegui questo comando dalla directory contenente il codice sorgente:

    gcloud builds submit --pack builder=BUILDPACK_BUILDER, \
        env=ENVIRONMENT_VARIABLE, \
        image=IMAGE_NAME

Sostituisci i valori segnaposto nei comandi precedenti con i seguenti:

  • BUILDPACK_BUILDER: il builder di buildpacks da utilizzare. Se non specifichi un builder, Cloud Build utilizza gcr.io/buildpacks/builder per impostazione predefinita.
  • ENVIRONMENT_VARIABLE: qualsiasi variabile di ambiente per la tua build.
  • IMAGE: l'URL dell'immagine in Artifact Registry. L'URL dell'immagine deve essere nel formato LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME.

Ecco alcuni comandi di esempio:

  • Esecuzione di una build utilizzando il valore predefinito gcr.io/buildpacks/builder per creare l'immagine us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app:

      gcloud builds submit --pack image=us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app

  • Trasferimento di più variabili di ambiente alla build utilizzando ^--^ come separatore. Per maggiori informazioni sull'utilizzo di caratteri di escape, consulta gcloud topic escaping.

      gcloud builds submit --pack \
      ^--^image=gcr.io/my-project/myimage--env=GOOGLE_ENTRYPOINT='java -jar target/myjar.jar',GOOGLE_RUNTIME_VERSION='3.1.301'

Configurazione dei trigger per l'utilizzo dei buildpack: oltre a creare mediante la riga di comando, puoi configurare trigger in modo che utilizzino buildpack per creare automaticamente l'immagine. Per saperne di più, consulta Creazione e gestione dei trigger di build.

Diversi modi per archiviare le immagini in Artifact Registry

Puoi configurare Cloud Build per archiviare l'immagine creata in uno dei seguenti modi:

  • utilizzando il campo images, che archivia l'immagine in Artifact Registry al termine della build.
  • utilizzando il comando docker push, che archivia l'immagine in Artifact Registry come parte del flusso di build.

La differenza tra l'uso del campo images e del comando Docker push è che, se utilizzi il campo images, l'immagine archiviata verrà visualizzata nei risultati della build. Sono inclusi la pagina Descrizione build di una build nella console Google Cloud, i risultati di Build.get() e quelli di gcloud builds list. Tuttavia, se utilizzi il comando Docker push per archiviare l'immagine creata, quest'ultima non verrà visualizzata nei risultati della build.

Se vuoi archiviare l'immagine come parte del flusso di build e vuoi visualizzarla nei risultati della build, utilizza sia il comando Docker push sia il campo images nel file di configurazione della build.

Per archiviare un'immagine container in Artifact Registry dopo il completamento della build:

  1. Se il repository di destinazione non esiste, crea un nuovo repository.
  2. Nella stessa directory che contiene il codice sorgente dell'applicazione e Dockerfile, crea un file denominato cloudbuild.yaml o cloudbuild.json.

  3. Nel file di configurazione di compilazione, aggiungi un passaggio di build per creare un'immagine, quindi aggiungi un campo images che specifichi l'immagine creata. L'immagine viene archiviata in Artifact Registry. Lo snippet seguente mostra una configurazione di compilazione per creare un'immagine e archiviarla in Artifact Registry:

    YAML 

    steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]
images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']

    JSON 

    {
"steps": [
{
    "name": "gcr.io/cloud-builders/docker",
    "args": [
        "build",
        "-t",
        "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
        "."
    ]
}
],
"images": [
    "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
]
}

    Dove:

    • LOCATION: la località a una o più regioni del tuo repository.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • REPOSITORY: il nome del tuo repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine container.

  4. Avvia la build utilizzando il file di configurazione della build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Dove:

    • CONFIG_FILE_PATH è il percorso del file di configurazione della build.
    • SOURCE_DIRECTORY è il percorso o l'URL del codice sorgente.

Per archiviare l'immagine in Artifact Registry come parte del flusso di build:

  1. Nella stessa directory che contiene il codice sorgente dell'applicazione e Dockerfile, crea un file denominato cloudbuild.yaml o cloudbuild.json.

  2. Nel file di configurazione di compilazione, aggiungi un passaggio di build docker per creare un'immagine, quindi aggiungi un altro passaggio di build docker e passa gli argomenti per richiamare il comando push:

    YAML 

    steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']

    JSON 

    {
  "steps": [
   {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
          "build",
          "-t",
          "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
          "."
       ]
   },
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
          "push",
          "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
        ]
   }
  ]
}

    Dove:

    • LOCATION: la località a una o più regioni del tuo repository.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • REPOSITORY: il nome del tuo repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine container.

  3. Avvia la build utilizzando il file di configurazione della build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Dove:

    • CONFIG_FILE_PATH è il percorso del file di configurazione della build.
    • SOURCE_DIRECTORY è il percorso o l'URL del codice sorgente.

Per archiviare un'immagine come parte del flusso di build e per visualizzarla nei risultati della build:

  1. Nella stessa directory che contiene il codice sorgente dell'applicazione e Dockerfile, crea un file denominato cloudbuild.yaml o cloudbuild.json.

  2. Nel file di configurazione di compilazione, dopo il passaggio che ha creato l'immagine, aggiungi un passaggio per richiamare il comando Docker push e quindi aggiungi il campo images:

    YAML 

    steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']

    JSON 

    {
    "steps": [
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "build",
           "-t",
           "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
           "."
        ]
   },
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "push",
           "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
        ]
   }
   ],
    "images": [
       "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME"
    ]
}

    Dove:

    • LOCATION: la località a una o più regioni del tuo repository.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • REPOSITORY: il nome del tuo repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine container.

  3. Avvia la build utilizzando il file di configurazione della build:

    gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY

    Dove:

    • CONFIG_FILE_PATH è il percorso del file di configurazione della build.
    • SOURCE_DIRECTORY è il percorso o l'URL del codice sorgente.

Firma le immagini container con cosign

Se archivi immagini in Artifact Registry, puoi aggiungere un ulteriore livello di sicurezza utilizzando lo strumento cosign per creare un record dell'account di servizio utilizzato per avviare una build. Basato sullo standard OpenID Connect (OIDC), i revisori possono utilizzare questo record per verificare che un'immagine sia stata creata da un account di servizio attendibile.

I passaggi seguenti spiegano come utilizzare il file di configurazione cloudbuild.yaml per ottenere un token di identità e firmare l'immagine container.

YAML 

  steps:
  - name: 'gcr.io/cloud-builders/docker'
    id: 'tag-and-push'
    script: |
      #!/bin/sh
      set -e
      docker build -t $_IMAGE .
      docker push "$_IMAGE"
      docker inspect $_IMAGE --format "$_IMAGE@{{.Id}}" >image_with_digest
  - name: 'gcr.io/cloud-builders/gcloud'
    id: 'generate-token'
    script: |
      #!/bin/sh
      set -e
      gcloud auth print-identity-token --audiences=sigstore > token
  - name: 'gcr.io/cloud-builders/docker'
    id: 'sign-image'
    script: |
      #!/bin/sh
      set -e
      docker run \
      --network=cloudbuild \
      --mount source=home-volume,target=/builder/home \
      --rm \
      -e SIGSTORE_NO_CACHE=true \
      -e HOME=/builder/home \
      gcr.io/projectsigstore/cosign \
      sign --identity-token=$(cat token) $(cat image_with_digest) -y
  service_account: '$_SERVICE_ACCOUNT'
  artifacts:
    images:
    - $_IMAGE
  substitutions:
    _IMAGE: 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME'
    _SERVICE_ACCOUNT_ID: 'SERVICE_ACCOUNT_ID'
    _SERVICE_ACCOUNT: projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}
  options:
    env:
    - '_IMAGE=$_IMAGE'
    dynamic_substitutions: true
    logging: CLOUD_LOGGING_ONLY

JSON 

    {
        "steps": [
            {
                "name": "gcr.io/cloud-builders/docker",
                "id": "tag-and-push",
                "script": "#!/bin/sh set -e \ndocker build -t $_IMAGE . \ndocker push \"$_IMAGE\""
            },
            {
                "name": "gcr.io/cloud-builders/gcloud",
                "id": "generate-token-and-get-digest",
                "script": "#!/bin/sh set -e \ngcloud auth print-identity-token --audiences=sigstore > token \ngcloud container images describe \"$_IMAGE\" --format=\"value(image_summary.fully_qualified_digest)\" > image_with_digest"
            },
            {
                "name": "gcr.io/projectsigstore/cosign",
                "id": "sign-image",
                "script": "#!/busybox/sh cosign sign --identity-token=$(cat token) $(cat image_with_digest) -y",
                "env": [
                    "SIGSTORE_NO_CACHE=true"
                ]
            }
        ],
        "service_account": "$_SERVICE_ACCOUNT",
        "artifacts": {
            "images": [
                "$_IMAGE"
            ]
        },
        "substitutions": {
            "_IMAGE": "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
            "_SERVICE_ACCOUNT_ID": "SERVICE_ACCOUNT_ID",
            "_SERVICE_ACCOUNT": "projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}"
        },
        "options": {
            "env": [
                "_IMAGE=$_IMAGE"
            ],
            "dynamic_substitutions": true,
            "logging": "CLOUD_LOGGING_ONLY"
        }
    }

Dove:

  • LOCATION è la località a livello di una o più regioni del repository in cui è archiviata l'immagine, ad esempio us-east1 o us.

  • PROJECT_ID: l'ID del tuo progetto Google Cloud.

  • REPOSITORY è il nome del repository in cui è archiviata l'immagine.

  • IMAGE_NAME è il nome dell'immagine.

  • SERVICE_ACCOUNT_ID è l'indirizzo email dell'account di servizio specificato dall'utente su cui vuoi eseguire la build. Ad esempio, l'indirizzo email di un account di servizio ha il seguente aspetto: service-account-name@project-id.iam.gserviceaccount.com.

Per verificare la firma, installa cosign sulla macchina locale, quindi esegui il comando cosign verify:

cosign verify \
--certificate-identity=SERVICE_ACCOUNT_ID \
--certificate-oidc-issuer=https://accounts.google.com \
IMAGE

Dove:

  • SERVICE_ACCOUNT_ID è l'indirizzo email dell'account di servizio attendibile che dovrebbe essere stato utilizzato per creare l'immagine container.
  • IMAGE è il nome completo dell'immagine, incluso il digest dell'immagine sha256.

Esegui l'immagine Docker

Per verificare che l'immagine che hai creato funzioni come previsto, puoi eseguirla utilizzando Docker.

  1. Configura Docker in modo che utilizzi le tue credenziali Artifact Registry durante l'interazione con Artifact Registry. Devi eseguire questa operazione una sola volta. Utilizza il seguente comando per eseguire l'autenticazione utilizzando gcloud credential helper.

    gcloud auth configure-docker HOSTNAME-LIST

    dove HOSTNAME-LIST è un elenco separato da virgole di nomi host del repository da aggiungere alla configurazione dell'assistente per le credenziali.

    Ad esempio, per aggiungere le regioni us-central1 e asia-northeast1, esegui il comando:

    gcloud auth configure-docker us-central1-docker.pkg.dev,asia-northeast1-docker.pkg.dev

  2. Esegui l'immagine Docker che hai creato in precedenza:

    docker run LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME

    Dove:

    • LOCATION: la località a una o più regioni del tuo repository.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • REPOSITORY: il nome del tuo repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine container.

    Verrà visualizzato un output simile al seguente:

    Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.

Passaggi successivi