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

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.
      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.

    # 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:

    # 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:

    # 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:

    # 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
        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