Crea, testa e containerizza le applicazioni Go

Questa pagina spiega come utilizzare Cloud Build per creare, testare, containerizzare ed eseguire 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 familiarità con Go. Inoltre:

  • Abilita le API Cloud Build, Cloud Run e Artifact Registry.

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

    Abilita le API

  • Per eseguire i comandi gcloud in questa pagina, installa Google Cloud CLI.
  • Tieni a portata di mano il progetto Go.
  • Se vuoi containerizzare l'app Go utilizzando Cloud Build, ti servirà un 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 obbligatorie

Per istruzioni su come concedere questi ruoli, consulta Concedere un ruolo utilizzando la pagina IAM.

Configurare le build Go

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

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

Per creare l'applicazione Go:

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

  2. Crea ed esegui test: 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 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 build.

    • args: il campo args di un passaggio di build accetta 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:

      • Eseguire il formattatore dei log di test per scaricare l'output dei log di test.
      • Stampare l'output dei log.
      • Salvare i risultati dei test in sponge.log.
      • Generare 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 build. Un passaggio di build successivo salverà i log in questo file in Cloud Storage.
      steps:
  # Run tests and save to file
  - name: golang:1.26-trixie
    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. Containerizza 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 seguenti campi in un passaggio di build:

    • 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 seguente passaggio di build crea l'immagine myimage e la contrassegna con la versione breve dell'ID commit. Il passaggio di build utilizza sostituzioni per l'ID progetto, il nome del repository e i valori SHA brevi, pertanto questi valori vengono sostituiti automaticamente al tempo di compilazione. Tieni presente che dovrai creare o avere un repository Docker esistente in Artifact Registry 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 build. Per farlo, devi avere un repository Docker esistente in Artifact Registry. Per configurare Cloud Build in modo che archivi l'immagine in un repository Docker di Artifact Registry, aggiungi un passaggio di build con i seguenti campi:

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

    Il seguente passaggio di build 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 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 gcloud CLI 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 seguente passaggio di build 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 che archivi tutti i log di test in Cloud Storage specificando un percorso e una località del bucket esistenti per i log di test.

    Il seguente passaggio di build archivia 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

    Il seguente snippet mostra il file di configurazione di build completo per i passaggi precedenti:

    steps:
  # Run tests and save to file
  - name: golang:1.26-trixie
    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 build utilizzando la gcloud CLI o i trigger di build. Quando avvii la build, devi specificare il nome del repository Artifact Registry.

    Per specificare il repository Artifact Registry quando avvii la build utilizzando gcloud CLI:

    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 quando crei la build con i trigger di build, specifica il nome del repository Artifact Registry nel campo Variabili di sostituzione quando crei il trigger di build.

Passaggi successivi