Go-Anwendungen erstellen

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

Hinweis

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

Cloud Build, Cloud Run, and Artifact Registry APIs aktivieren.
Aktivieren Sie die APIs
Installieren Sie die Google Cloud-Befehlszeile, um die gcloud-Befehle auf dieser Seite auszuführen.
Halten Sie Ihr Go-Projekt bereit.
Wenn Sie Ihre Go-Anwendung mit Cloud Build containerisieren möchten, benötigen Sie ein Dockerfile zusammen mit Ihrem Quellcode.
Wenn Sie den erstellten Container in Artifact Registry speichern möchten, erstellen Sie ein Docker-Repository in Artifact Registry.
Wenn Sie Testlogs in Cloud Storage speichern möchten, erstellen Sie einen Bucket in Cloud Storage.

Erforderliche IAM-Berechtigungen

Weisen Sie zum Speichern von Testlogs in Logging dem Cloud Build-Dienstkonto die Rolle Storage-Objekt-Ersteller (roles/storage.objectCreator) für den Cloud Storage-Bucket zu.
Zum Speichern erstellter Images in Artifact Registry weisen Sie dem Cloud Build-Dienstkonto die Rolle Artifact Registry-Autor (roles/artifactregistry.writer) zu.

Eine Anleitung zum Zuweisen dieser Rollen finden Sie unter Rolle über die IAM-Seite zuweisen.

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.

Dieser Abschnitt enthält eine Beispiel-Build-Konfigurationsdatei für eine Go-Anwendung. 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 eine Go-Anwendung:

Erstellen Sie im Stammverzeichnis des Projekts eine Build-Konfigurationsdatei mit dem Namen cloudbuild.yaml.
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. Auf diese Weise 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.
  Auf GitHub ansehen
```
steps:
  # Run tests and save to file
  - name: golang:1.17
    entrypoint: /bin/bash
    args:
      - -c
      - |
        go get -u github.com/jstemmer/go-junit-report
        2>&1 go test -timeout 1m -v ./... | tee sponge.log
        /go/bin/go-junit-report -set-exit-code < sponge.log > ${SHORT_SHA}_test_log.xml
```
Containerisieren dere 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 aus Container Registry 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.

Auf GitHub ansehen
```
# Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t',
         'us-central1-docker.pkg.dev/$PROJECT_ID/$_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:

Auf GitHub ansehen
```
# 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']
```
Container in Cloud Run bereitstellen: Um das Image in Cloud Run bereitzustellen, fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu:
- name: Setzen Sie den Wert dieses Feldes auf google/cloud-sdk, damit das Image der gcloud-Befehlszeile den Befehl gcloud aufruft, um das Image in Cloud Run bereitzustellen.
- 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:

Auf GitHub ansehen
```
# 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']
```

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:

Auf GitHub ansehen

# 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 oben beschriebenen Schritte:

Auf GitHub ansehen

steps:
  # Run tests and save to file
  - name: golang:1.17
    entrypoint: /bin/bash
    args:
      - -c
      - |
        go get -u github.com/jstemmer/go-junit-report
        2>&1 go test -timeout 1m -v ./... | tee sponge.log
        /go/bin/go-junit-report -set-exit-code < sponge.log > ${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

Starten Sie den Build mit der gcloud-Befehlszeile oder Build-Triggern. Sie müssen den Namen des Artifact Registry-Repositorys beim Starten des Builds angeben.

So geben Sie das Artifact Registry-Repository beim Start des Builds mit der gcloud-Befehlszeile an:
```
gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_REPO_NAME="REPO_NAME"
```
Ersetzen Sie dabei REPO_NAME durch den Namen Ihres Artifact Registry-Repositorys.

Wenn Sie beim Erstellen mit Build-Triggern das Artifact Registry-Repository angeben möchten, geben Sie beim Erstellen des Build-Triggers den Namen des Artifact Registry-Repositorys im Feld Substitutionsvariablen an.

Go-Anwendungen erstellen

Hinweis

Erforderliche IAM-Berechtigungen

Go-Builds konfigurieren

Weitere Informationen