Definire l'handler della funzione Lambda in C#

Il gestore di funzioni Lambda è il metodo nel codice della funzione che elabora gli eventi. Quando viene richiamata la funzione, Lambda esegue il metodo del gestore. La funzione viene eseguita fino a quando il gestore non restituisce una risposta, termina o scade.

Questa pagina descrive come utilizzare i gestori di funzioni Lambda in C# per lavorare con il runtime gestito.NET, incluse le opzioni per la configurazione del progetto, le convenzioni di denominazione e le migliori pratiche. Questa pagina include anche un esempio di una funzione Lambda di C# che raccoglie informazioni su un ordine, produce una ricevuta in un file di testo e inserisce questo file in un bucket Amazon Simple Storage Service (S3). Per informazioni su come distribuire una funzione dopo averla scritta, consulta o. Crea e implementa le funzioni Lambda C# con gli archivi di file .zip Distribuzione delle funzioni .NET Lambda con immagini di container

Configurazione del progetto C# handler

Quando si lavora con le funzioni Lambda in C#, il processo prevede la scrittura del codice, quindi la distribuzione del codice in Lambda. Esistono due diversi modelli di esecuzione per la distribuzione delle funzioni Lambda in .NET: l'approccio della libreria di classi e l'approccio dell'assembly eseguibile.

Nell'approccio alla libreria di classi, si impacchetta il codice della funzione come .NET assembly (.dll) e lo si distribuisce in Lambda con il runtime dotnet8 gestito.NET (). Per il nome del gestore, Lambda prevede una stringa nel formato. AssemblyName::Namespace.Classname::Methodname Durante la fase di inizializzazione della funzione, la classe della funzione viene inizializzata e viene eseguito qualsiasi codice nel costruttore.

Nell'approccio dell'assembly eseguibile, si utilizza la funzionalità delle istruzioni di primo livello introdotta per la prima volta in C# 9. Questo approccio genera un assembly eseguibile che Lambda esegue ogni volta che riceve un comando invoke per la tua funzione. In questo approccio, si utilizza anche il runtime gestito.NET ()dotnet8. Per il nome del gestore, fornisci a Lambda il nome dell'assembly eseguibile da eseguire.

L'esempio principale in questa pagina illustra l'approccio delle librerie di classi. È possibile inizializzare il progetto C# Lambda in vari modi, ma il modo più semplice è utilizzare l'interfaccia CLI.NET con la CLI. Amazon.Lambda.Tools Configura la Amazon.Lambda.Tools CLI seguendo i passaggi indicati. Configurazione dell'ambiente di sviluppo .NET Quindi, inizializza il tuo progetto con il seguente comando:

dotnet new lambda.EmptyFunction --name ExampleCS

Questo comando genera la seguente struttura di file:

/project-root 
    └ src
        └ ExampleCS
            └ Function.cs (contains main handler)
            └ Readme.md
            └ aws-lambda-tools-defaults.json
            └ ExampleCS.csproj          
    └ test
         └ ExampleCS.Tests
            └ FunctionTest.cs (contains main handler)
            └ ExampleCS.Tests.csproj 

In questa struttura di file, la logica principale del gestore della funzione risiede nel Function.cs file.

Esempio di codice di funzione Lambda in C#

Il seguente esempio di codice della funzione C# Lambda raccoglie informazioni su un ordine, produce una ricevuta in un file di testo e inserisce questo file in un bucket Amazon S3.

Esempio Funzione Lambda Function.cs

using System;
using System.Text;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;

// Assembly attribute to enable Lambda function logging
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace ExampleLambda;

public class Order
{
    public string OrderId { get; set; } = string.Empty;
    public double Amount { get; set; }
    public string Item { get; set; } = string.Empty;
}

public class OrderHandler
{
    private static readonly AmazonS3Client s3Client = new();

