Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Définir le gestionnaire de fonctions Lambda en C#

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.

Lorsque votre fonction est invoquée et que Lambda exécute la méthode du gestionnaire de votre fonction, celle-ci transmet deux arguments à votre fonction. Le premier argument est l'objet event. Lorsqu'une autre Service AWS personne appelle votre fonction, l'eventobjet contient des données relatives à l'événement à l'origine de l'appel de votre fonction. Par exemple, un event objet de API Gateway contient des informations sur le chemin, la HTTP méthode et HTTP les en-têtes. La structure exacte de l'événement varie en fonction de l' Service AWS appel de votre fonction. Consultez Invoquer Lambda avec des événements provenant d'autres services AWS pour obtenir pour en savoir plus sur les formats d'événements des différents services.

Lambda transmet également un objet de context à votre fonction. Cet objet contient des informations sur l'invocation, la fonction et l'environnement d'exécution. Pour de plus amples informations, veuillez consulter Utilisation de l'objet de contexte Lambda pour récupérer les informations de la fonction C#.

Le format natif pour tous les événements Lambda est constitué de flux d'octets représentant l'événement JSON formaté. À moins que les paramètres d'entrée et de sortie de votre fonction ne soient de typeSystem.IO.Stream, vous devez les sérialiser. Spécifiez le sérialiseur que vous souhaitez utiliser en définissant l'attribut d'assemblage LambdaSerializer. Pour de plus amples informations, veuillez consulter Sérialisation dans les fonctions Lambda.

. NETmodèles d'exécution pour Lambda

Il existe deux modèles d'exécution différents pour exécuter les fonctions Lambda dans. NET: l'approche de la bibliothèque de classes et l'approche de l'assemblage exécutable.

Dans l'approche de la bibliothèque de classes, vous fournissez à Lambda une chaîne indiquant le AssemblyName, ClassName, et Method de la fonction à invoquer. Pour en savoir plus sur le format de cette chaîne, consultez Gestionnaires de bibliothèques de classes. Pendant la phase d'initialisation de la fonction, la classe de votre fonction est initialisée et tout code contenu dans le constructeur est exécuté.

Dans l'approche de l'assemblage exécutable, vous utilisez la fonctionnalité des instructions de premier niveau de C# 9. Cette approche génère un assemblage exécutable que Lambda exécute chaque fois qu'il reçoit une commande d'invocation pour votre fonction. Vous ne fournissez à Lambda que le nom de l'assemblage exécutable à exécuter.

Les sections suivantes donnent des exemples de code de fonction pour ces deux approches.

Gestionnaires de bibliothèques de classes

Le code de la fonction Lambda suivant montre un exemple d'une méthode du gestionnaire (FunctionHandler) pour une fonction Lambda qui utilise l'approche de la bibliothèque de classe. Dans cet exemple de fonction, Lambda reçoit un événement API de Gateway qui appelle la fonction. La fonction lit un enregistrement dans une base de données et le renvoie dans le cadre de la réponse de la API passerelle.

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace GetProductHandler;

public class Function
{
    private readonly IDatabaseRepository _repo;
    
    public Function()
    {
        this._repo = new DatabaseRepository();
    }
    
    public async Task<APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest request)
    {
        var id = request.PathParameters["id"];
        
        var databaseRecord = await this._repo.GetById(id);
        
        return new APIGatewayProxyResponse 
        {
            StatusCode = (int)HttpStatusCode.OK,
            Body = JsonSerializer.Serialize(databaseRecord)
        };
    }
}

Lorsque vous créez une fonction Lambda, vous devez fournir à Lambda des informations sur le gestionnaire de votre fonction sous la forme d'une chaîne de gestionnaire. Cette chaîne indique à Lambda quelle méthode de votre code doit être exécutée lorsque votre fonction est invoquée. En C#, lorsque l'on utilise l'approche de la bibliothèque de classes, le format de la chaîne du gestionnaire est le suivant :

ASSEMBLY::TYPE::METHOD, où :

