Cloud Functions wurde in Cloud Run-Funktionen umbenannt. Weitere Informationen finden Sie im Blogpost zu Cloud Run-Funktionen.

Diese Seite wurde von der Cloud Translation API übersetzt.

HTTP-Cloud Run-Funktion mit Go erstellen und bereitstellen

Einleitung

In diesem Leitfaden wird der Schreibvorgang für eine Cloud Run Functions-Funktion mit der Go-Laufzeit beschrieben. Es gibt zwei Arten von Cloud Run-Funktionen:

Eine HTTP-Funktion, die Sie über Standard-HTTP-Anfragen aufrufen.
Eine ereignisgesteuerte Funktion, die durch Ereignisse in Ihrer Cloud-Infrastruktur ausgelöst wird, z. B. Nachrichten in einem Pub/Sub-Thema oder Änderungen in einem Cloud Storage-Bucket.

Weitere Informationen finden Sie unter HTTP-Funktionen schreiben und Ereignisgesteuerte Funktionen schreiben.

Hinweise

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Functions, Cloud Build, Artifact Registry, Cloud Run, and Cloud Logging APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Functions, Cloud Build, Artifact Registry, Cloud Run, and Cloud Logging APIs.

Enable the APIs

Installieren und initialisieren Sie die gcloud CLI.

Aktualisieren und installieren Sie gcloud-Komponenten mit dem folgenden Befehl.
```
gcloud components update
```
Bereiten Sie die Entwicklungsumgebung vor.

Zum Einrichtungsleitfaden für Go

Funktion erstellen

Erstellen Sie in Ihrem lokalen System ein Verzeichnis für den Funktionscode:
Linux oder MacOS X
```
mkdir ~/helloworld
cd ~/helloworld
```
Windows
```
mkdir %HOMEPATH%\helloworld
cd %HOMEPATH%\helloworld
```

Erstellen Sie eine hello_http.go-Datei im Verzeichnis helloworld mit folgendem Inhalt:


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"encoding/json"
	"fmt"
	"html"
	"net/http"

	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

func init() {
	functions.HTTP("HelloHTTP", HelloHTTP)
}

// HelloHTTP is an HTTP Cloud Function with a request parameter.
func HelloHTTP(w http.ResponseWriter, r *http.Request) {
	var d struct {
		Name string `json:"name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&d); err != nil {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	if d.Name == "" {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	fmt.Fprintf(w, "Hello, %s!", html.EscapeString(d.Name))
}

Diese Beispielfunktion verwendet einen in der HTTP-Anfrage angegebenen Namen und gibt eine Begrüßung oder, wenn kein Name angegeben wird, "Hello World!" zurück.

Abhängigkeiten angeben

Erstellen Sie eine go.mod-Datei, um Ihre Abhängigkeiten zu verfolgen:

cd ~/helloworld
go mod init example.com/hello
go mod tidy

Wenn Ihre Funktion Abhängigkeiten außerhalb der Functions Framework-Bibliothek hat, bearbeiten Sie die go.mod-Datei, um sie hinzuzufügen. Sie können Abhängigkeiten auch mit einem Go-vendor-Verzeichnis angeben. Weitere Informationen finden Sie unter Abhängigkeiten in Go angeben.

Funktion lokal erstellen und testen

Sie können Ihre Funktion lokal erstellen und testen, ohne sie bereitzustellen. Dazu müssen Sie ein lokales main.go-Modul erstellen, um Ihre Funktion aufzurufen.

Erstellen Sie ein cmd-Unterverzeichnis:

mkdir ~/helloworld/cmd
cd ~/helloworld/cmd

Erstellen Sie ein Haupt-Go-Modul, um Ihre Funktion aufzurufen. Kopieren Sie dazu das folgende Code-Snippet in eine Datei mit dem Namen main.go in das Verzeichnis ~/helloworld/cmd:

package main

import (
  "log"
  "os"

  // Blank-import the function package so the init() runs
  _ "example.com/hello"
  "github.com/GoogleCloudPlatform/functions-framework-go/funcframework"
)

func main() {
  // Use PORT environment variable, or default to 8080.
  port := "8080"
  if envPort := os.Getenv("PORT"); envPort != "" {
    port = envPort
  }
  if err := funcframework.Start(port); err != nil {
    log.Fatalf("funcframework.Start: %v\n", err)
  }
}

Lösen Sie die verbleibenden Abhängigkeiten mit dem Befehl go mod tidy auf:
```
go mod tidy
```

Führen Sie die Funktion mit dem folgenden Befehl lokal aus:

export FUNCTION_TARGET=HelloHTTP
go run ~/helloworld/cmd/main.go

Testen Sie Ihre Funktion. Rufen Sie dazu http://localhost:8080 in einem Browser auf oder führen Sie curl localhost:8080 in einem anderen Fenster aus.

Weitere Informationen finden Sie unter Anfragen an lokale Funktionen senden.

Funktion bereitstellen

Führen Sie den Befehl im Verzeichnis helloworld aus, um die Funktion bereitzustellen:

  gcloud functions deploy go-http-function \
    --gen2 \
    --runtime=go122 \
    --region=REGION \
    --source=. \
    --entry-point=HelloHTTP \
    --trigger-http \
    --allow-unauthenticated

Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitstellen möchten (z. B. us-west1).

Mit dem optionalen Flag --allow-unauthenticated können Sie die Funktion ohne Authentifizierung aufrufen.

Bereitgestellte Funktion testen

Beachten Sie nach dem Bereitstellen der Funktion das Attribut uri in der Ausgabe des Befehls gcloud functions deploy oder rufen Sie es mit dem folgenden Befehl ab:
```
  gcloud functions describe go-http-function \
    --region=REGION
```
Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitgestellt haben (z. B. us-west1).
Rufen Sie diese URL in Ihrem Browser auf: Die Funktion gibt die Nachricht „Hello World!“ zurück.

Sie finden diese URL auch in der Google Cloud Console. Rufen Sie die Übersichtsseite zu Cloud Run Functions auf und klicken Sie auf den Namen der Funktion, um die Seite Funktionsdetails zu öffnen. Öffnen Sie den Tab TRIGGER, um die URL Ihrer Funktion zu sehen.

Logs der Funktion ansehen

Logs mit dem Befehlszeilentool ansehen

Sie können die Logs Ihrer Funktion über die Cloud Logging-UI oder die Google Cloud CLI prüfen.

Wenn Sie mit der gcloud CLI Logs für Ihre Funktion aufrufen möchten, verwenden Sie den Befehl logs read:

    gcloud functions logs read \
      --gen2 \
      --limit=10 \
      --region=REGION \
      go-http-function

Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitgestellt haben (z. B. us-west1).

Die Ausgabe sollte in etwa so aussehen:

LEVEL: I
NAME: hellohttp
TIME_UTC: 2023-05-31 21:52:20.473
LOG:

LEVEL: I
NAME: hellohttp
TIME_UTC: 2023-05-31 21:52:20.370
LOG:

LEVEL: I
NAME: hellohttp
TIME_UTC: 2023-05-31 21:52:20.280
LOG: Default STARTUP TCP probe succeeded after 1 attempt for container "h-hello_h_t_t_p-1" on port 8080.

LEVEL: I
NAME: hellohttp
TIME_UTC: 2023-05-31 21:52:20.108
LOG:

Logs mit dem Logging-Dashboard ansehen

Um die Logs für Ihre Funktion mit dem Logging-Dashboard aufzurufen, öffnen Sie die Übersichtsseite zu Cloud Run Functions. Klicken Sie in der Liste auf den Namen Ihrer Funktion und dann auf den Tab Logs.