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 gli avvii rapidi e la panoramica della configurazione di compilazione.

Cloud Build fornisce immagini pre-create a cui puoi fare riferimento in un file di configurazione Cloud Build per eseguire le tue attività. Queste immagini sono supportate e gestite da Google Cloud. Puoi utilizzare la immagine Docker predefinita supportata per eseguire comandi Docker e creare immagini Docker.

Prima di iniziare

Le istruzioni riportate in questa pagina presuppongono che tu abbia dimestichezza con Docker. Inoltre:

  • Tieni a portata di mano il codice sorgente dell'applicazione e Dockerfile.
  • Avere un repository Docker per archiviare le immagini in Artifact Registry o creare 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 la cofirma, segui le istruzioni riportate in Autorizzare l'accesso da servizio a servizio per creare un account di servizio specificato dall'utente e concedere le autorizzazioni necessarie per generare token ID.

Eseguire la compilazione con un file di configurazione della build

Per creare l'immagine Docker utilizzando un file di configurazione della build:

  1. Nella stessa directory contenente 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 è archiviata in gcr.io/cloud-builders/docker. Nell'esempio di file di configurazione 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 riportata sopra con quanto segue:

    • LOCATION: la posizione regionale o multiregionale del repository Docker in Artifact Registry.

    • PROJECT_ID: il tuo ID progetto Google Cloud.

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

    • IMAGE_NAME: il nome dell'immagine del contenitore.

      Se Dockerfile e il codice sorgente si trovano in directory diverse, aggiungi -f e il percorso di Dockerfile all'elenco degli 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 riportata sopra con quanto segue:

      • LOCATION: la posizione regionale o multiregionale del repository.
      • PROJECT_ID: il tuo ID progetto Google Cloud.
      • REPOSITORY: il nome del repository Artifact Registry.
      • IMAGE_NAME: il nome dell'immagine del contenitore.
      • DOCKERFILE_PATH: percorso del tuo 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 nel comando precedente con quanto segue:

    • CONFIG_FILE_PATH: il percorso del file di configurazione di compilazione.
    • 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 corrente.

Esegui il build con un Dockerfile

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

Per eseguire il build utilizzando un Dockerfile, esegui il seguente comando dalla directory contenente il codice sorgente e il Dockerfile:

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

Sostituisci i valori segnaposto nel comando precedente con quanto segue:

  • LOCATION: la posizione regionale o multiregionale del repository.
  • PROJECT_ID: il tuo ID progetto Google Cloud.
  • REPOSITORY: il nome del repository Artifact Registry.
  • IMAGE_NAME: il nome dell'immagine del contenitore.

Creare 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 eseguire il build utilizzando i buildpack, esegui il seguente 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 quanto segue:

  • BUILDPACK_BUILDER: il generatore di buildpack da utilizzare. Se non specifichi un generatore, Cloud Build utilizza gcr.io/buildpacks/builder per impostazione predefinita.
  • ENVIRONMENT_VARIABLE: eventuali variabili di ambiente per la compilazione.
  • 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:

  • Esegui una compilazione 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

  • Passare più variabili di ambiente alla build utilizzando ^--^ come separatore. Per ulteriori informazioni sull'escapismo degli argomenti, 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 degli attivatori per l'utilizzo dei buildpack: oltre a eseguire la compilazione utilizzando la riga di comando, puoi configurare gli attivatori per utilizzare i buildpack per compilare automaticamente l'immagine. Per scoprire di più, consulta la pagina Creare e gestire i trigger di build.

Diversi modi per archiviare le immagini in Artifact Registry

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

  • 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 nell'ambito del flusso di compilazione.

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

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

Per archiviare un'immagine container in Artifact Registry al termine della compilazione:

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

  3. Nel file di configurazione della build, aggiungi un passaggio di compilazione per creare un'immagine, quindi un campo images che specifichi l'immagine creata. L'immagine viene archiviata in Artifact Registry. Lo snippet seguente mostra una configurazione di build 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 posizione regionale o multiregionale del repository.
    • PROJECT_ID: il tuo ID progetto Google Cloud.
    • REPOSITORY: il nome del repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine del contenitore.

  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 nell'ambito del flusso di compilazione:

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

  2. Nel file di configurazione della build, aggiungi un passaggio di compilazione docker per creare un'immagine, quindi aggiungi un altro passaggio di compilazione 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 posizione regionale o multiregionale del repository.
    • PROJECT_ID: il tuo ID progetto Google Cloud.
    • REPOSITORY: il nome del repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine del contenitore.

  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 all'interno del flusso di compilazione e visualizzarla nei risultati della compilazione:

  1. Nella stessa directory contenente 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 crea l'immagine, aggiungi un passaggio per invocare il comando push di Docker e poi 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 posizione regionale o multiregionale del repository.
    • PROJECT_ID: il tuo ID progetto Google Cloud.
    • REPOSITORY: il nome del repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine del contenitore.

  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.

Firmare le immagini container con cosign

Se memorizzi le immagini in Artifact Registry, puoi aggiungere un altro livello di sicurezza utilizzando lo strumento cosign per creare un record dell'account di servizio utilizzato per avviare una compilazione. Supportato dall'standard OpenID Connect (OIDC), questo record può essere utilizzato dagli auditor per verificare che un'immagine sia stata creata da un account di servizio attendibile.

I passaggi riportati di seguito mostrano come utilizzare il file di configurazione cloudbuild.yaml per ottenere un token di identità e firmare l'immagine del contenitore.

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à regionale o multiregionale del repository in cui è archiviata l'immagine, ad esempio us-east1 o us.

  • PROJECT_ID: il tuo ID 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 in cui vuoi eseguire la compilazione. Ad esempio, un 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 tua 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 prevedi di aver 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 creata funzioni come previsto, puoi eseguirla utilizzando Docker.

  1. Configura Docker in modo che utilizzi le tue credenziali di Artifact Registry quando interagisci con Artifact Registry. (questa operazione deve essere eseguita una sola volta). Utilizza il seguente comando per autenticarti utilizzando lo strumento gcloud credential helper.

    gcloud auth configure-docker HOSTNAME-LIST

    dove ELENKO-HOSTNAME è un elenco separato da virgole di nomi host del repository da aggiungere alla configurazione dell'helper delle 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 posizione regionale o multiregionale del repository.
    • PROJECT_ID: il tuo ID progetto Google Cloud.
    • REPOSITORY: il nome del repository Artifact Registry.
    • IMAGE_NAME: il nome dell'immagine del contenitore.

    Vedrai un output simile al seguente:

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

Passaggi successivi