Fonctions handler Go | Function Compute - Function Compute - Centre de documentation Alibaba Cloud

Définissez une fonction handler en Go, compilez-la en binaire, puis renseignez le paramètre Handler dans la console Function Compute avec le nom de ce binaire. Function Compute exécute ce handler lors de chaque invocation.

Remarque

Pour accéder aux fonctions via des déclencheurs HTTP ou des noms de domaine personnalisés, récupérez la structure de requête avant de définir les réponses HTTP. Pour plus d'informations, consultez Utiliser un déclencheur HTTP pour appeler une fonction.

Prise en main rapide

Importez le package SDK github.com/aliyun/fc-runtime-go-sdk/fc, implémentez une fonction handler et transmettez-la à fc.Start dans main().

package main

import (
    "fmt"
    "context"

    "github.com/aliyun/fc-runtime-go-sdk/fc"
)

type StructEvent struct {
    Key string `json:"key"`
}

func HandleRequest(ctx context.Context, event StructEvent) (string, error) {
    return fmt.Sprintf("hello, %s!", event.Key), nil
}

func main() {
    fc.Start(HandleRequest)
}

Ce handler accepte un événement JSON contenant un champ key et retourne une chaîne de salutation :

{
  "key": "value"
}

Analyse du code

Élément	Rôle
`package main`	Package d'entrée obligatoire pour tout exécutable Go
`github.com/aliyun/fc-runtime-go-sdk/fc`	SDK Go pour Function Compute
`context`	Fournit le contexte d'exécution lors de l'invocation de la fonction
`HandleRequest(ctx context.Context, event StructEvent) (string, error)`	Fonction handler : reçoit un contexte et un événement typé, puis retourne une chaîne et une erreur
`fc.Start(HandleRequest)`	Enregistre le handler auprès de Function Compute et lance la boucle du runtime

Pour en savoir plus sur l'objet Context et la Gestion des erreurs.

Compilation et déploiement

Initialisez un module Go et installez le SDK Function Compute :

go mod init my-fc-function
go get github.com/aliyun/fc-runtime-go-sdk

Compilez votre handler en un binaire Linux (Function Compute s'exécute sous Linux) :

CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o main main.go

Dans la console Function Compute, attribuez au paramètre Handler la valeur main (nom du binaire compilé). Consultez Créer une fonction événementielle.

Signatures des handlers

Règles applicables aux handlers :

Le handler doit être une fonction.
Il accepte entre 0 et 2 paramètres d'entrée. Si deux paramètres sont présents, le premier doit être de type context.Context.
Il retourne entre 0 et 2 valeurs. Une valeur de retour unique doit être de type error. En cas de deux valeurs retournées, la seconde doit impérativement être de type error.

Signatures valides :

func ()
func () error
func (InputType) error
func () (OutputType, error)
func (InputType) (OutputType, error)
func (context.Context) error
func (context.Context, InputType) error
func (context.Context) (OutputType, error)
func (context.Context, InputType) (OutputType, error)

Les types InputType et OutputType doivent être compatibles avec encoding/json. Function Compute utilise json.Unmarshal pour les entrées et json.Marshal pour les sorties. Reportez-vous à JSON Unmarshal.

Types d'événements d'entrée

Sélectionnez le type d'événement adapté à votre cas d'usage :

Type d'événement	Cas d'usage	Exemple
Struct	Événements fortement typés avec des champs connus	event-struct.go
`string`	Entrée brute sous forme de chaîne	event-string.go
`map[string]interface{}`	Événements dynamiques ou faiblement typés	event-map.go

D'autres exemples sont disponibles dans le dépôt fc-runtime-go-sdk/examples.

Handlers de déclencheurs HTTP

Pour traiter les requêtes HTTP provenant d'un déclencheur HTTP ou d'un domaine personnalisé, utilisez les structures HTTPTriggerEvent et HTTPTriggerResponse du package SDK events.

Traitement des événements de déclencheur HTTP

package main

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

	"github.com/aliyun/fc-runtime-go-sdk/events"
	"github.com/aliyun/fc-runtime-go-sdk/fc"
)

type HTTPTriggerEvent events.HTTPTriggerEvent
type HTTPTriggerResponse events.HTTPTriggerResponse

func (h HTTPTriggerEvent) String() string {
	jsonBytes, err := json.MarshalIndent(h, "", "  ")
	if err != nil {
		return ""
	}
	return string(jsonBytes)
}