Dans l'exemple de code illustré, si l'assemblage est nommé GetProductHandler, alors la chaîne du gestionnaire sera GetProductHandler::GetProductHandler.Function::FunctionHandler.

Gestionnaires d'assemblages exécutables

Dans l'exemple suivant, la fonction Lambda est définie comme un assemblage exécutable. La méthode du gestionnaire dans ce code est nommée Handler. Lors de l'utilisation d'assemblages exécutables, l'exécution Lambda doit être amorcée. Pour ce faire, vous devez utiliser la méthode LambdaBootstrapBuilder.Create. Cette méthode prend comme entrée la méthode que votre fonction utilise en tant que gestionnaire et le sérialiseur Lambda à utiliser.

Pour plus d'informations sur l'utilisation des instructions de haut niveau, voir Présentation du. NET6 runtime pour AWS Lambda on the AWS compute blog.

namespace GetProductHandler;

IDatabaseRepository repo = new DatabaseRepository();

await LambdaBootstrapBuilder.Create<APIGatewayProxyRequest>(Handler, new DefaultLambdaJsonSerializer())
    .Build()
    .RunAsync();

async Task<APIGatewayProxyResponse> Handler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext context)
{
    var id = apigProxyEvent.PathParameters["id"];
        
    var databaseRecord = await this.repo.GetById(id);
    
    return new APIGatewayProxyResponse 
    {
        StatusCode = (int)HttpStatusCode.OK,
        Body = JsonSerializer.Serialize(databaseRecord)
    };
};

Lors de l'utilisation d'assemblages exécutables, la chaîne du gestionnaire qui indique à Lambda comment exécuter votre code est le nom de l'assemblage. Dans cet exemple, ce serait GetProductHandler.

Sérialisation dans les fonctions Lambda

Si votre fonction Lambda utilise des types d'entrée ou de sortie autres qu'un objet Stream, vous devez ajouter une bibliothèque de sérialisation à votre application. Vous pouvez mettre en œuvre la sérialisation en utilisant la sérialisation standard basée sur la réflexion fournie par System.Text.Json et Newtonsoft.Json, ou en utilisant la sérialisation générée par la source.

Utilisation de la sérialisation générée par la source

La sérialisation générée par la source est une fonctionnalité de. NETversions 6 et ultérieures qui permettent de générer du code de sérialisation au moment de la compilation. Elle supprime le besoin de réflexion et peut améliorer les performances de votre fonction. Pour utiliser la sérialisation générée par la source dans votre fonction, procédez comme suit :

Un exemple de fonction utilisant la sérialisation générée par la source est présenté dans le code suivant.

[assembly: LambdaSerializer(typeof(SourceGeneratorLambdaJsonSerializer<CustomSerializer>))]

public class Function
{
    private readonly IDatabaseRepository _repo;
    
    public Function()
    {
        this._repo = new DatabaseRepository();
    }
    
    public async Task<APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest request)
    {
        var id = request.PathParameters["id"];
        
        var databaseRecord = await this._repo.GetById(id);
        
        return new APIGatewayProxyResponse 
        {
            StatusCode = (int)HttpStatusCode.OK,
            Body = JsonSerializer.Serialize(databaseRecord, CustomSerializer.Default.Product)
        };
    }
}

[JsonSerializable(typeof(APIGatewayProxyRequest))]
[JsonSerializable(typeof(APIGatewayProxyResponse))]
[JsonSerializable(typeof(Product))]
public partial class CustomSerializer : JsonSerializerContext
{
    
}

Utilisation de la sérialisation basée sur la réflexion

AWS fournit des bibliothèques prédéfinies pour vous permettre d'ajouter rapidement une sérialisation à votre application. Vous pouvez le configurer à l'aide des Amazon.Lambda.Serialization.Json NuGet packages Amazon.Lambda.Serialization.SystemTextJson ou. En arrière-plan, Amazon.Lambda.Serialization.SystemTextJson utilise System.Text.Json pour effectuer des tâches de sérialisation, et Amazon.Lambda.Serialization.Json utilise le package Newtonsoft.Json.

