Questa pagina descrive come configurare Cloud Build per creare e archiviare immagini Docker. Se non hai mai utilizzato Cloud Build, leggi guide rapide e configurazione della build panoramica.
Cloud Build fornisce immagini predefinite a cui puoi fare riferimento in un file di configurazione di Cloud Build per eseguire attività di machine learning. 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. Nella addizione:
- 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 in Autorizzare l'accesso service-to-service per creare un account di servizio specificato dall'utente e concedere le autorizzazioni necessari per generare i token ID.
Crea con un file di configurazione di compilazione
Per creare la tua immagine Docker utilizzando un file di configurazione di compilazione:
- Nella stessa directory che contiene il codice sorgente dell'applicazione,
creare un file denominato
cloudbuild.yaml
ocloudbuild.json
. Nel file di configurazione della build:
- Aggiungi un campo
name
e specifica l'immagine Docker predefinita. La l'immagine predefinita è archiviata ingcr.io/cloud-builders/docker
. Nell'esempio: di configurazione predefinito riportato di seguito, il camponame
specifica che il Docker predefinito utilizzata da Cloud Build per eseguire l'attività indicata dal campoargs
. 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 diDockerfile
all'elenco di argomenti nel campoargs
: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 delDockerfile
.
- Aggiungi un campo
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
eSOURCE_DIRECTORY
nelgcloud builds submit
, Cloud Build presuppone che la configurazione e il codice sorgente si trovano nella directory di lavoro corrente.
Crea con un Dockerfile
Cloud Build ti consente di creare un'immagine Docker utilizzando solo
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 di configurazione della build. Puoi eseguire questa operazione utilizzando 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 creare.
- 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:
Eseguire una build utilizzando il valore predefinito
gcr.io/buildpacks/builder
per creare immagineus-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, consultagcloud 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 il metodo riga di comando, puoi configurare trigger in modo che utilizzino i 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 nei 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 nell'ambito del tuo flusso di build.
La differenza tra l'uso del campo images
e del comando Docker push
è
se utilizzi il campo images
, l'immagine archiviata verrà visualizzata
generare risultati. È inclusa la pagina Descrizione build di una build nel
alla console Google Cloud, i risultati
Build.get()
,
e i risultati di gcloud builds list
. Tuttavia, se utilizzi
Docker push
per archiviare l'immagine creata, l'immagine non verrà visualizzata
nei risultati della build.
Se vuoi archiviare l'immagine come parte del flusso di build e vuoi visualizzare
nei risultati della build, usa sia il comando Docker push
che images
nel file di configurazione della build.
Per archiviare un'immagine container in Artifact Registry dopo la build :
- Se il repository di destinazione non esiste, crea un nuovo repository.
- Nella stessa directory che contiene il codice sorgente dell'applicazione e
Dockerfile
, creare un file denominatocloudbuild.yaml
ocloudbuild.json
. Nel file di configurazione di compilazione, 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 Artifact Registry. Lo snippet seguente mostra una configurazione di compilazione da creare di un'immagine e la archivia 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.
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:
Nella stessa directory che contiene il codice sorgente dell'applicazione e
Dockerfile
, creare un file denominatocloudbuild.yaml
ocloudbuild.json
.Nel file di configurazione di compilazione, aggiungi un passaggio di build
docker
per creare un'immagine e quindi aggiungi un altro passaggio di builddocker
e passa gli argomenti per richiamare Comandopush
: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.
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 nel flusso di build e per visualizzarla nel i risultati della build:
- Nella stessa directory che contiene il codice sorgente dell'applicazione e
Dockerfile
, creare un file denominatocloudbuild.yaml
ocloudbuild.json
. Nel file di configurazione di compilazione, dopo il passaggio che crea l'immagine, aggiungi un passaggio richiama il comando Docker
push
e aggiungi il campoimages
: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.
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 cosign per Creare un record dell'account di servizio utilizzato per avviare una build. Con l'appoggio di lo standard OpenID Connect (OIDC), i revisori possono utilizzare questo record per verificare che un'immagine sia stata creata da un l'account di servizio.
I seguenti passaggi dimostrano 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
indica una o più regioni località del repository in cui è archiviata l'immagine, ad esempious-east1
ous
.PROJECT_ID
: l'ID del tuo progetto Google Cloud.REPOSITORY
è il nome del repository in cui l'immagine viene archiviato.IMAGE_NAME
è il nome dell'immagine.SERVICE_ACCOUNT_ID
è l'indirizzo email del specificato dall'utente su cui vuoi eseguire la build. Ad esempio, un l'indirizzo email dell'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 del l'account di servizio affidabile che prevedi sia stato utilizzato nell'immagine container.IMAGE
è il nome completo dell'immagine, incluso sha256 digest di un'immagine.
Esegui l'immagine Docker
Per verificare che l'immagine che hai creato funzioni come previsto, puoi eseguirla utilizzando e Docker.
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
easia-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 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
- Scopri come creare applicazioni Java.
- Scopri come creare applicazioni Python.
- Scopri come creare applicazioni Go.
- Scopri come archiviare gli artefatti delle build in Cloud Storage.
- Scopri come archiviare gli artefatti della build in Artifact Registry.
- Scopri come risolvere gli errori di build.