Environnement d'exécution Go

Cloud Functions accepte les environnements d'exécution Go suivants :

• Go 1.16 (recommandé)
• Go 1.13
• Go 1.11

Pour savoir comment préparer votre machine locale pour le développement Go, consultez la page Configurer votre environnement de développement.

Pour commencer à utiliser Go sur Cloud Functions, consultez le guide de démarrage rapide.

Remarque : Le seul type de fonctions basées sur les événements avec lesquelles Go est compatible sont les fonctions d'arrière-plan.

Sélectionner l'environnement d'exécution

Vous pouvez sélectionner l'environnement d'exécution Go pour votre fonction lors du déploiement.

gcloud

Si vous utilisez Google Cloud CLI, vous pouvez spécifier l'environnement d'exécution Go de votre choix à l'aide du paramètre --runtime. Les valeurs acceptées sont go111, go113 et go116. Exemple :

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

FLAGS... fait référence aux arguments transmis lors du premier déploiement de votre fonction. Pour en savoir plus sur les arguments obligatoires et facultatifs, consultez la section Déployer à l'aide de l'outil gcloud.

Console

Si vous utilisez Cloud Console, vous pouvez sélectionner l'environnement d'exécution lorsque vous créez et déployez une fonction. Consultez le guide de démarrage rapide de Cloud Console pour obtenir des instructions détaillées.

Environnement d'exécution

L'environnement d'exécution comprend l'exécution, le système d'exploitation, les packages et une bibliothèque appelant votre fonction.

Les environnements d'exécution Go 1.11.6, Go 1.13.15 et Go 1.16.7 utilisent un environnement d'exécution basé sur Ubuntu 18.04. Pour plus d'informations, consultez la section Environnements d'exécution.

Structure du code source

Pour que Cloud Functions trouve la définition de votre fonction, chaque environnement d'exécution a certaines exigences en matière de structuration pour votre code source. Pour en savoir plus, consultez la page Écrire des fonctions Cloud Functions.

Spécifier des dépendances

Cloud Functions dans Go doit fournir toutes ses dépendances via des modules Go avec un fichier go.mod ou un répertoire vendor. Pour plus d'informations, consultez la page Spécifier des dépendances en Go.

Environment variables

Les environnements d'exécution Go 1.13 et ultérieurs définissent automatiquement moins de variables d'environnement que les précédents environnements d'exécution compatibles avec Cloud Functions. Pour en savoir plus, consultez la page Utiliser des variables d'environnement.

Initialisation unique

Vos fonctions devront peut-être effectuer une initialisation unique, telle que la création de clients API et la configuration de l'accès à la base de données. Vous disposez pour cela de plusieurs méthodes :

• Utilisez une fonction func init() pour initialiser les valeurs lorsqu'une nouvelle instance de votre fonction démarre. Notez que le code de la fonction func init() s'exécute avant que celle-ci ne reçoive sa première requête.

• Utilisez la fonction sync.Once.Do() pour exécuter le code une fois par instance de Cloud Functions. Cette opération est utile dans les cas où vous souhaitez uniquement initialiser à la demande plutôt que lorsque votre instance de fonction démarre pour la première fois. Par exemple, il se peut que vous n'ayez besoin d'initialiser un client de base de données que dans certaines circonstances.

context.Context

Le package context de Go définit le type de Context, qui contient des échéances, des signaux d'annulation et d'autres valeurs couvertes par les requêtes au-delà des limites de l'API et entre les processus.

Les clients API qui survivent à un appel de fonction donné doivent être initialisés avec une valeur de context.Context globale, telle que celle créée par la fonction context.Background(). Pour optimiser les performances, vous pouvez initialiser un client dans un champ d'application global. Ce client et son contexte peuvent persister tout au long de la vie d'une instance de fonction donnée.

Vous ne devez utiliser le contexte d'appel de fonction que pour les objets ou les opérations relevant de la durée de vie d'un appel de fonction spécifique. Le contexte d'appel peut être annulé à tout moment après l'exécution de votre fonction, ce qui signifie que tous les clients initialisés à l'aide de ce contexte peuvent être fermés. Le contexte d'appel de la fonction est accessible via les arguments de la fonction : généralement r.Context() pour les fonctions HTTP et ctx pour les fonctions d'arrière-plan.

Référez-vous au code suivant pour obtenir un exemple utilisant un client Pub/Sub :

functions/tips/contexttip/context_tip.go

Afficher sur GitHub Commentaires

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

Go 1.16 introduit des modifications dans la gestion des dépendances. Plus précisément, il fonctionne désormais par défaut en mode "compatible avec les modules", ce qui signifie que le code source doit inclure un fichier go.mod. Les notes de version complètes sont disponibles sur golang.org.

Pour prendre en charge les déploiements existants dans des versions antérieures à la version 1.16 et faciliter le chemin de migration :

• Les fonctions sans go.mod continueront d'être prises en charge.
• Les fonctions avec vendor et sans go.mod fonctionnent comme auparavant pour les versions antérieures à la version 1.16. Cloud Functions ajoute le framework des fonctions s'il ne se trouve pas dans vendor.
• Les fonctions associées à vendor et go.mod sont compatibles avec Go 1.14 et versions ultérieures. En outre, elles doivent disposer du framework des fonctions dans go.mod/vendor. Dans le cas contraire, la compilation échoue et renvoie l'erreur suivante :

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"`

Découvrez comment utiliser le répertoire vendor pour votre version de Go spécifique.