    public async Task<string> HandleRequest(Order order, ILambdaContext context)
    {
        try
        {
            string? bucketName = Environment.GetEnvironmentVariable("RECEIPT_BUCKET");
            if (string.IsNullOrWhiteSpace(bucketName))
            {
                throw new ArgumentException("RECEIPT_BUCKET environment variable is not set");
            }

            string receiptContent = $"OrderID: {order.OrderId}\nAmount: ${order.Amount:F2}\nItem: {order.Item}";
            string key = $"receipts/{order.OrderId}.txt";

            await UploadReceiptToS3(bucketName, key, receiptContent);

            context.Logger.LogInformation($"Successfully processed order {order.OrderId} and stored receipt in S3 bucket {bucketName}");
            return "Success";
        }
        catch (Exception ex)
        {
            context.Logger.LogError($"Failed to process order: {ex.Message}");
            throw;
        }
    }

    private async Task UploadReceiptToS3(string bucketName, string key, string receiptContent)
    {
        try
        {
            var putRequest = new PutObjectRequest
            {
                BucketName = bucketName,
                Key = key,
                ContentBody = receiptContent,
                ContentType = "text/plain"
            };

            await s3Client.PutObjectAsync(putRequest);
        }
        catch (AmazonS3Exception ex)
        {
            throw new Exception($"Failed to upload receipt to S3: {ex.Message}", ex);
        }
    }
}

Questo file Function.cs contiene le sezioni seguenti:

• usingistruzioni: usale per importare le classi C# richieste dalla tua funzione Lambda.

• [assembly: LambdaSerializer(...)]: LambdaSerializer è un attributo assembly che indica a Lambda di convertire automaticamente i payload di eventi JSON in oggetti C# prima di passarli alla funzione.

• namespace ExampleLambda: definisce lo spazio dei nomi. In C#, il nome dello spazio dei nomi non deve necessariamente corrispondere al nome del file.

• public class Order {...}: definisce la forma dell'evento di input previsto.

• public class OrderHandler {...}: Questo definisce la tua classe C#. Al suo interno, definirai il metodo del gestore principale e qualsiasi altro metodo di supporto.

• private static readonly AmazonS3Client s3Client = new();: Questo inizializza un client Amazon S3 con la catena di provider di credenziali predefinita, al di fuori del metodo del gestore principale. Questo fa sì che Lambda esegua questo codice durante la fase di inizializzazione.

• public async ... HandleRequest (Order order, ILambdaContext context): questo è il metodo dell'handler principale, che contiene la logica principale dell'applicazione.

• private async Task UploadReceiptToS3(...) {}: questo è un metodo helper a cui fa riferimento il metodo dell'handler principale handleRequest.

Poiché questa funzione richiede un client SDK Amazon S3, devi aggiungerlo alle dipendenze del progetto. Puoi farlo accedendo src/ExampleCS ed eseguendo il seguente comando:

dotnet add package AWSSDK.S3

Aggiungi informazioni sui metadati a .json aws-lambda-tools-defaults

Per impostazione predefinita, il aws-lambda-tools-defaults.json file generato non contiene region informazioni sulla profile tua funzione. Inoltre, aggiorna la function-handler stringa al valore corretto (ExampleCS::ExampleLambda.OrderHandler::HandleRequest). Puoi effettuare questo aggiornamento manualmente e aggiungere i metadati necessari per utilizzare un profilo di credenziali e una regione specifici per la tua funzione. Ad esempio, il aws-lambda-tools-defaults.json file dovrebbe avere un aspetto simile al seguente:

{
  "Information": [
    "This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
    "To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
    "dotnet lambda help",
    "All the command line options for the Lambda command can be specified in this file."
  ],
  "profile": "default",
  "region": "us-east-1",
  "configuration": "Release",
  "function-architecture": "x86_64",
  "function-runtime": "dotnet8",
  "function-memory-size": 512,
  "function-timeout": 30,
  "function-handler": "ExampleCS::ExampleLambda.OrderHandler::HandleRequest"
}

Affinché questa funzione funzioni correttamente, il suo ruolo di esecuzione deve consentire l's3:PutObjectazione. Se si utilizza il dotnet lambda deploy-function comando (ad esempiodotnet lambda deploy-function ExampleCS), la AWSLambdaExecute politica nei prompt della CLI contiene le autorizzazioni necessarie per richiamare correttamente questa funzione.