func NewHTTPTriggerResponse(statusCode int) *HTTPTriggerResponse {
	return &HTTPTriggerResponse{StatusCode: statusCode}
}

func (h *HTTPTriggerResponse) String() string {
	jsonBytes, err := json.MarshalIndent(h, "", "  ")
	if err != nil {
		return ""
	}
	return string(jsonBytes)
}

func (h *HTTPTriggerResponse) WithStatusCode(statusCode int) *HTTPTriggerResponse {
	h.StatusCode = statusCode
	return h
}

func (h *HTTPTriggerResponse) WithHeaders(headers map[string]string) *HTTPTriggerResponse {
	h.Headers = headers
	return h
}

func (h *HTTPTriggerResponse) WithIsBase64Encoded(isBase64Encoded bool) *HTTPTriggerResponse {
	h.IsBase64Encoded = isBase64Encoded
	return h
}

func (h *HTTPTriggerResponse) WithBody(body string) *HTTPTriggerResponse {
	h.Body = body
	return h
}

func HandleRequest(event HTTPTriggerEvent) (*HTTPTriggerResponse, error) {
	fmt.Printf("event: %v\n", event)
	if event.Body == nil {
		return NewHTTPTriggerResponse(http.StatusBadRequest).
			WithBody(fmt.Sprintf("the request did not come from an HTTP Trigger, event: %v", event)), nil
	}

	reqBody := *event.Body
	if event.IsBase64Encoded != nil && *event.IsBase64Encoded {
		decodedByte, err := base64.StdEncoding.DecodeString(*event.Body)
		if err != nil {
			return NewHTTPTriggerResponse(http.StatusBadRequest).
				WithBody(fmt.Sprintf("HTTP Trigger body is not base64 encoded, err: %v", err)), nil
		}
		reqBody = string(decodedByte)
	}
	return NewHTTPTriggerResponse(http.StatusOK).WithBody(reqBody), nil
}

func main() {
	fc.Start(HandleRequest)
}

Ce handler lit le corps de la requête depuis HTTPTriggerEvent, le décode en Base64 si nécessaire, puis le renvoie tel quel. Les structures proviennent du package github.com/aliyun/fc-runtime-go-sdk/events. Voir aussi Utiliser un déclencheur HTTP pour appeler une fonction.

Appel de la fonction

Prérequis

Assurez-vous de disposer des éléments suivants :

Une fonction créée avec le runtime Go et intégrant le code handler ci-dessus
Un déclencheur HTTP configuré pour cette fonction

Créer une fonction événementielle | Configurer un déclencheur HTTP

Procédure

Connectez-vous à la console Function Compute. Dans le volet de navigation de gauche, cliquez sur Functions.
Dans la barre de navigation supérieure, sélectionnez une région. Sur la page Functions, cliquez sur la fonction cible.
Cliquez sur l'onglet Triggers. Copiez l'endpoint public du déclencheur HTTP.

Envoyez une requête vers cet endpoint :

   curl -i "https://http-trigger-demo.cn-shanghai.fcapp.run" -d "Hello FC!"

Important

Si le paramètre Authentication Method est défini sur No Authentication, appelez directement la fonction avec curl ou Postman.
S'il est défini sur Signature Authentication ou JWT Authentication, incluez les identifiants requis. Consultez Authentification.

Résolution des erreurs de test de fonction

Ce handler attend une entrée provenant d'un déclencheur HTTP. Le bouton Test Function envoie quant à lui une charge utile d'événement standard, ce qui génère une erreur 400 :

{
    "statusCode": 400,
    "body": "the request did not come from an HTTP Trigger, event: {\n  \"version\": null,\n  \"rawPath\": null,\n  \"headers\": null,\n  \"queryParameters\": null,\n  \"body\": null,\n  \"isBase64Encoded\": null,\n  \"requestContext\": null\n}"
}

Pour inspecter l'événement brut quelle que soit sa source, utilisez un handler acceptant un tableau []byte :

// GetRawRequestEvent returns the raw event as the response body
func GetRawRequestEvent(event []byte) (*HTTPTriggerResponse, error) {
	fmt.Printf("raw event: %s\n", string(event))
	return NewHTTPTriggerResponse(http.StatusOK).WithBody(string(event)), nil
}

func main() {
	fc.Start(GetRawRequestEvent)
}

Function Compute:Handlers du runtime Go