Crea immagini container

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

Cloud Build fornisce immagini predefinite che 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 l'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 familiarità con Docker. In aggiunta:

Tieni a portata di mano il codice sorgente dell'applicazione e Dockerfile.
Disponi di un repository Docker per archiviare le immagini in Artifact Registry o creane uno nuovo.
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 firma congiunta, 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.

Compila con un file di configurazione della build

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

Nella stessa directory contenente il codice sorgente dell'applicazione, crea un file denominato cloudbuild.yaml o cloudbuild.json.
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. Nel seguente file di configurazione di esempio, 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", "." ] } ] }
Dove:
- 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 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', "." ] } ] }
  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 container.
  - DOCKERFILE_PATH: il percorso del tuo Dockerfile.
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.
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.

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 eseguire la 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

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 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 eseguire la build utilizzando i buildpack, esegui questo comando dalla directory contenente il codice sorgente:

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

Dove:

BUILDPACK_BUILDER: il builder di buildpack da utilizzare. Se non specifichi un builder, Cloud Build utilizza gcr.io/buildpacks/builder per impostazione predefinita.
ENVIRONMENT_VARIABLE: eventuali variabili di ambiente per la 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 gcr.io/buildpacks/builder predefinito 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
```
Passaggio di più variabili di ambiente alla build utilizzando ^--^ come separatore. Per ulteriori informazioni sull'escape 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 dei trigger per l'utilizzo dei buildpack: oltre a creare utilizzando la riga di comando, puoi configurare i trigger per utilizzare i buildpack per creare automaticamente l'immagine. Per scoprire di più, consulta la pagina Creare e gestire i trigger di build.

Diversi modi di archiviare le immagini in Artifact Registry

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

Utilizza il campo images per archiviare un'immagine Docker in Artifact Registry al termine della build.
Utilizza il campo artifacts.oci per archiviare un'immagine OCI in Artifact Registry al termine della build.
Utilizza il comando docker push per archiviare un'immagine container in Artifact Registry nell'ambito del flusso di build.

La differenza tra l'utilizzo 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 per una build nella consoleGoogle Cloud , i risultati di Build.get() e i risultati di gcloud builds list. Tuttavia, se utilizzi il comando Docker push per archiviare l'immagine creata, questa non verrà visualizzata nei risultati della build.

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

Archivia un'immagine container in Artifact Registry al termine della build

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

Nel file di configurazione della build, aggiungi un passaggio di build per creare un'immagine, quindi aggiungi un campo images che specifica l'immagine creata. In questo modo, l'immagine viene archiviata in Artifact Registry. Il seguente snippet mostra una configurazione della 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 container.

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.

Archivia l'immagine in Artifact Registry nell'ambito del flusso di build

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

Nel file di configurazione della build, aggiungi un passaggio di build docker per creare un'immagine, poi 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 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 container.

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.

Archivia un'immagine come parte del flusso di build e per visualizzarla nei risultati della build

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

Nel file di configurazione della build, dopo il passaggio che crea l'immagine, aggiungi un passaggio per richiamare il comando Docker push 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 container.

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.

Archivia un'immagine OCI in Artifact Registry al termine della build

Nella stessa directory contenente il codice sorgente dell'applicazione e Dockerfile, crea un file denominato cloudbuild.yaml o cloudbuild.json.
Nel file di configurazione della build, aggiungi un campo artifacts che specifica l'immagine OCI creata. Questa configurazione memorizza l'immagine OCI in Artifact Registry. L'esempio seguente mostra una configurazione di build che crea un'immagine OCI e la archivia in Artifact Registry:
YAML
```
artifacts:
  oci:
  - file: 'OCI_IMAGE_PATH'
    registryPath: 'https://LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY'
    tags: ["primary_image"]
```
JSON
```
{
  "artifacts": {
    "oci": [
      {
        "file": "OCI_IMAGE_PATH",
        "registryPath": "https://LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY",
        "tags": ["primary_image"]
      }
    ]
  }
}
```
Dove:
- OCI_IMAGE_PATH è l'indirizzo della directory locale che contiene l'immagine OCI da caricare, ad esempio /.pack/layout-repo/my-app.
- LOCATION è la località regionale o multiregionale del repository.
- PROJECT_ID è l'ID progetto Google Cloud .
- REPOSITORY: è il nome del tuo repository Artifact Registry.

Firma delle 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 del account di servizio utilizzato per avviare una build. Supportato dallo standard OpenID Connect (OIDC), gli auditor possono utilizzare questo record per verificare che un'immagine sia stata creata da un account di servizio attendibile.

I passaggi seguenti mostrano 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à 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 del account di servizio specificato dall'utente che vuoi utilizzare per eseguire la build. Ad esempio, un indirizzo email del 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 del account di servizio attendibile che prevedi sia 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.

Configura Docker per utilizzare le credenziali di Artifact Registry quando interagisci con Artifact Registry. (Devi farlo solo una volta.) Utilizza il seguente comando per autenticarti 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'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
```
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 container.
Vedrai un output simile al seguente:
```
Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.
```

Passaggi successivi

Scopri come creare applicazioni Java.
Scopri come creare applicazioni Python.
Scopri come creare applicazioni Go.
Scopri come archiviare gli artefatti di build in Cloud Storage.
Scopri come archiviare gli artefatti di build in Artifact Registry.
Scopri come risolvere gli errori di build.

Crea immagini container Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Compila con un file di configurazione della build

YAML

JSON

YAML

JSON

Crea con un Dockerfile

Crea con i buildpack di Google Cloud

Diversi modi di archiviare le immagini in Artifact Registry

Archivia un'immagine container in Artifact Registry al termine della build

YAML

JSON

Archivia l'immagine in Artifact Registry nell'ambito del flusso di build

YAML

JSON

Archivia un'immagine come parte del flusso di build e per visualizzarla nei risultati della build

YAML

JSON

Archivia un'immagine OCI in Artifact Registry al termine della build

YAML

JSON

Firma delle immagini container con cosign

YAML

JSON

Esegui l'immagine Docker

Passaggi successivi

Crea immagini container