Go-Laufzeit

Cloud Functions unterstützt diese Go-Laufzeiten:

  • Go 1.16 (Vorschau)
  • Go 1.13 (empfohlen)
  • Go 1.11

Informationen zur Vorbereitung eines lokalen Computers für die Entwicklung mit Go finden Sie unter Go-Entwicklungsumgebung einrichten.

Informationen zu den ersten Schritten mit Go in Cloud Functions finden Sie in der Kurzanleitung.

Laufzeit auswählen

Sie können die Go-Laufzeit für Ihre Funktion während der Bereitstellung auswählen.

gcloud

Wenn Sie das gcloud-Befehlszeilentool verwenden, können Sie mit dem Parameter --runtime die gewünschte Go-Laufzeit angeben (unterstützte Werte sind go111, go113 und go116). Beispiel:

gcloud functions deploy FUNCTION_NAME --runtime go113 FLAGS...

FLAGS... bezieht sich auf Argumente, die bei der erstmaligen Bereitstellung der Funktion übergeben wurden. Weitere Informationen zu erforderlichen und optionalen Argumenten finden Sie unter gcloud-Tool zum Bereitstellen verwenden.

Console

Wenn Sie die Cloud Console verwenden, können Sie beim Erstellen und Bereitstellen einer Funktion die Laufzeit auswählen. Eine ausführliche Anleitung finden Sie in der Cloud Console-Kurzanleitung.

Ausführungsumgebung

Die Ausführungsumgebung enthält die Laufzeit, das Betriebssystem, Pakete und eine Bibliothek, die Ihre Funktion aufruft.

Die Laufzeiten Go 1.11.6, Go 1.13.15 und Go 1.16.7 verwenden eine auf Ubuntu 18.04 basierende Ausführungsumgebung. Weitere Informationen finden Sie unter Ausführungsumgebung von Cloud Functions.

Struktur des Quellcodes

Damit Cloud Functions die Definition Ihrer Funktion findet, hat jede Laufzeit bestimmte Strukturanforderungen für Ihren Quellcode. Weitere Informationen finden Sie unter Cloud Functions-Funktionen schreiben.

Abhängigkeiten angeben

Alle Abhängigkeiten von Cloud Functions in Go müssen über Go-Module mit einer go.mod-Datei oder über ein vendor-Verzeichnis bereitgestellt werden. Weitere Informationen finden Sie unter Abhängigkeiten in Go angeben.

Einmalige Initialisierung

Ihre Funktionen müssen möglicherweise eine einmalige Initialisierung durchlaufen, z. B. zum Erstellen von API-Clients und zum Konfigurieren des Datenbankzugriffs. Dazu haben Sie verschiedene Möglichkeiten:

  • Verwenden Sie die Funktion func init() zum Initialisieren von Werten, wenn eine neue Instanz der Funktion gestartet wird. Der Code in der Funktion func init() wird ausgeführt, bevor die Funktion die erste Anfrage erhält.

  • Verwenden Sie die Funktion sync.Once.Do(), um Code einmal pro Cloud Functions-Instanz auszuführen. Dies ist nützlich, wenn die Initialisierung nur bei Bedarf ausgeführt werden soll und nicht beim ersten Start Ihrer Funktionsinstanz. Sie müssen zum Beispiel einen Datenbankclient nur unter bestimmten Umständen initialisieren.

context.Context

Mit dem context-Paket von Go wird der Context-Typ definiert, der Fristen, Abbruchsignale und andere auf Anfragen bezogene Werte über API-Grenzen hinweg und zwischen Prozessen überträgt.

API-Clients, die einen bestimmten Funktionsaufruf überdauern, sollten mit einem globalen context.Context-Wert initialisiert werden, z. B. einem, der mit der Funktion context.Background() erstellt wurde. Zur Leistungsoptimierung können Sie einen Client im globalen Bereich initialisieren. Dieser Client und sein Kontext bleiben möglicherweise für die gesamte Lebensdauer einer Funktionsinstanz bestehen.

