Environnement d'exécution Go

L'environnement d'exécution Go de Cloud Functions est basé sur la version 1.11.6 de Go. 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.

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 l'outil de ligne de commande gcloud, vous pouvez spécifier l'environnement d'exécution à l'aide du paramètre --runtime. Exemple :

gcloud functions deploy FUNCTION_NAME --runtime go111 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 la console GCP, vous pouvez sélectionner l'environnement d'exécution lorsque vous créez et déployez une fonction.

  1. Dans la console GCP, accédez à la page "Présentation" de Cloud Functions.

    Accéder à la page Présentation de Cloud Functions

    Vérifiez que le projet pour lequel vous avez activé Cloud Functions est sélectionné.

  2. Cliquez sur Créer une fonction.

  3. Sous Environnement d'exécution, sélectionnez Go 1.11.

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.

Go utilise un environnement d'exécution basé sur Ubuntu 18.04 avec Go version 1.11.6. 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 section É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.

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 Cloud Pub/Sub :

functions/tips/contexttip/context_tip.go

// 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"
	"io/ioutil"
	"log"
	"net/http"
	"os"

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

// projectID is set from the GCP_PROJECT environment variable, which is
// automatically set by the Cloud Functions runtime.
var projectID = os.Getenv("GCP_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"`
}

// PublishMessage publishes a message to Pub/Sub. PublishMessage only works
// with topics that already exist.
func PublishMessage(w http.ResponseWriter, r *http.Request) {
	// Read the request body.
	data, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Printf("ioutil.ReadAll: %v", err)
		http.Error(w, "Error reading request", http.StatusBadRequest)
		return
	}

	// Parse the request body to get the topic name.
	p := publishRequest{}
	if err := json.Unmarshal(data, &p); err != nil {
		log.Printf("json.Unmarshal: %v", err)
		http.Error(w, "Error parsing request", http.StatusBadRequest)
		return
	}

	m := &pubsub.Message{
		Data: []byte("Test 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, "Published msg: %v", id)
}