Go-Anwendungen erstellen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

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 CLI, 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

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:

  1. Erstellen Sie im Stammverzeichnis des Projekts eine Build-Konfigurationsdatei mit dem Namen cloudbuild.yaml.

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

    # Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t',
         'us-central1-docker.pkg.dev/$PROJECT_ID/$_REPO_NAME/myimage:$SHORT_SHA', '.']

  4. 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/$_REPO_NAME/myimage:$SHORT_SHA']

  5. 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, um mit dem gcloud-CLI-Image den Befehl gcloud zum Bereitstellen des Images in Cloud Run aufzurufen.
    • 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/$_REPO_NAME/myimage:$SHORT_SHA',
         '--region', 'us-central1', '--platform', 'managed']

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

    steps:
  # Run tests and save to file
  - name: golang:1.19
    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. Starten Sie den Build mit der gcloud-CLI oder mit 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 CLI 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 Ersetzungsvariablen an.

Nächste Schritte