Diese Seite wurde von der Cloud Translation API übersetzt.

Go-Anwendungen erstellen

Auf dieser Seite wird erläutert, wie Sie mit Cloud Build Go-Anwendungen erstellen, testen und bereitstellen. Wenn Sie Cloud Build noch nicht kennen, lesen Sie zuerst die Kurzanleitungen sowie die Übersicht über die Build-Konfiguration.

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 das Cloud SDK, 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: Setzen Sie den Wert dieses Feldes auf /bin/bash. So können Sie mehrzeilige Bash-Befehle direkt im Build-Schritt ausführen.
- args: Das Feld args eines Build-Schritts verwendet eine Liste von Argumenten und übergibt sie an das Image, auf das das Feld name verweist. Im folgenden Beispiel verwendet das Feld args die Argumente für:
  - Testformat-Formatierer ausführen, um die Testlogausgabe herunterzuladen.
  - 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 mithilfe der Kurzversion 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
    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
```
Anwendung containerisieren: Nachdem Sie den Build-Schritt hinzugefügt haben, um zu gewährleisten, dass die Tests bestanden wurden, können Sie die Anwendung erstellen. Cloud Build bietet ein vordefiniertes Docker-Image, das Sie zum Containerisieren Ihrer Go-Anwendung verwenden können. Fügen Sie in einem Build-Schritt die folgenden Felder hinzu, um die Anwendung zu containerisieren:
- name: Setzen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker, 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 Kurzversion Ihrer Commit-ID getaggt. Der Build-Schritt verwendet Substitutionen für die Projekt-ID, den Repository-Namen und die kurzen SHA-Werte. Daher werden diese Werte zum Zeitpunkt der Erstellung automatisch ersetzt. Beachten Sie, dass Sie zum Speichern des Images ein Docker-Repository in Artifact Registry erstellen müssen oder ein vorhandenes haben muss.

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 an Artifact Registry übertragen: Sie können den erstellten Container in Artifact Registry speichern, einem 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. Wenn Sie Cloud Build zum Speichern des Images in einem Artifact Registry-Docker-Repository konfigurieren möchten, 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: Legen Sie den Wert dieses Felds auf google/cloud-sdk fest, um das Cloud SDK-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:

Auf GitHub ansehen
```
# Deploy to Cloud Run
- name: 'gcr.io/cloud-builders/gcloud'
  args: ['run', 'deploy', 'helloworld',
         '--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
    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',
           '--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 dem gcloud-Tool oder den Build-Triggern. Sie müssen den Namen des Artifact Registry-Repositorys beim Starten des Builds angeben.

So geben Sie das Artifact Registry-Repository beim Starten des Builds mit dem gcloud-Tool an:
```
gcloud builds submit --config=cloudbuild.yaml \
    --substitutions=_REPO_NAME="REPO_NAME"
```
Ersetzen Sie REPO_NAME durch den Namen des Artifact Registry-Repositorys.

Wenn Sie das Artifact Registry-Repositorys beim Erstellen mit Build-Triggern angeben möchten, geben Sie dessen Namen im Feld Substitutionsvariablen an, wenn Sie den Build-Trigger erstellen.

Go-Anwendungen erstellen

Hinweis

Erforderliche IAM-Berechtigungen

Go-Builds konfigurieren

Nächste Schritte