Crea, testa e containerizza le applicazioni Go

Questa pagina spiega come utilizzare Cloud Build per creare, testare, eseguire il containerizzazione e il deployment di applicazioni Go e come salvare i log di test in Cloud Storage.

Prima di iniziare

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

  • Enable the Cloud Build, Cloud Run, and Artifact Registry APIs.

    Enable the APIs

  • Per eseguire i comandi gcloud in questa pagina, installa Google Cloud CLI.
  • Tieni a portata di mano il progetto Go.
  • Se vuoi eseguire il containerizzazione della tua app Go utilizzando Cloud Build, devi avere un file Dockerfile insieme al codice sorgente.
  • Se vuoi archiviare il container compilato 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 istruzioni su come concedere questi ruoli, consulta Concedere un ruolo utilizzando la pagina IAM.

Configurazione delle build Go

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

Questa sezione illustra un file di configurazione di build di esempio per un'app Go. Contiene i passaggi di compilazione per creare l'app, aggiungere i test delle unità e, dopo il superamento dei test, per eseguire il containerizzazione e il deployment dell'app.

Per compilare l'applicazione Go:

  1. Nella directory principale del progetto, crea un file di configurazione Cloud Build denominato cloudbuild.yaml.

  2. Compilazione e test: se hai definito test di unità nella tua applicazione, puoi configurare Cloud Build per eseguirli aggiungendo i seguenti campi in un passaggio di compilazione:

    • name: imposta il valore di questo campo su golang per utilizzare l'immagine golang da Docker Hub per l'attività.
    • entrypoint: imposta il valore di questo campo su /bin/bash. In questo modo puoi eseguire comandi bash su più righe direttamente dal passaggio di compilazione.

    • args: il campo args di un passaggio di compilazione prende un elenco di argomenti e li passa all'immagine a cui fa riferimento il campo name. Nell'esempio riportato di seguito, il campo args accetta gli argomenti per:

      • Esegui il programma di formattazione dei log di test per scaricare l'output del log di test.
      • Stampa dell'output del log.
      • Salvataggio dei risultati del test in sponge.log.
      • Eseguire l'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 compilazione. Un passaggio di compilazione successivo salverà i log in questo file in Cloud Storage.
      steps:
  # Run tests and save to file
  - name: golang:1.23
    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

  3. Esegui il containerizzazione dell'app: dopo aver aggiunto il passaggio di compilazione per assicurarti che i test siano stati superati, puoi compilare l'applicazione. Cloud Build fornisce un'immagine Docker predefinita che puoi utilizzare per eseguire il containerizzazione della tua applicazione Go. Per contengare l'app, aggiungi i seguenti campi in un passaggio di compilazione:

    • name: imposta il valore di questo campo su gcr.io/cloud-builders/docker per utilizzare l'immagine Docker predefinita per l'attività.
    • args: aggiungi gli argomenti per il comando docker build come valori per questo campo.

    Il passaggio di compilazione seguente crea l'immagine myimage e la contrassegna con la versione breve dell'ID commit. Il passaggio di compilazione utilizza sostituzione per l'ID progetto, il nome del repository e i valori SHA brevi, pertanto questi valori vengono sostituiti automaticamente in fase di compilazione. Tieni presente che dovrai creare o disporre di un repository Docker in Artifact Registry esistente per archiviare l'immagine.

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

  4. Esegui il push del container in Artifact Registry: puoi archiviare il container creato in Artifact Registry, un Google Cloud servizio che puoi utilizzare per archiviare, gestire e proteggere gli artefatti di compilazione. Per farlo, 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 compilazione con i seguenti campi:

    • name: imposta il valore di questo campo su gcr.io/cloud-builders/docker per utilizzare l'immagine ufficiale del generatore docker 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 di Artifact Registry dove vuoi archiviare l'immagine.

    Il seguente passaggio di compilazione esegue il push dell'immagine creata nel passaggio precedente in Artifact Registry:

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

  5. Esegui il deployment del contenitore in Cloud Run: per eseguire il deployment dell'immagine su Cloud Run, aggiungi un passaggio di compilazione con i seguenti campi:

    • name: imposta il valore di questo campo su google/cloud-sdk per utilizzare l'immagine gcloud CLI per richiamare il comando gcloud per eseguire il deployment dell'immagine su Cloud Run.
    • args: aggiungi gli argomenti per il comando gcloud run deploy come valori di questo campo.

    Il seguente passaggio di compilazione esegue il deployment dell'immagine creata in precedenza in Cloud Run:

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

  6. Salva i log di test in Cloud Storage: puoi configurare Cloud Build in modo da archiviare i log di test in Cloud Storage specificando la posizione e il percorso del bucket esistente per i log di test.

    Il seguente passaggio di compilazione memorizza i log di test salvati nel file XML JUNIT in un bucket Cloud Storage:

    # 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 per i passaggi precedenti:

    steps:
  # Run tests and save to file
  - name: golang:1.23
    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/$_AR_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/$_AR_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/$_AR_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/$_AR_REPO_NAME/myimage:$SHORT_SHA

  7. Avvia la compilazione utilizzando l'interfaccia a riga di comando gcloud o gli trigger di compilazione. Devi specificare il nome del repository Artifact Registry all'avvio della compilazione.

    Per specificare il repository Artifact Registry all'avvio della build utilizzando la CLI gcloud:

    gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_AR_REPO_NAME="AR_REPO_NAME"

    Sostituisci AR_REPO_NAME con il nome del repository Artifact Registry.

    Per specificare il repository Artifact Registry durante la compilazione con gli trigger di compilazione, specifica il nome del repository Artifact Registry nel variabili di sostituzione quando crei l'trigger di compilazione.

Passaggi successivi