Gestionnaire de fonctions AWS Lambda dans Go

Le gestionnaire de fonction Lambda est la méthode dans votre code de fonction qui traite les événements. Lorsque votre fonction est invoquée, Lambda exécute la méthode du gestionnaire. Votre fonction s'exécute jusqu'à ce que le gestionnaire renvoie une réponse, se ferme ou expire.

Une fonction Lambda écrite en Go est créée en tant qu'exécutable Go. Dans le code de votre fonction Lambda, vous devez inclure le package github.com/aws/ aws-lambda-go /lambda, qui implémente le modèle de programmation Lambda pour Go. De plus, vous devez mettre en œuvre le code de fonction du gestionnaire et une fonction main().

Exemple Une fonction Lambda dans Go

package main

import (
	"context"
	"fmt"
	"github.com/aws/aws-lambda-go/lambda"
)

type MyEvent struct {
	Name string `json:"name"`
}

func HandleRequest(ctx context.Context, event *MyEvent) (*string, error) {
	if event == nil {
		return nil, fmt.Errorf("received nil event")
	}
	message := fmt.Sprintf("Hello %s!", event.Name)
	return &message, nil
}

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

Voici un exemple d'entrée pour cette fonction :

{
  "name": "Jane"
}

Notez ce qui suit :

• package main : dans Go, le package contenant func main() doit toujours être nommé main.

• import : utilisez cette instruction pour inclure les bibliothèques que votre fonction Lambda requiert. Dans cette instance, elle inclut :

  • context: AWS LambdaObjet de contexte dans Go.

  • fmt : l'objet Go Formatting utilisé pour formater la valeur de retour de votre fonction.

  • github.com/aws/ aws-lambda-go /lambda : comme mentionné précédemment, implémente le modèle de programmation Lambda pour Go.

• func HandleRequest (ctx context.Context, event *MyEvent) (*string, error) : il s'agit de la signature de votre gestionnaire Lambda. C'est le point d'entrée de votre fonction Lambda et il contient la logique qui est exécutée lorsque votre fonction est invoquée. En outre, les paramètres inclus désignent les éléments suivants :

  • ctx context.Context : fournit des informations d'exécution pour l'invocation de votre fonction Lambda. ctx est la variable que vous déclarez pour exploiter les informations disponibles via AWS LambdaObjet de contexte dans Go.

  • event * MyEvent : Il s'agit d'un paramètre nommé event qui pointe versMyEvent. Il représente l'entrée de la fonction Lambda.

  • *string, error : le gestionnaire renvoie deux valeurs. La première est un pointeur sur une chaîne de caractères qui contient le résultat de la fonction Lambda. La deuxième est un type d'erreur, qui correspond à nil s'il n'y a pas d'erreur et qui contient les informations d'erreur standard en cas de problème. Pour plus d'informations sur la gestion des erreurs personnalisées, consultez AWS LambdaErreurs de fonction dans Go.

  • return &message, nil : renvoie deux valeurs. La première est un pointeur vers un message sous forme de chaîne de caractères, qui est un message d'accueil construit à partir du champ Name de l'événement d'entrée. La deuxième valeur, nil, indique que la fonction n'a pas rencontré d'erreurs.

• func main() : point d'entrée qui exécute votre code de fonction Lambda. C'est obligatoire.

  En ajoutant lambda.Start(HandleRequest) entre les accolades du code func main(){}, votre fonction Lambda sera exécutée. Selon les normes du langage Go, l'accolade ouvrante, {, doit être placée directement à la fin de la signature de la fonction main.

Dénomination

exécutions de provid.al2 et provid.al2023

Pour les fonctions Go qui utilisent l'exécution provided.al2 ou provided.al2023 dans un package de déploiement .zip, le fichier exécutable qui contient le code de votre fonction doit être nommé bootstrap. Si vous déployez la fonction avec un fichier .zip, le fichier bootstrap doit se trouver à la racine du fichier .zip. Pour les fonctions Go qui l'exécution provided.al2 ou provided.al2023 dans une image du conteneur, vous pouvez utiliser n'importe quel nom pour le fichier exécutable.

Vous pouvez utiliser n'importe quel nom pour le gestionnaire. Pour référencer la valeur du gestionnaire dans votre code, vous pouvez utiliser la variable d'environnement _HANDLER.

Exécution go1.x

Pour les fonctions Go qui utilisent l'exécution go1.x, le fichier exécutable et le gestionnaire peuvent partager n'importe quel nom. Par exemple, si vous définissez la valeur du gestionnaire sur Handler, Lambda appellera la fonction main() dans le fichier exécutable Handler.

