Diese Seite wurde von der Cloud Translation API übersetzt.

Go-Anwendungen erstellen und testen

Auf dieser Seite wird erläutert, wie Sie mit Cloud Build Go-Anwendungen erstellen, testen und bereitstellen.

Hinweise

Die Anleitung auf dieser Seite setzt voraus, dass Sie mit Go vertraut sind. Außerdem gilt:

Enable the Cloud Build, Cloud Run, and Artifact Registry APIs.
Enable the APIs
Zum Ausführen der gcloud-Befehle auf dieser Seite müssen Sie die Google Cloud CLI installieren.
Klonen Sie das Git-Repository cloud-build-samples. Dies stellt eine kleine Webanwendung mit Tests und einer Dockerfile bereit.
Erstellen Sie ein Docker-Repository in Artifact Registry, falls Sie noch keines haben.
Erstellen Sie einen Bucket in Cloud Storage, um Testprotokolle zu speichern.

Dienstkonto konfigurieren

In den Beispielen in diesem Dokument wird ein vom Nutzer angegebenes Dienstkonto verwendet. Führen Sie in der Google Cloud CLI den folgenden Befehl aus, um das von Cloud Build verwendete Dienstkonto zu erstellen:

gcloud iam service-accounts create cloud-build-go \
--description="Build and test Go applications" \
--display-name="Cloud Build Go" \
--project="PROJECT_ID"

Das Compute-Standarddienstkonto, das von Cloud Run verwendet wird, benötigt die Berechtigung, als neues Dienstkonto zu fungieren. Ermitteln Sie zuerst den Namen des Compute-Dienstkontos in Ihrem Projekt:

gcloud iam service-accounts list --filter="email:-compute@developer.gserviceaccount.com"

Weisen Sie als Nächstes die Rolle Dienstkontonutzerroles/iam.serviceAccountUser () zu:

gcloud iam service-accounts add-iam-policy-binding \
COMPUTE_SERVICE_ACCOUNT_EMAIL  \
--member="serviceAccount:cloud-build-go@PROJECT_ID.iam.gserviceaccount.com" \
--role="roles/iam.serviceAccountUser"

Ersetzen Sie COMPUTE_SERVICE_ACCOUNT_EMAIL durch die E-Mail-Adresse des Standard-Compute-Dienstkontos, die durch den vorherigen Befehl ausgegeben wurde.

IAM-Berechtigungen konfigurieren

Prüfen Sie, ob Sie die erforderlichen Berechtigungen haben:

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Cloud Build-Dienstkonto (roles/cloudbuild.builds.builder) für Ihr Build-Dienstkonto zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen von Builds in Cloud Build benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Artifact Registry Writer (roles/artifactregistry.writer) für Ihr Build-Dienstkonto zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Speichern erstellter Images in Artifact Registry benötigen.

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Storage Object Creator (roles/storage.objectCreator) für Ihr Build-Dienstkonto zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Speichern von Testlogs in Logging benötigen.

Um die Berechtigungen zu erhalten, die Sie für die Bereitstellung der Anwendung in Cloud Run benötigen, bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Cloud Run Developer (roles/run.developer) für Ihr Build-Dienstkonto zu gewähren.

Go-Builds konfigurieren

Das öffentliche golang-Image von Docker Hub unterstützt das Erstellen mithilfe von Go-Modulen. Wenn Sie dieses Image als Build-Schritt in Ihrer Cloud Build-Konfigurationsdatei verwenden, können Sie im Image go-Befehle aufrufen. Argumente, die an diesen Build-Schritt übergeben werden, werden direkt an das golang-Tool weitergegeben, sodass Sie in diesem Image alle go-Befehle ausführen können.

In diesem Abschnitt wird eine Beispieldatei für die Build-Konfiguration für eine Go-Anwendung aus dem Git-Repository cloud-build-samples gezeigt. Die Anwendung umfasst Build-Schritte, um die Anwendung zu erstellen, Unittests hinzuzufügen und die Anwendung nach dem Bestehen der Tests zu containerisieren und bereitzustellen.

So erstellen Sie die Beispiel-Go-Anwendung:

Erstellen und testen: Wenn Sie Unittests in Ihrer Anwendung definiert haben, können Sie Cloud Build so konfigurieren, dass die Tests ausgeführt werden. Fügen Sie dazu die folgenden Felder in einem Build-Schritt hinzu:
- name: Legen Sie den Wert dieses Felds auf golang fest, um das Golang-Image von Docker Hub für Ihre Aufgabe zu verwenden.
- entrypoint: Legen Sie den Wert dieses Felds auf /bin/bash fest. So können Sie mehrzeilige Bash-Befehle direkt aus dem Build-Schritt ausführen.
- args: Im Feld args eines Build-Schritts wird eine Liste von Argumenten abgerufen und an das Image übergeben, auf das im Feld name verwiesen wird. Im folgenden Beispiel verwendet das Feld args die Argumente für:
  - Ausführen des Testlog-Formatierers zum Herunterladen der Testlogausgabe.
  - Ausgeben der Logausgabe.
  - Speichern der Testergebnisse in sponge.log.
  - Ausgabe der Ergebnisse in sponge.log in eine JUnit-XML-Datei Der Name der JUnit-XML-Datei wird mit der kurzen Version der Commit-ID erstellt, die Ihrem Build zugeordnet ist. Bei einem nachfolgenden Build-Schritt werden die Logs in dieser Datei in Cloud Storage gespeichert.