Inoltre, assicurati che

Infine, assicuratevi di definire la variabile di RECEIPT_BUCKET ambiente. Dopo una chiamata riuscita, il bucket Amazon S3 dovrebbe contenere un file di ricevuta.

Gestori di librerie di classi

Il codice di esempio principale in questa pagina illustra un gestore di librerie di classi. I gestori di librerie di classi hanno la seguente struttura:

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

namespace NAMESPACE;

...

public class CLASSNAME {
    public async Task<string> METHODNAME (...) {
    ...
    }
}

Quando crei una funzione Lambda, devi fornire a Lambda informazioni sul gestore della funzione sotto forma di stringa nel campo Handler. Questo indica a Lambda quale metodo del codice eseguire quando la funzione viene richiamata. In C#, per i gestori di librerie di classi, il formato della stringa del gestore è, dove: ASSEMBLY::TYPE::METHOD

• ASSEMBLY è il nome del file di assembly .NET per l'applicazione. Se stai usando la Amazon.Lambda.Tools CLI per creare la tua applicazione e non imposti il nome dell'assembly utilizzando la AssemblyName proprietà nel .csproj file, allora ASSEMBLY è semplicemente il nome del tuo .csproj file.

• TYPEè il nome completo del tipo di gestore, che è. NAMESPACE.CLASSNAME

• METHODè il nome del metodo del gestore principale nel codice, che è. METHODNAME

Per il codice di esempio principale in questa pagina, se l'assembly ha un nomeExampleCS, la stringa completa del gestore è. ExampleCS::ExampleLambda.OrderHandler::HandleRequest

Gestori di assembly eseguibili

È inoltre possibile definire le funzioni Lambda in C# come assembly eseguibile. I gestori di assembly eseguibili utilizzano la funzionalità delle istruzioni di primo livello di C#, in cui il compilatore genera il Main() metodo e inserisce il codice della funzione al suo interno. Quando si utilizzano assembly eseguibili, è necessario avviare il runtime Lambda. A tale scopo, utilizzate il metodo contenuto nel codice. LambdaBootstrapBuilder.Create Gli input di questo metodo sono la funzione di gestione principale e il serializzatore Lambda da utilizzare. Di seguito viene mostrato un esempio di gestore di assembly eseguibile in C#:

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)
    };
};

Nel campo Handler per i gestori di assembly eseguibili, la stringa del gestore che indica a Lambda come eseguire il codice è il nome dell'assembly. In questo esempio, quello è. GetProductHandler

Firme valide dei gestori per le funzioni C#

In C#, le firme valide del gestore Lambda richiedono tra 0 e 2 argomenti. In genere, la firma del gestore ha due argomenti, come mostrato nell'esempio principale:

public async Task<string> HandleRequest(Order order, ILambdaContext context)

Quando si forniscono due argomenti, il primo argomento deve essere l'input dell'evento e il secondo argomento deve essere l'oggetto del contesto Lambda. Entrambi gli argomenti sono opzionali. Ad esempio, le seguenti sono anche firme di gestori Lambda valide in C#:

• public async Task<string> HandleRequest()

• public async Task<string> HandleRequest(Order order)

• public async Task<string> HandleRequest(ILambdaContext context)

Oltre alla sintassi di base della firma del gestore, esistono alcune restrizioni aggiuntive:

• Non è possibile utilizzare la unsafe parola chiave nella firma del gestore. Tuttavia, è possibile utilizzare il unsafe contesto all'interno del metodo handler e le sue dipendenze. Per ulteriori informazioni, vedere unsafe (riferimento a C#) nel sito Web della documentazione Microsoft.

• Il gestore non può utilizzare la params parola chiave o utilizzarla ArgIterator come parametro di input o return. Queste parole chiave supportano un numero variabile di parametri. Il numero massimo di argomenti che il gestore può accettare è due.

• Il gestore potrebbe non essere un metodo generico. In altre parole, non può utilizzare parametri di tipo generico come<T>.