Vous pouvez également créer votre propre bibliothèque de sérialisation en implémentant l'interface ILambdaSerializer, disponible dans la bibliothèque Amazon.Lambda.Core. Cette interface définit deux méthodes :

Simplifiez le code de la fonction à l'aide du cadre d'annotations Lambda

Lambda Annotations est un framework pour. NET6 et. NET8 qui simplifie l'écriture de fonctions Lambda en C#. Grâce au cadre d'annotations, vous pouvez remplacer une grande partie du code d'une fonction Lambda écrite à l'aide du modèle de programmation habituel. Le code écrit à l'aide du cadre utilise des expressions plus simples qui vous permettent de vous concentrer sur votre logique commerciale.

L'exemple de code suivant montre comment l'utilisation du cadre d'annotations peut simplifier l'écriture des fonctions Lambda. Le premier exemple montre le code écrit à l'aide du modèle de programme Lambda habituel, et le second montre l'équivalent à l'aide du cadre d'annotations.

public APIGatewayHttpApiV2ProxyResponse LambdaMathAdd(APIGatewayHttpApiV2ProxyRequest request, ILambdaContext context)
{
    if (!request.PathParameters.TryGetValue("x", out var xs))
    {
        return new APIGatewayHttpApiV2ProxyResponse
        {
            StatusCode = (int)HttpStatusCode.BadRequest
        };
    }
    if (!request.PathParameters.TryGetValue("y", out var ys))
    {
        return new APIGatewayHttpApiV2ProxyResponse
        {
            StatusCode = (int)HttpStatusCode.BadRequest
        };
    }
    var x = int.Parse(xs);
    var y = int.Parse(ys);
    return new APIGatewayHttpApiV2ProxyResponse
    {
        StatusCode = (int)HttpStatusCode.OK,
        Body = (x + y).ToString(),
        Headers = new Dictionary≪string, string> { { "Content-Type", "text/plain" } }
    };
}

[LambdaFunction]
[HttpApi(LambdaHttpMethod.Get, "/add/{x}/{y}")]
public int Add(int x, int y)
{
    return x + y;
}

Pour un autre exemple de la façon dont l'utilisation des annotations Lambda peut simplifier votre code, consultez cet exemple d'application multiservice dans le référentiel. awsdocs/aws-doc-sdk-examples GitHub Le dossier PamApiAnnotations utilise des annotations Lambda dans le fichier principal function.cs. À titre de comparaison, le dossier PamApi contient des fichiers équivalents écrits à l'aide du modèle de programmation Lambda habituel.

Le cadre d'annotations utilise des générateurs de source pour générer un code qui traduit le modèle de programmation Lambda en code tel qu'il apparaît dans le deuxième exemple.

Pour plus d'informations sur l'utilisation des annotations Lambda pour. NET, consultez les ressources suivantes :

Injection de dépendances grâce au cadre d'annotations Lambda

Vous pouvez également utiliser le cadre d'annotations Lambda pour ajouter l'injection de dépendance à vos fonctions Lambda en utilisant une syntaxe que vous connaissez bien. Lorsque vous ajoutez un attribut [LambdaStartup] à un fichier Startup.cs, le cadre d'annotations Lambda génère le code nécessaire au moment de la compilation.

[LambdaStartup]
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<IDatabaseRepository, DatabaseRepository>();
    }
}

Votre fonction Lambda peut injecter des services en utilisant l'injection de constructeur ou en injectant dans des méthodes individuelles à l'aide de l'attribut [FromServices].

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace GetProductHandler;

public class Function
{
    private readonly IDatabaseRepository _repo;
    
    public Function(IDatabaseRepository repo)
    {
        this._repo = repo;
    }
    
    [LambdaFunction]
    [HttpApi(LambdaHttpMethod.Get, "/product/{id}")]
    public async Task<Product> FunctionHandler([FromServices] IDatabaseRepository repository, string id)
    {
        return await this._repo.GetById(id);
    }
}

Restrictions liées au gestionnaire de fonctions Lambda

Notez que des restrictions s'appliquent à la signature du gestionnaire.

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

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