Sie sollten den Kontext des Funktionsaufrufs nur für Objekte oder Vorgänge einsetzen, die in die Lebensdauer eines bestimmten Funktionsaufrufs fallen. Der Aufrufkontext kann zu einem beliebigen Zeitpunkt nach dem Ende der Funktionsausführung abgebrochen werden. Das bedeutet, dass alle initialisierten Clients, die diesen Kontext verwenden, geschlossen werden können. Der Kontext des Funktionsaufrufs kann über die Argumente der Funktion aufgerufen werden: normalerweise ist dies r.Context() für HTTP-Funktionen und ctx für Hintergrundfunktionen.

Im folgenden Codebeispiel wird ein Pub/Sub-Client verwendet:


// Package contexttip is an example of how to use Pub/Sub and context.Context in
// a Cloud Function.
package contexttip

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"

	"cloud.google.com/go/pubsub"
)

// GOOGLE_CLOUD_PROJECT is a user-set environment variable.
var projectID = os.Getenv("GOOGLE_CLOUD_PROJECT")

// client is a global Pub/Sub client, initialized once per instance.
var client *pubsub.Client

func init() {
	// err is pre-declared to avoid shadowing client.
	var err error

	// client is initialized with context.Background() because it should
	// persist between function invocations.
	client, err = pubsub.NewClient(context.Background(), projectID)
	if err != nil {
		log.Fatalf("pubsub.NewClient: %v", err)
	}
}

type publishRequest struct {
	Topic   string `json:"topic"`
	Message string `json:"message"`
}

// PublishMessage publishes a message to Pub/Sub. PublishMessage only works
// with topics that already exist.
func PublishMessage(w http.ResponseWriter, r *http.Request) {
	// Parse the request body to get the topic name and message.
	p := publishRequest{}

	if err := json.NewDecoder(r.Body).Decode(&p); err != nil {
		log.Printf("json.NewDecoder: %v", err)
		http.Error(w, "Error parsing request", http.StatusBadRequest)
		return
	}

	if p.Topic == "" || p.Message == "" {
		s := "missing 'topic' or 'message' parameter"
		log.Println(s)
		http.Error(w, s, http.StatusBadRequest)
		return
	}

	m := &pubsub.Message{
		Data: []byte(p.Message),
	}
	// Publish and Get use r.Context() because they are only needed for this
	// function invocation. If this were a background function, they would use
	// the ctx passed as an argument.
	id, err := client.Topic(p.Topic).Publish(r.Context(), m).Get(r.Context())
	if err != nil {
		log.Printf("topic(%s).Publish.Get: %v", p.Topic, err)
		http.Error(w, "Error publishing message", http.StatusInternalServerError)
		return
	}
	fmt.Fprintf(w, "Message published: %v", id)
}

Go 1.16 (öffentliche Vorschau)

Go 1.16 führt Änderungen im Abhängigkeitsmanagement ein. Der wichtigste Modus ist jetzt der modulbasierte Modus. Das heißt, der Quellcode muss eine go.mod-Datei enthalten. Die vollständigen Versionshinweise finden Sie unter golang.org.

So unterstützen Sie vorhandene Bereitstellungen in Versionen älter als 1.16 und vereinfachen den Migrationspfad:

  • Funktionen ohne go.mod werden weiterhin unterstützt.
  • Funktionen mit vendor und ohne go.mod funktionieren wie zuvor für Versionen vor 1.16. Cloud Functions fügt das Functions Framework hinzu, wenn es sich nicht in vendor befindet.
  • Funktionen mit vendor und go.mod werden für Go 1.14 und höher unterstützt, müssen aber das Functions Framework in go.mod/vendor haben. Andernfalls schlägt der Build mit folgendem Fehler fehl:
vendored dependencies must include "github.com/GoogleCloudPlatform/functions-framework-go";
if your function does not depend on the module, please add a blank import:
`_ "github.com/GoogleCloudPlatform/functions-framework-go"`

Weitere Informationen zur Verwendung des Verzeichnisses vendor für Ihre jeweilige Go-Version.