```
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
```
Containerisieren der Anwendung: Nachdem Sie den Build-Schritt hinzugefügt haben, um sicherzustellen, dass die Tests bestanden haben, können Sie die Anwendung erstellen. Cloud Build bietet ein vordefiniertes Docker-Image, mit dem Sie Ihre Go-Anwendung containerisieren können. Fügen Sie in einem Build-Schritt die folgenden Felder hinzu, um Ihre Anwendung zu containerisieren:
- name: Legen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker fest, um das vordefinierte Docker-Image für Ihre Aufgabe zu verwenden.
- args: Fügen Sie die Argumente für den Befehl docker build als Werte für dieses Feld hinzu.
Mit dem folgenden Build-Schritt wird das Image myimage erstellt und mit der kurzen Version Ihrer Commit-ID getaggt. Der Build-Schritt verwendet Substitutionen für Projekt-ID, Repository-Name und kurze SHA-Werte. Daher werden diese Werte bei der Build-Erstellung automatisch ersetzt. Beachten Sie, dass Sie zum Speichern des Images ein Docker-Repository in Artifact Registry erstellen oder ein vorhandenes erstellen müssen.
```
# Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 
         'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', '.']
```
Container in Artifact Registry hochladen: Sie können den erstellten Container in Artifact Registry speichern. Dies ist ein Google Cloud- Dienst, mit dem Sie Build-Artefakte speichern, verwalten und sichern können. Dazu benötigen Sie ein vorhandenes Docker-Repository in Artifact Registry. Um Cloud Build so zu konfigurieren, dass das Image in einem Artifact Registry-Docker-Repository gespeichert wird, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:
- name: Legen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker fest, um das offizielle docker-Builder-Image für Ihre Aufgabe zu verwenden.
- args: Fügen Sie die Argumente für den Befehl docker push als Werte dieses Felds hinzu. Geben Sie für die Ziel-URL das Artifact Registry-Docker-Repository ein, in dem Sie das Image speichern möchten.
Mit dem folgenden Build-Schritt wird das Image, das Sie im vorherigen Schritt erstellt haben, per Push an Artifact Registry übertragen:
```
# 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']
```
Container in Cloud Run bereitstellen: Um das Image in Cloud Run bereitzustellen, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:
- name: Legen Sie den Wert dieses Felds auf google/cloud-sdk fest, um das gcloud CLI-Image zum Aufrufen des Befehls gcloud zu verwenden, damit das Image in Cloud Run bereitgestellt wird.
- args: Fügen Sie die Argumente für den Befehl gcloud run deploy als Werte dieses Felds hinzu.
Mit dem folgenden Build-Schritt wird das zuvor erstellte Image in Cloud Run bereitgestellt:
```
# 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']
```

Testlogs in Cloud Storage speichern: Sie können Cloud Build so konfigurieren, dass alle Testlogs in Cloud Storage gespeichert werden. Geben Sie dazu einen vorhandenen Bucket-Speicherort und einen Pfad zu den Testlogs an.

Mit dem folgenden Build-Schritt werden die Testlogs, die Sie in der JUNIT-XML-Datei gespeichert haben, in einem Cloud Storage-Bucket gespeichert:

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

Das folgende Snippet zeigt die vollständige Build-Konfigurationsdatei für alle vorherigen Schritte:

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

Starten Sie den Build mit der gcloud CLI oder erstellen Sie einen Build-Trigger:

Google Cloud CLI

Führen Sie den folgenden Befehl aus und geben Sie mit --substitutions die Ersetzungsvariablen an, die in cloudbuild.yaml verwendet werden:

gcloud builds submit --region=us-central1 --config=cloudbuild.yaml \
--default-buckets-behavior=REGIONAL_USER_OWNED_BUCKET \
--service-account= projects/PROJECT_ID/serviceAccounts/cloud-build-go@PROJECT_ID.iam.gserviceaccount.com \
--substitutions=_AR_REPO_NAME="_AR_REPO_NAME",_BUCKET_NAME="_BUCKET_NAME",SHORT_SHA="SHORT_SHA"

Ersetzen Sie dabei _AR_REPO_NAME durch den Namen Ihres Artifact Registry-Repositorys.

Ersetzen Sie _BUCKET_NAME durch den Namen Ihres Cloud Storage-Bucket für Testprotokolle.

Ersetzen Sie SHORT_SHA durch einen kurzen generischen Textstring wie „temp_fake_sha“, da bei der Ausführung mit der gcloud CLI kein Wert für SHORT_SHA angegeben wird.

Build-Trigger

Folgen Sie der Anleitung unter Build-Trigger erstellen. Geben Sie im Feld Substitution variables (Ersatzvariablen) auch den Namen Ihres Artifact Registry-Repositories und den Namen Ihres Cloud Storage-Bucket für Testprotokolle an.

Nächste Schritte

Anhand dieses Beispiels können Sie Ihre eigene Go-Anwendung erstellen, testen und bereitstellen.
Container-Images erstellen
Build-Fehler beheben