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

Bei den Anleitungen auf dieser Seite wird davon ausgegangen, 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 mithilfe von Cloud Build containerisieren möchten, benötigen Sie zusammen mit Ihrem Quellcode ein Dockerfile.
• 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

• Um Testlogs in Logging zu speichern, weisen Sie dem Cloud Build-Dienstkonto die Rolle Storage-Objekt-Ersteller (roles/storage.objectCreator) für den Cloud Storage-Bucket zu.

• Um gespeicherte Images in Artifact Registry zu speichern, weisen Sie dem Cloud Build-Dienstkonto die Rolle ArtifactArtifact Registry-Autor“ (roles/artifactregistry.writer) zu.

Eine Anleitung zum Zuweisen dieser Rollen finden Sie unter Rolle mit der IAM-Seite zuweisen.

Go-Builds konfigurieren

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

In diesem Abschnitt wird eine beispielhafte Build-Konfigurationsdatei für eine Go-Anwendung beschrieben. Er enthält Build-Schritte zum Erstellen der Anwendung, Hinzufügen von Einheitentests und nachdem die Tests die Anwendung bestanden, containerisiert und bereitgestellt haben.

So erstellen Sie eine Go-Anwendung:

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

2. Erstellen und testen: Wenn Sie Einheitentests 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: Setzen Sie den Wert dieses Felds auf golang, 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.
     • Logausgabe drucken
     • Die Testergebnisse werden in sponge.log gespeichert.
     • 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

3. 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', '.']

4. 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: Setzen Sie den Wert dieses Felds auf gcr.io/cloud-builders/docker, um das offizielle docker-Builder-Image für die Aufgabe aus Container Registry 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 im vorherigen Schritt erstellte Image in Artifact Registry verschoben:

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

5. Container in Cloud Run bereitstellen: Fügen Sie einen Build-Schritt mit den folgenden Feldern hinzu, um das Image in Cloud Run bereitzustellen:

   • name: Setzen Sie den Wert dieses Felds auf google/cloud-sdk, um das Cloud SDK-Image zu verwenden, um 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:

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

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

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

   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

7. Starten Sie den Build mit dem gcloud-Tool oder Build-Trigger. Beim Starten des Builds müssen Sie den Namen des Artifact Registry-Repositorys 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.

   Um das Artifact Registry-Repository beim Erstellen mit Build-Triggern anzugeben, geben Sie den Namen Ihres Artifact Registry-Repositorys im Feld Substitutionsvariablen an, wenn Sie den Build-Trigger erstellen

Nächste Schritte

• Container-Images erstellen
• Build-Fehler beheben