• Lambda non supporta i gestori asincroni con la firma. async void

Convenzioni di denominazione dei gestori

I gestori Lambda in C# non hanno restrizioni di denominazione rigide. Tuttavia, devi assicurarti di fornire la stringa del gestore corretta a Lambda quando distribuisci la tua funzione. La stringa del gestore corretta dipende dal fatto che stiate distribuendo un gestore di libreria di classi o un gestore di assembly eseguibile.

Sebbene sia possibile utilizzare qualsiasi nome per il gestore, i nomi delle funzioni in C# sono generalmente in. PascalCase Inoltre, sebbene non sia necessario che il nome del file corrisponda al nome della classe o del gestore, in genere è consigliabile utilizzare un nome di file come OrderHandler.cs se si trattasse del nome della classe. OrderHandler Ad esempio, è possibile modificare il nome del file in questo esempio da a. Function.cs OrderHandler.cs

Serializzazione nelle funzioni Lambda C#

JSON è il formato di input più comune e standard per le funzioni Lambda. In questo esempio, la funzione prevede un input simile a quanto segue:

{
    "orderId": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}

In C#, è possibile definire la forma dell'evento di input previsto in una classe. In questo esempio, definiamo la Order classe per modellare questo input:

public class Order
{
    public string OrderId { get; set; } = string.Empty;
    public double Amount { get; set; }
    public string Item { get; set; } = string.Empty;
}

Se la funzione Lambda utilizza i tipi di input/output diversi da un oggetto Stream, è necessario aggiungere una libreria di serializzazione all'applicazione. Ciò consente di convertire l'input JSON in un'istanza della classe definita. Esistono due metodi di serializzazione per le funzioni C# in Lambda: serializzazione basata sulla riflessione e serializzazione generata dal codice sorgente.

Serializzazione basata sulla riflessione

AWS fornisce librerie predefinite che è possibile aggiungere rapidamente all'applicazione. Queste librerie implementano la serializzazione utilizzando la riflessione. Utilizzate uno dei seguenti pacchetti per implementare la serializzazione basata sulla riflessione:

• Amazon.Lambda.Serialization.SystemTextJson— Nel backend, questo pacchetto viene utilizzato System.Text.Json per eseguire attività di serializzazione.

• Amazon.Lambda.Serialization.Json— Nel backend, questo pacchetto viene utilizzato Newtonsoft.Json per eseguire attività di serializzazione.

È possibile inoltre creare una libreria di serializzazione personalizzata implementando l'interfaccia ILambdaSerializer, disponibile come parte della libreria Amazon.Lambda.Core. L'interfaccia definisce due metodi:

• T Deserialize<T>(Stream requestStream);

  Questo metodo viene implementato per deserializzare il payload della richiesta dall'API Invoke nell'oggetto passato al gestore della funzione Lambda.

• T Serialize<T>(T response, Stream responseStream);

  Questo metodo viene implementato per serializzare il risultato restituito dal gestore della funzione Lambda nel payload della risposta restituito dall'operazione dell'API Invoke.

L'esempio principale in questa pagina utilizza la serializzazione basata sulla riflessione. La serializzazione basata sulla riflessione funziona immediatamente AWS Lambda e non richiede alcuna configurazione aggiuntiva, il che la rende una buona scelta in termini di semplicità. Tuttavia, richiede un maggiore utilizzo della memoria funzionale. È inoltre possibile che si verifichino latenze di funzioni più elevate a causa della riflessione in fase di esecuzione.

Serializzazione generata dal codice sorgente

Con la serializzazione generata dal codice sorgente, il codice di serializzazione viene generato in fase di compilazione. Ciò elimina la necessità di riflettere e può migliorare le prestazioni della funzione. Per utilizzare la serializzazione generata dal codice sorgente nella funzione, è necessario effettuare le seguenti operazioni:

• Crea una nuova classe parziale che eredita da JsonSerializerContext, aggiungendo attributi JsonSerializable per tutti i tipi che richiedono la serializzazione o la deserializzazione.

