Questa pagina è stata tradotta dall'API Cloud Translation.

Creazione delle 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 di Cloud Build.

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

Prima di iniziare

Le istruzioni riportate in questa pagina presuppongono la tua conoscenza di Docker. Inoltre:

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 crea un nuovo repository.
Se vuoi utilizzare i comandi gcloud in questa pagina, installa l'interfaccia a riga di comando di Google Cloud.
Se vuoi eseguire le immagini, installa Docker.

Creazione con un file di configurazione della build

Per creare la tua 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 viene archiviata in Container Registry all'indirizzo 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 della build precedente con la seguente:
- LOCATION: località regionale o multi-regionale del tuo repository Docker in Artifact Registry.
- PROJECT_ID: ID del progetto Cloud.
- REPOSITORY: il nome del tuo repository Docker in Artifact Registry.
- IMAGE_NAME: il nome dell'immagine del container.
  
  Se Dockerfile e il codice sorgente si trovano in directory diverse, aggiungi -f e il percorso verso Dockerfile nell'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 della build precedente con la seguente:
  - LOCATION: località geografica o multi-area geografica per il repository.
  - PROJECT_ID: ID del progetto Cloud.
  - REPOSITORY: il nome del repository Artifact Registry.
  - IMAGE_NAME: il nome dell'immagine del container.
  - DOCKERFILE_PATH: percorso verso il tuo Dockerfile.
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 riportato sopra con il seguente:
- CONFIG_FILE_PATH: il percorso del file di configurazione della build.
- SOURCE_DIRECTORY: percorso o 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.

Creazione con un Dockerfile

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

Per creare una risorsa utilizzando un Dockerfile, esegui il comando seguente dalla directory contenente il tuo codice sorgente e la Dockerfile:

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

Sostituisci i valori segnaposto nel comando riportato sopra con il seguente:

LOCATION: località geografica o multi-area geografica per il repository.
PROJECT_ID: ID del progetto Cloud.
REPOSITORY: il nome del repository Artifact Registry.
IMAGE_NAME: il nome dell'immagine del container.

Creazione con i pacchetti di build cloud-native

Cloud Build ti consente di creare un'immagine senza un Dockerfile o un file di configurazione da creare. Puoi farlo utilizzando Cloud Native Buildpacks.

Per creare la build utilizzando i pacchetti build, esegui il comando seguente dalla directory contenente il tuo codice sorgente:

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

Sostituisci i valori segnaposto nei comandi riportati sopra con i seguenti valori:

BUILDPACK_BUILDER: il builder buildpack 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 esempi di comandi:

Esegui una build utilizzando l'impostazione predefinita 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
```
Passaggio di più variabili di ambiente alla build mediante l'uso di ^--^ come separatore. Per ulteriori informazioni sull'interpretazione letterale 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 mediante la riga di comando, puoi configurare i trigger per l'utilizzo dei buildpack in modo da creare automaticamente l'immagine. Per scoprire di più, consulta la sezione Creare e gestire i trigger di build.

Modi diversi di archiviazione delle immagini in Artifact Registry

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

utilizzando il campo images, che memorizza l'immagine in Artifact Registry al termine della build.
utilizzando il comando docker push, che archivia l'immagine in Artifact Registry durante il flusso di compilazione.

La differenza tra l'uso del campo images e il 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, i risultati di Build.get() e i risultati 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 visualizzare l'immagine 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:

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 specifichi l'immagine creata. In questo modo, 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: località geografica o multi-area geografica per il repository.
- PROJECT_ID: ID del progetto Cloud.
- REPOSITORY: il nome del repository Artifact Registry.
- IMAGE_NAME: il nome dell'immagine del 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.

Per archiviare l'immagine in Artifact Registry nell'ambito del flusso di compilazione:

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, quindi aggiungi un altro passaggio di build docker e trasmetti 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: località geografica o multi-area geografica per il repository.
PROJECT_ID: ID del progetto Cloud.
REPOSITORY: il nome del repository Artifact Registry.
IMAGE_NAME: il nome dell'immagine del 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.

Per archiviare un'immagine come parte del flusso di build e mostrarla 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 di push e 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: località geografica o multi-area geografica per il repository.
PROJECT_ID: ID del progetto Cloud.
REPOSITORY: il nome del repository Artifact Registry.
IMAGE_NAME: il nome dell'immagine del 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.

Esegui l'immagine Docker

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

Configura Docker per utilizzare le tue credenziali Artifact Registry durante l'interazione con Artifact Registry. Questa operazione deve essere eseguita solo una volta. Utilizza il comando seguente per autenticarti utilizzando l'Assistente per le credenziali gcloud.
```
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 credenziali.

Ad esempio, per aggiungere le aree geografiche 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 creata in precedenza:
```
docker run LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME
```
Dove:
- LOCATION: località geografica o multi-area geografica per il repository.
- PROJECT_ID: ID del progetto Cloud.
- REPOSITORY: il nome del repository Artifact Registry.
- IMAGE_NAME: il nome dell'immagine del container.
Verrà visualizzato un output simile al seguente:
```
Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.
```

Passaggi successivi

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