Notions de base sur Go Handler Dénomination Gestionnaire de fonctions Lambda utilisant des types structurés Utilisation de l'état global Meilleures pratiques en matière de code pour les fonctions Go Lambda

Définir le gestionnaire de fonctions 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.

Rubriques

Notions de base sur Go Handler
Dénomination
Gestionnaire de fonctions Lambda utilisant des types structurés
Utilisation de l'état global
Meilleures pratiques en matière de code pour les fonctions Go Lambda

Notions de base sur Go Handler

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: Utilisation de l'objet de contexte Lambda pour récupérer les informations de la fonction 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 Utilisation de l'objet de contexte Lambda pour récupérer les informations de la fonction 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.
- 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' AWS aws-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.

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é. Cela se comporte de la même manière AWS Lambda que 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 AWS SDK for Go V2. Pour plus d'informations, consultez Getting Started with the AWS SDK for Go V2.


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 := "amzn-s3-demo-bucket"
	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)
}

Meilleures pratiques en matière de code pour les fonctions Go Lambda

Respectez les directives de la liste suivante pour utiliser les meilleures pratiques de codage lors de la création de vos fonctions Lambda :

Séparez le gestionnaire Lambda de votre logique principale. Cela vous permet de créer une fonction testable plus unitaire.
Réduisez la complexité de vos dépendances. Privilégiez les infrastructures plus simples qui se chargent rapidement au démarrage de l’environnement d’exécution.
Réduisez la taille de votre package de déploiement selon ses besoins d’exécution. Cela contribue à réduire le temps nécessaire au téléchargement et à la décompression de votre package de déploiement avant l’invocation.

Tirez parti de la réutilisation de l’environnement d’exécution pour améliorer les performances de votre fonction. Initialisez les SDK clients et les connexions à la base de données en dehors du gestionnaire de fonctions et mettez en cache les actifs statiques localement dans le /tmp répertoire. Les invocations ultérieures traitées par la même instance de votre fonction peuvent réutiliser ces ressources. Cela permet d’économiser des coûts, tout en réduisant le temps d’exécution de la fonction.

Pour éviter des éventuelles fuites de données entre les invocations, n’utilisez pas l’environnement d’exécution pour stocker des données utilisateur, des événements ou d’autres informations ayant un impact sur la sécurité. Si votre fonction repose sur un état réversible qui ne peut pas être stocké en mémoire dans le gestionnaire, envisagez de créer une fonction distincte ou des versions distinctes d’une fonction pour chaque utilisateur.
Utilisez une directive keep-alive pour maintenir les connexions persistantes. Lambda purge les connexions inactives au fil du temps. Si vous tentez de réutiliser une connexion inactive lorsque vous invoquez une fonction, cela entraîne une erreur de connexion. Pour maintenir votre connexion persistante, utilisez la directive Keep-alive associée à votre environnement d’exécution. Pour obtenir un exemple, consultez Réutilisation des connexions avec Keep-Alive dans Node.js.
Utilisez des variables d’environnement pour transmettre des paramètres opérationnels à votre fonction. Par exemple, si vous écrivez dans un compartiment Amazon S3 au lieu de coder en dur le nom du compartiment dans lequel vous écrivez, configurez le nom du compartiment comme variable d’environnement.
Évitez d'utiliser des invocations récursives dans votre fonction Lambda, lorsque la fonction s'invoque elle-même ou initie un processus susceptible de l'invoquer à nouveau. Cela peut entraîner un volume involontaire d’invocations de fonction et des coûts accrus. Si vous constatez un volume d'invocations involontaire, réglez la fonction réservée à la simultanéité sur 0 immédiatement afin de limiter toutes les invocations à la fonction pendant que vous mettez à jour le code.
N'utilisez pas de code non documenté ni public APIs dans votre code de fonction Lambda. Pour les AWS Lambda environnements d'exécution gérés, Lambda applique régulièrement des mises à jour de sécurité et fonctionnelles aux applications internes de Lambda. APIs Ces API mises à jour internes peuvent être rétroincompatibles, ce qui peut entraîner des conséquences imprévues, telles que des échecs d'invocation si votre fonction dépend de ces mises à jour non publiques. APIs Voir la API référence pour une liste des documents accessibles au publicAPIs.
Écriture du code idempotent. L’écriture de code idempotent pour vos fonctions garantit ne gestion identique des événements dupliqués. Votre code doit valider correctement les événements et gérer correctement les événements dupliqués. Pour de plus amples informations, veuillez consulterComment faire en sorte que ma fonction Lambda soit idempotente ?.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création avec Go

Contexte