Compilare il codice della funzione.NET Lambda in un formato di runtime nativo

Inizializzazione e distribuzione di una funzione Lambda compilata in AOT nativa

1. Inizializza un nuovo progetto utilizzando il modello AOT nativo, quindi naviga nella directory contenente i file .cs e .csproj creati. In questo esempio, diamo un nome alla nostra funzione NativeAotSample.

   dotnet new lambda.NativeAOT -n NativeAotSample
   cd ./NativeAotSample/src/NativeAotSample

   Il file Function.cs creato dal modello AOT nativo contiene il seguente codice di funzione.

   using Amazon.Lambda.Core;
   using Amazon.Lambda.RuntimeSupport;
   using Amazon.Lambda.Serialization.SystemTextJson;
   using System.Text.Json.Serialization;
   
   namespace NativeAotSample;
   
   public class Function
   {
       /// <summary>
       /// The main entry point for the Lambda function. The main function is called once during the Lambda init phase. It
       /// initializes the .NET Lambda runtime client passing in the function handler to invoke for each Lambda event and
       /// the JSON serializer to use for converting Lambda JSON format to the .NET types.
       /// </summary>
       private static async Task Main()
       {
           Func<string, ILambdaContext, string> handler = FunctionHandler;
           await LambdaBootstrapBuilder.Create(handler, new SourceGeneratorLambdaJsonSerializer<LambdaFunctionJsonSerializerContext>())
               .Build()
               .RunAsync();
       }
   
       /// <summary>
       /// A simple function that takes a string and does a ToUpper.
       ///
       /// To use this handler to respond to an AWS event, reference the appropriate package from
       /// https://github.com/aws/aws-lambda-dotnet#events
       /// and change the string input parameter to the desired event type. When the event type
       /// is changed, the handler type registered in the main method needs to be updated and the LambdaFunctionJsonSerializerContext
       /// defined below will need the JsonSerializable updated. If the return type and event type are different then the
       /// LambdaFunctionJsonSerializerContext must have two JsonSerializable attributes, one for each type.
       ///
       // When using Native AOT extra testing with the deployed Lambda functions is required to ensure
       // the libraries used in the Lambda function work correctly with Native AOT. If a runtime
       // error occurs about missing types or methods the most likely solution will be to remove references to trim-unsafe
       // code or configure trimming options. This sample defaults to partial TrimMode because currently the AWS
       // SDK for .NET does not support trimming. This will result in a larger executable size, and still does not
       // guarantee runtime trimming errors won't be hit.
       /// </summary>
       /// <param name="input"></param>
       /// <param name="context"></param>
       /// <returns></returns>
       public static string FunctionHandler(string input, ILambdaContext context)
       {
           return input.ToUpper();
       }
   }
   
   /// <summary>
   /// This class is used to register the input event and return type for the FunctionHandler method with the System.Text.Json source generator.
   /// There must be a JsonSerializable attribute for each type used as the input and return type or a runtime error will occur
   /// from the JSON serializer unable to find the serialization information for unknown types.
   /// </summary>
   [JsonSerializable(typeof(string))]
   public partial class LambdaFunctionJsonSerializerContext : JsonSerializerContext
   {
       // By using this partial class derived from JsonSerializerContext, we can generate reflection free JSON Serializer code at compile time
       // which can deserialize our class and properties. However, we must attribute this class to tell it what types to generate serialization code for.
       // See https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-source-generation

   AOT nativo compila l'applicazione in un unico binario nativo. Il punto di ingresso di quel binario è il metodo static Main. All'interno di static Main, viene avviato il runtime Lambda e viene impostato il metodo FunctionHandler. Come parte del bootstrap di runtime, un serializzatore generato dal codice sorgente viene configurato utilizzando new SourceGeneratorLambdaJsonSerializer<LambdaFunctionJsonSerializerContext>()

2. Per distribuire l'applicazione in Lambda, assicurati che Docker sia in esecuzione nel tuo ambiente locale ed esegui il comando riportato.

   dotnet lambda deploy-function

   Dietro le quinte, la CLI globale.NET scarica un'immagine Docker AL2023 e compila il codice dell'applicazione all'interno di un container in esecuzione. Il file binario compilato viene restituito al file system locale prima di essere implementato su Lambda.

3. Verifica la tua funzione eseguendo il comando riportato. Sostituisci <FUNCTION_NAME> con il nome scelto per la funzione nella procedura guidata di implementazione.

   dotnet lambda invoke-function <FUNCTION_NAME> --payload "hello world"

   La risposta della CLI include dettagli sulle prestazioni per l'avvio a freddo (durata di inizializzazione) e il tempo di esecuzione totale per l'invocazione della funzione.

4. Per eliminare le AWS risorse create seguendo i passaggi precedenti, esegui il comando seguente. Sostituisci <FUNCTION_NAME> con il nome scelto per la funzione nella procedura guidata di implementazione. Eliminando AWS le risorse che non utilizzi più, eviti che ti vengano addebitati addebiti inutili. Account AWS

   dotnet lambda delete-function <FUNCTION_NAME>