Creazione di applicazioni Go

Questa pagina spiega come utilizzare Cloud Build per creare, testare ed eseguire il deployment di applicazioni Go.

Prima di iniziare

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

Abilita le API Cloud Build, Cloud Run, and Artifact Registry.
Abilita le API
Per eseguire i comandi gcloud in questa pagina, installa Google Cloud CLI.
Tieni il tuo progetto Go a portata di mano.
Se vuoi containerizzare l'app Go utilizzando Cloud Build, hai bisogno di Dockerfile insieme al codice sorgente.
Se vuoi archiviare il container creato in Artifact Registry, crea un repository Docker in Artifact Registry.
Se vuoi archiviare i log di test in Cloud Storage, crea un bucket in Cloud Storage.

Autorizzazioni IAM richieste

Per archiviare i log di test in Logging, concedi il ruolo Creatore oggetti Storage (roles/storage.objectCreator) per il bucket Cloud Storage all'account di servizio Cloud Build.
Per archiviare le immagini create in Artifact Registry, concedi il ruolo Writer Artifact Registry (roles/artifactregistry.writer) all'account di servizio Cloud Build.

Per istruzioni sulla concessione di questi ruoli, vedi Concedere un ruolo utilizzando la pagina IAM.

Configurazione delle build di Go

L'immagine pubblica golang di Docker Hub supporta la creazione con i moduli Go. L'utilizzo di questa immagine come passaggio di build nel file di configurazione di Cloud Build ti consente di richiamare i comandi go all'interno dell'immagine. Gli argomenti passati a questo passaggio della build vengono passati direttamente allo strumento golang, consentendoti di eseguire qualsiasi comando go in questa immagine.

In questa sezione viene illustrato un file di configurazione di esempio per un'app Go, che contiene passaggi per la creazione dell'app, l'aggiunta dei test delle unità e, dopo il test, la containerizzazione e il deployment dell'app.

Per creare la tua applicazione Go:

Nella directory radice del progetto, crea un file di configurazione Cloud Build denominato cloudbuild.yaml.
Crea e verifica: se hai definito test delle unità nella tua applicazione, puoi configurare Cloud Build in modo che esegua i test aggiungendo i seguenti campi in un passaggio di build:
- name: imposta il valore di questo campo su golang per utilizzare l'immagine golang di Docker Hub per la tua attività.
- entrypoint: imposta il valore di questo campo su /bin/bash. Ciò consente di eseguire comandi multilinea su più righe direttamente dal passaggio della build.
- args: il campo args di un passaggio di build prende un elenco di argomenti e li passa all'immagine a cui fa riferimento il campo name. Nell'esempio seguente, il campo args accetta gli argomenti per:
  - Esecuzione del formattatore log di test per scaricare l'output del log di test.
  - Stampa dell'output del log.
  - Salvataggio dei risultati del test in sponge.log.
  - Output dei risultati in sponge.log in un file XML JUNIT. Il nome del file XML JUNIT viene creato utilizzando la versione breve dell'ID commit associato alla build. Un passaggio di build successivo salverà i log in questo file in Cloud Storage.
  Visualizza su GitHub
```
steps:
  # Run tests and save to file
  - name: golang:1.19
    entrypoint: /bin/bash
    args:
      - -c
      - |
        go install github.com/jstemmer/go-junit-report/v2@latest
        2>&1 go test -timeout 1m -v ./... | /go/bin/go-junit-report -set-exit-code -iocopy -out ${SHORT_SHA}_test_log.xml
```
Containerizzare l'app: dopo aver aggiunto il passaggio di build per assicurarti che i test siano stati superati, puoi creare l'applicazione. Cloud Build fornisce un'immagine Docker predefinita che puoi utilizzare per containerizzare l'applicazione Go. Per containerizzare l'app, aggiungi i campi seguenti in un passaggio di build:
- name: imposta il valore di questo campo su gcr.io/cloud-builders/docker per utilizzare l'immagine docker predefinita da Container Registry per la tua attività.
- args: aggiungi gli argomenti per il comando docker build come valori per questo campo.
Il seguente passaggio di build crea l'immagine myimage e la inserisce nella versione breve dell'ID commit. Nel passaggio di build vengono utilizzate sostituzioni per l'ID progetto, il nome del repository e i valori SHA brevi, pertanto questi valori vengono sostituiti automaticamente al momento della build. Tieni presente che dovrai creare o disporre di un repository Docker in Artifact Registry per archiviare l'immagine.