• Configura il LambdaSerializer per utilizzare un SourceGeneratorLambdaJsonSerializer<T>.

• Aggiornate qualsiasi serializzazione e deserializzazione manuale nel codice dell'applicazione per utilizzare la classe appena creata.

L'esempio seguente mostra come modificare l'esempio principale di questa pagina, che utilizza la serializzazione basata sulla riflessione, per utilizzare invece la serializzazione generata dal codice sorgente.

using System.Text.Json;
using System.Text.Json.Serialization;

...

public class Order
{
    public string OrderId { get; set; } = string.Empty;
    public double Amount { get; set; }
    public string Item { get; set; } = string.Empty;
}

[JsonSerializable(typeof(Order))]
public partial class OrderJsonContext : JsonSerializerContext {}

public class OrderHandler
{

    ...

    public async Task<string> HandleRequest(string input, ILambdaContext context)
    {
    
    var order = JsonSerializer.Deserialize(input, OrderJsonContext.Default.Order);
    
    ...
    
    }

}

La serializzazione generata dal codice sorgente richiede più impostazioni rispetto alla serializzazione basata sulla riflessione. Tuttavia, le funzioni che utilizzano dati generati dal codice sorgente tendono a utilizzare meno memoria e offrono prestazioni migliori grazie alla generazione di codice in fase di compilazione. Per contribuire a eliminare gli avviamenti a freddo delle funzioni, prendete in considerazione la possibilità di passare alla serializzazione generata dal codice sorgente.

Nota

Se desideri utilizzare la ahead-of-time compilazione nativa (AOT) con Lambda, devi utilizzare la serializzazione generata dal codice sorgente.

Accesso e utilizzo dell'oggetto contestuale Lambda

L'oggetto contesto: contiene informazioni sulla chiamata, sulla funzione e sull'ambiente di esecuzione. In questo esempio, l'oggetto context è di tipo ed è il secondo Amazon.Lambda.Core.ILambdaContext argomento della funzione di gestione principale.

public async Task<string> HandleRequest(Order order, ILambdaContext context) {
    ...
}

L'oggetto context è un input opzionale. Per ulteriori informazioni sulle firme valide dei gestori accettate, vedere. Firme valide dei gestori per le funzioni C#

L'oggetto context è utile per produrre log di funzioni su Amazon CloudWatch. Puoi usare il context.getLogger() metodo per ottenere un LambdaLogger oggetto per la registrazione. In questo esempio, possiamo usare il logger per registrare un messaggio di errore se l'elaborazione fallisce per qualsiasi motivo:

context.Logger.LogError($"Failed to process order: {ex.Message}");

Oltre alla registrazione, puoi anche utilizzare l'oggetto contestuale per il monitoraggio delle funzioni. Per ulteriori informazioni sulla copia di oggetti, consulta la sezione Utilizzo dell'oggetto del contesto Lambda per recuperare le informazioni sulla funzione C#.

Usando la SDK per .NET v3 nel tuo gestore

Spesso, utilizzerai le funzioni Lambda per interagire o aggiornare altre AWS risorse. Il modo più semplice per interfacciarsi con queste risorse è usare la SDK per .NET v3.

Nota

La SDK per .NET (v2) è obsoleta. Ti consigliamo di utilizzare solo la versione v3. SDK per .NET

Puoi aggiungere dipendenze SDK al tuo progetto usando il seguente comando: Amazon.Lambda.Tools

dotnet add package <package_name>

Ad esempio, nell'esempio principale di questa pagina, dobbiamo utilizzare l'API Amazon S3 per caricare una ricevuta su S3. Possiamo importare il client SDK Amazon S3 con il seguente comando:

dotnet add package AWSSDK.S3

Questo comando aggiunge la dipendenza al progetto. Dovresti anche vedere una riga simile alla seguente nel .csproj file del tuo progetto:

<PackageReference Include="AWSSDK.S3" Version="3.7.2.18" />

Quindi, importa le dipendenze direttamente nel tuo codice C#:

using Amazon.S3;
using Amazon.S3.Model;