Pour modifier le nom du gestionnaire de fonction dans la console Lambda, dans le volet Runtime settings (Paramètres d'exécution), choisissez Edit (Modifier).

Gestionnaire de fonctions Lambda utilisant des types structurés

Dans l'exemple ci-dessus, le type d'entrée était une chaîne simple. Mais vous pouvez également transmettre des événements structurés à votre gestionnaire de fonction :

package main

import (
	"fmt"
	"github.com/aws/aws-lambda-go/lambda"
)

type MyEvent struct {
	Name string `json:"What is your name?"`
	Age  int    `json:"How old are you?"`
}

type MyResponse struct {
	Message string `json:"Answer"`
}

func HandleLambdaEvent(event *MyEvent) (*MyResponse, error) {
	if event == nil {
		return nil, fmt.Errorf("received nil event")
	}
	return &MyResponse{Message: fmt.Sprintf("%s is %d years old!", event.Name, event.Age)}, nil
}

func main() {
	lambda.Start(HandleLambdaEvent)
}

Voici un exemple d'entrée pour cette fonction :

{
    "What is your name?": "Jim",
    "How old are you?": 33
}

La réponse ressemble à ceci :

{
    "Answer": "Jim is 33 years old!"
}

Pour être exportées, les noms de champs de la structure d'événement doivent être en majuscules. Pour plus d'informations sur la gestion des événements provenant de sources d'AWSaws-lambda-goévénements, consultez /events.

Signatures de gestionnaire valides

Vous disposez de plusieurs options lorsque vous créez un gestionnaire de fonction Lambda dans Go, mais vous devez respecter les règles suivantes :

• Le gestionnaire doit être une fonction.

• Le gestionnaire peut accepter entre 0 et 2 arguments. S'il y a deux arguments, le premier argument doit implémenter context.Context.

• Le gestionnaire peut retourner entre 0 et 2 arguments. S'il y a une seule valeur renvoyée, elle doit implémenter error. S'il y a deux valeurs renvoyées, la seconde valeur doit implémenter error. Pour plus d'informations sur l'implémentation des informations de gestion des erreurs, consultez AWS LambdaErreurs de fonction dans Go.

Voici la liste des signatures de gestionnaire valides. TIn et TOut représentent des types compatibles avec la bibliothèque encoding/json standard. Pour en savoir plus, reportez-vous à la section func Unmarshal pour savoir comment ces types sont désérialisés.

• func ()

• func () error

• func (TIn) error

• func () (TOut, error)

• func (context.Context) error

• func (context.Context, TIn) error

• func (context.Context) (TOut, error)

• func (context.Context, TIn) (TOut, error)

Utilisation de l'état global

Vous pouvez déclarer et modifier des variables globales indépendantes du code du gestionnaire de votre fonction Lambda. De plus, votre gestionnaire peut déclarer une fonction init qui est exécutée lorsque votre gestionnaire est chargé. Celui-ci se comporte dans AWS Lambda comme il le fait dans les programmes Go standard. Une instance unique de votre fonction Lambda ne gère jamais plusieurs événements simultanément.

Exemple Une fonction Go avec des variables globales

Note

Ce code utilise le V2 AWS SDK for Go. Pour plus d'informations, consultez la section Mise en route avec le V2 AWS SDK for Go.

package main

import (
	"context"
	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/s3/types"
	"log"
)

var invokeCount int
var myObjects []types.Object

func init() {
	// Load the SDK configuration
	cfg, err := config.LoadDefaultConfig(context.TODO())
	if err != nil {
		log.Fatalf("Unable to load SDK config: %v", err)
	}

	// Initialize an S3 client
	svc := s3.NewFromConfig(cfg)

	// Define the bucket name as a variable so we can take its address
	bucketName := "examplebucket"
	input := &s3.ListObjectsV2Input{
		Bucket: &bucketName,
	}

	// List objects in the bucket
	result, err := svc.ListObjectsV2(context.TODO(), input)
	if err != nil {
		log.Fatalf("Failed to list objects: %v", err)
	}
	myObjects = result.Contents
}

func LambdaHandler(ctx context.Context) (int, error) {
	invokeCount++
	for i, obj := range myObjects {
		log.Printf("object[%d] size: %d key: %s", i, obj.Size, *obj.Key)
	}
	return invokeCount, nil
}

func main() {
	lambda.Start(LambdaHandler)
}