Kompilasi kode fungsi.NET Lambda ke format runtime asli

Untuk menginisialisasi dan menerapkan fungsi Lambda yang dikompilasi AOT asli

1. Inisialisasi proyek baru menggunakan template AOT asli dan kemudian navigasikan ke direktori yang berisi file yang dibuat .cs dan.csproj. Dalam contoh ini, kita menamai fungsi kitaNativeAotSample.

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

   Function.csFile yang dibuat oleh template AOT asli berisi kode fungsi berikut.

   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

   Native AOT mengkompilasi aplikasi Anda menjadi satu biner asli. Titik masuk biner itu adalah metodenya. static Main Di dalamstatic Main, runtime Lambda di-bootstrap dan metode disiapkan. FunctionHandler Sebagai bagian dari bootstrap runtime, serializer yang dihasilkan sumber dikonfigurasi menggunakan new SourceGeneratorLambdaJsonSerializer<LambdaFunctionJsonSerializerContext>()

2. Untuk menyebarkan aplikasi Anda ke Lambda, pastikan Docker berjalan di lingkungan lokal Anda dan jalankan perintah berikut.

   dotnet lambda deploy-function

   Di belakang layar, CLI global.NET mengunduh image AL2023 Docker dan mengkompilasi kode aplikasi Anda di dalam wadah yang sedang berjalan. Biner yang dikompilasi adalah output kembali ke sistem file lokal Anda sebelum diterapkan ke Lambda.

3. Uji fungsi Anda dengan menjalankan perintah berikut. Ganti <FUNCTION_NAME> dengan nama yang Anda pilih untuk fungsi Anda di wizard penerapan.

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

   Respons dari CLI mencakup detail kinerja untuk start dingin (durasi inisialisasi) dan total waktu berjalan untuk pemanggilan fungsi Anda.

4. Untuk menghapus AWS sumber daya yang Anda buat dengan mengikuti langkah-langkah sebelumnya, jalankan perintah berikut. Ganti <FUNCTION_NAME> dengan nama yang Anda pilih untuk fungsi Anda di wizard penerapan. Dengan menghapus AWS sumber daya yang tidak lagi Anda gunakan, Anda mencegah tagihan tagihan yang tidak perlu ditagih ke Anda. Akun AWS

   dotnet lambda delete-function <FUNCTION_NAME>