Il codice di esempio inizializza quindi un client Amazon S3 (utilizzando la catena di provider di credenziali predefinita) come segue:

private static readonly AmazonS3Client s3Client = new();

In questo esempio, abbiamo inizializzato il nostro client Amazon S3 al di fuori della funzione di gestione principale per evitare di doverlo inizializzare ogni volta che richiamiamo la nostra funzione. Dopo aver inizializzato il client SDK, puoi utilizzarlo per interagire con altri servizi. AWS Il codice di esempio richiama l'PutObjectAPI Amazon S3 nel modo seguente:

var putRequest = new PutObjectRequest
{
    BucketName = bucketName,
    Key = key,
    ContentBody = receiptContent,
    ContentType = "text/plain"
};

await s3Client.PutObjectAsync(putRequest);

Accesso alle variabili d'ambiente

Nel codice dell'handler, puoi fare riferimento a qualsiasi variabile di ambiente utilizzando il metodo System.Environment.GetEnvironmentVariable. In questo esempio, facciamo riferimento alla variabile di RECEIPT_BUCKET ambiente definita utilizzando le seguenti righe di codice:

string? bucketName = Environment.GetEnvironmentVariable("RECEIPT_BUCKET");
if (string.IsNullOrWhiteSpace(bucketName))
{
    throw new ArgumentException("RECEIPT_BUCKET environment variable is not set");
}

Utilizzo dello stato globale

Lambda esegue il codice statico e il costruttore della classe durante la fase di inizializzazione prima di richiamare la funzione per la prima volta. Le risorse create durante l'inizializzazione rimangono in memoria tra le chiamate, in modo da evitare di doverle creare ogni volta che si richiama la funzione.

Nel codice di esempio, il codice di inizializzazione del client S3 non rientra nel metodo del gestore principale. Il runtime inizializza il client prima che la funzione gestisca il primo evento, il che può portare a tempi di elaborazione più lunghi. Gli eventi successivi sono molto più veloci perché Lambda non ha bisogno di inizializzare nuovamente il client.

Semplificazione del codice delle funzioni con il framework Lambda Annotations

Lambda Annotations è un framework per.NET 8 che semplifica la scrittura di funzioni Lambda utilizzando C#. Il framework Annotations utilizza generatori di sorgenti per generare codice che si traduce dal modello di programmazione Lambda al codice semplificato. Con il framework Annotations, è possibile sostituire gran parte del codice in una funzione Lambda scritta utilizzando il normale modello di programmazione. Il codice scritto utilizzando il framework utilizza espressioni più semplici che consentono di concentrarsi sulla logica aziendale. Per alcuni esempi, consulta Amazon.Lambda.Annotations nella documentazione di nuget.

Per un esempio di applicazione completa che utilizza le annotazioni Lambda, consulta PhotoAssetManagerl'esempio nel repository. awsdocs/aws-doc-sdk-examples GitHub Il Function.cs file principale nella PamApiAnnotations directory utilizza Lambda Annotations. Per fare un confronto, la PamApi directory contiene file equivalenti scritti utilizzando il normale modello di programmazione Lambda.

Iniezione delle dipendenze con il framework Lambda Annotations

Puoi utilizzare il framework Lambda Annotations anche per aggiungere l'iniezione di dipendenze alle tue funzioni Lambda utilizzando una sintassi che conosci. Quando aggiungi un attributo [LambdaStartup] a un file Startup.cs, il framework Lambda Annotations genererà il codice richiesto in fase di compilazione.

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

La tua funzione Lambda può iniettare servizi utilizzando l'iniezione del costruttore o iniettandoli in metodi individuali utilizzando l'attributo [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);
    }
}

Best practice di codice per le funzioni Lambda con C#

Segui le linee guida riportate nell'elenco seguente per utilizzare le best practice di codifica durante la creazione delle funzioni Lambda:

• Separare il gestore Lambda dalla logica principale. In questo modo è possibile creare una funzione di cui è più semplice eseguire l'unit test.

