Crea e testa le applicazioni Go

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

Prima di iniziare

Le istruzioni 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 a portata di mano il tuo progetto Go.
  • Se vuoi containerizzare la tua app Go con Cloud Build, è necessario 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 richieste

Per istruzioni sulla concessione di questi ruoli, consulta Concessione di un ruolo utilizzando la pagina IAM.

Configurazione di build Go

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

Questa sezione illustra un file di configurazione di compilazione di esempio per un'app Go. Ha i passaggi per creare l'app, aggiungere i test delle unità e, una volta superati i test, containerizzare ed eseguire il deployment dell'app.

Per creare la tua applicazione Go:

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

  2. Creazione e test: se hai definito i test delle unità nella tua applicazione, puoi configura Cloud Build per l'esecuzione dei test aggiungendo quanto segue campi in un passaggio di build:

    • name: imposta il valore di questo campo su golang per utilizzare l'immagine golang da Docker Hub per le tue attività.
    • entrypoint: imposta il valore di questo campo su /bin/bash. Questo consente di per eseguire comandi bash multilinea direttamente dal passaggio di creazione.

    • args: il campo args di un passaggio di build accetta un elenco di argomenti e e le passa all'immagine a cui fa riferimento il campo name. Nel seguente Ad esempio, il campo args accetta gli argomenti per:

      • Eseguire il formattatore di 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 il file XML JUNIT viene creato usando la versione breve dell'ID di commit associato con la tua build. Un passaggio di build successivo salverà i log di questo file in Cloud Storage.
      steps:
  # Run tests and save to file
  - name: golang:1.22
    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 le risorse, puoi creare l'applicazione. Cloud Build fornisce immagine Docker predefinita che puoi utilizzare per containerizzare la tua applicazione Go. A containerizza la tua app, aggiungi i seguenti campi in un passaggio di build:

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

    Il seguente passaggio di build crea l'immagine myimage e la tagga con una 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 vengono sostituiti automaticamente al momento della creazione. Tieni presente che dovrai per creare o avere un repository Docker 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/$_REPO_NAME/myimage:$SHORT_SHA', '.']

  4. Esegui il push del container in Artifact Registry: puoi archiviare il container creato in Artifact Registry, un servizio Google Cloud che puoi utilizzare archiviare, gestire e proteggere gli artefatti delle build. Per farlo, dovrai avere una repository Docker esistente in Artifact Registry. Per configurare Cloud Build per archiviare l'immagine in un repository Docker di Artifact Registry, aggiungi con i seguenti campi:

    • name: imposta il valore di questo campo su gcr.io/cloud-builders/docker su utilizza l'immagine del builder docker ufficiale per l'attività.
    • args: aggiungi gli argomenti per il comando docker push come valori di questo . Per l'URL di destinazione, inserisci il repository Docker di Artifact Registry in cui vuoi archiviare l'immagine.

    Il seguente passaggio di creazione esegue il push dell'immagine che hai creato nel passaggio precedente ad Artifact Registry:

    # 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']

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

    • name: imposta il valore di questo campo su google/cloud-sdk per utilizzare gcloud CLI per richiamare il comando gcloud ed eseguire il deployment dell'immagine su Cloud Run.
    • args: aggiungi come valori gli argomenti per il comando gcloud run deploy 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/$_REPO_NAME/myimage:$SHORT_SHA', 
         '--region', 'us-central1', '--platform', 'managed']

  6. Salva i log di test in Cloud Storage: puoi configurare Cloud Build per archiviare eventuali log di test in Cloud Storage specificando un bucket esistente la posizione e il percorso dei 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:

    # 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 tutti i passaggi descritti sopra:

    steps:
  # Run tests and save to file
  - name: golang:1.22
    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

  7. Avvia la build utilizzando gcloud CLI o trigger di build. Devi specificare il nome del repository Artifact Registry quando avvii creare.

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

    gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_REPO_NAME="REPO_NAME"

    Sostituisci REPO_NAME con il nome del tuo Artifact Registry repository Git.

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

Passaggi successivi