Visualizza su GitHub
```
# Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t',
         'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA', '.']
```
Esegui il push del container ad Artifact Registry: puoi archiviare il container creato in Artifact Registry, che è un servizio Google Cloud che puoi utilizzare per archiviare, gestire e proteggere gli artefatti di build. Per fare ciò, devi avere un repository Docker esistente in Artifact Registry. Per configurare Cloud Build per archiviare l'immagine in un repository Docker di Artifact Registry, aggiungi un passaggio di build con i campi seguenti:
- name: imposta il valore di questo campo su gcr.io/cloud-builders/docker per utilizzare l'immagine ufficiale del builder docker di Container Registry per la tua attività.
- args: aggiungi gli argomenti per il comando docker push come valori di questo campo. Per l'URL di destinazione, inserisci il repository Docker per Artifact Registry in cui vuoi archiviare l'immagine.
Il seguente passaggio di build esegue il push dell'immagine che hai creato nel passaggio precedente ad Artifact Registry:

Visualizza su GitHub
```
# Docker push to Google Artifact Registry
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA']
```
Esegui il deployment del container in Cloud Run: per eseguire il deployment dell'immagine in Cloud Run, aggiungi un passaggio di build con i seguenti campi:
- name: imposta il valore di questo campo su google/cloud-sdk per utilizzare l'immagine dell'interfaccia a riga di comando gcloud per richiamare il comando gcloud per eseguire il deployment dell'immagine in Cloud Run.
- args: aggiungi gli argomenti per il comando gcloud run deploy come valori di questo campo.
Il passaggio di build seguente esegue il deployment dell'immagine creata in precedenza in Cloud Run:

Visualizza su GitHub
```
# Deploy to Cloud Run
- name: 'gcr.io/cloud-builders/gcloud'
  args: ['run', 'deploy', 'helloworld-${SHORT_SHA}',
         '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA',
         '--region', 'us-central1', '--platform', 'managed']
```

Salvare i log di test in Cloud Storage: puoi configurare Cloud Build in modo da archiviare tutti i log di test in Cloud Storage specificando una posizione del bucket e un percorso esistenti ai log di test.

Il seguente passaggio di build archivia i log di test che hai salvato nel file XML JUNIT in un bucket Cloud Storage:

Visualizza su GitHub

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://$_BUCKET_NAME/
    paths:
      - ${SHORT_SHA}_test_log.xml

Lo snippet seguente mostra il file di configurazione della build completo di tutti i passaggi descritti in precedenza:

Visualizza su GitHub

steps:
  # Run tests and save to file
  - name: golang:1.19
    entrypoint: /bin/bash
    args:
      - -c
      - |
        go install github.com/jstemmer/go-junit-report/v2@latest
        2>&1 go test -timeout 1m -v ./... | /go/bin/go-junit-report -set-exit-code -iocopy -out ${SHORT_SHA}_test_log.xml

  # Docker Build
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t',
           'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA', '.']

  # Docker push to Google Artifact Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA']

  # Deploy to Cloud Run
  - name: 'gcr.io/cloud-builders/gcloud'
    args: ['run', 'deploy', 'helloworld-${SHORT_SHA}',
           '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA',
           '--region', 'us-central1', '--platform', 'managed']

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://$_BUCKET_NAME/
    paths:
      - ${SHORT_SHA}_test_log.xml
# Store images in Google Artifact Registry
images:
  - us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA

Avvia la build utilizzando l'interfaccia a riga di comando gcloud o i trigger di build. Dovrai specificare il nome del repository Artifact Registry all'avvio della build.

Per specificare il repository di Artifact Registry all'avvio della build utilizzando l'interfaccia a riga di comando gcloud:
```
gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_REPO_NAME="REPO_NAME"
```
Sostituisci REPO_NAME con il nome del tuo repository Artifact Registry.

Per specificare il repository Artifact Registry durante la creazione con trigger di build, specifica il nome del repository Artifact Registry nel campo Variabili di sostituzione quando crei il trigger di build.

Passaggi successivi

Scopri come creare immagini container.
Scopri come risolvere gli errori di build.