• Controllare le dipendenze nel pacchetto di distribuzione della funzione. L'ambiente di esecuzione AWS Lambda contiene diverse librerie. Per abilitare il set di caratteristiche e aggiornamenti della sicurezza più recenti, Lambda aggiorna periodicamente tali librerie. Tali aggiornamenti possono introdurre lievi modifiche al comportamento della funzione Lambda. Per mantenere il controllo completo delle dipendenze utilizzate dalla funzione, inserire tutte le dipendenze nel pacchetto di implementazione.

• Ridurre la complessità delle dipendenze. Preferire framework più semplici che si caricano velocemente all'avvio del contesto di esecuzione.

• Ridurre al minimo le dimensioni del pacchetto di implementazione al fine di soddisfare le esigenze di runtime. In questo modo viene ridotta la quantità di tempo necessaria per il download del pacchetto e per la relativa decompressione prima dell'invocazione. Per le funzioni create in .NET, evitate di caricare l'intera libreria AWS SDK come parte del pacchetto di distribuzione. Utilizzare invece in modo selettivo i moduli che prelevano i componenti dell'SDK necessari (ad esempio i moduli SDK Dynamo DB e Amazon S3 e le librerie di base Lambda).

• Sfruttare il riutilizzo del contesto di esecuzione per migliorare le prestazioni della funzione. Inizializzare i client SDK e le connessioni al database all'esterno del gestore di funzioni e memorizzare localmente nella cache gli asset statici nella directory /tmp. Le chiamate successive elaborate dalla stessa istanza della funzione possono riutilizzare queste risorse. Ciò consente di risparmiare sui costi riducendo i tempi di esecuzione delle funzioni.

  Per evitare potenziali perdite di dati tra le chiamate, non utilizzare il contesto di esecuzione per archiviare dati utente, eventi o altre informazioni con implicazioni di sicurezza. Se la funzione si basa su uno stato mutabile che non può essere archiviato in memoria all'interno del gestore, considerare la possibilità di creare una funzione separata o versioni separate di una funzione per ogni utente.

• Utilizzare una direttiva keep-alive per mantenere le connessioni persistenti. Lambda elimina le connessioni inattive nel tempo. Se si tenta di riutilizzare una connessione inattiva quando si richiama una funzione, si verificherà un errore di connessione. Per mantenere la connessione persistente, utilizzare la direttiva keep-alive associata al runtime. Per un esempio, vedere Riutilizzo delle connessioni con Keep-Alive in Node.js.

• Utilizzare le variabili di ambiente per passare i parametri operativi alla funzione. Se ad esempio si scrive in un bucket Amazon S3 anziché impostare come hard-coded il nome del bucket in cui si esegue la scrittura, configurare tale nome come una variabile di ambiente.

• Evita di usare invocazioni ricorsive nella tua funzione Lambda, in cui la funzione si richiama da sola o avvia un processo che potrebbe richiamare nuovamente la funzione. Ciò potrebbe provocare un volume non desiderato di invocazioni della funzione e un aumento dei costi. Se noti un volume indesiderato di invocazioni, imposta immediatamente la simultaneità riservata della funzione su 0 per interrompere tutte le invocazioni della funzione mentre si aggiorna il codice.

• Non utilizzare documenti non documentati e non pubblici APIs nel codice della funzione Lambda. Per i runtime AWS Lambda gestiti, Lambda applica periodicamente aggiornamenti di sicurezza e funzionalità all'interno di Lambda. APIs Questi aggiornamenti delle API interne possono essere incompatibili con le versioni precedenti e portare a conseguenze indesiderate, come errori di chiamata se la funzione dipende da questi elementi non pubblici. APIs Consulta il riferimento alle API per un elenco di quelle disponibili al pubblico. APIs

• Scrivi un codice idempotente. La scrittura di un codice idempotente per le tue funzioni garantisce che gli eventi duplicati vengano gestiti allo stesso modo. Il tuo codice dovrebbe convalidare correttamente gli eventi e gestire con garbo gli eventi duplicati. Per ulteriori informazioni, consulta Come posso rendere idempotente la mia funzione Lambda?.