Tentukan pengendali fungsi Lambda di C #

Handler fungsi Lambda Anda adalah metode dalam kode fungsi Anda yang memproses peristiwa. Saat fungsi Anda diaktifkan, Lambda menjalankan metode handler. Fungsi Anda berjalan sampai handler mengembalikan respons, keluar, atau batas waktu.

Halaman ini menjelaskan cara bekerja dengan penangan fungsi Lambda di C# untuk bekerja dengan runtime terkelola .NET, termasuk opsi untuk penyiapan proyek, konvensi penamaan, dan praktik terbaik. Halaman ini juga menyertakan contoh fungsi C# Lambda yang mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini dalam bucket Amazon Simple Storage Service (S3). Untuk informasi tentang cara menerapkan fungsi Anda setelah menulisnya, lihat Bangun dan terapkan fungsi C# Lambda dengan arsip file.zip atauDeploy fungsi Lambda .NET dengan gambar kontainer.

Menyiapkan proyek pengendali C# Anda

Saat bekerja dengan fungsi Lambda di C #, prosesnya melibatkan penulisan kode Anda, kemudian menerapkan kode Anda ke Lambda. Ada dua model eksekusi yang berbeda untuk menerapkan fungsi Lambda di.NET: pendekatan perpustakaan kelas dan pendekatan perakitan yang dapat dieksekusi.

Dalam pendekatan perpustakaan kelas, Anda mengemas kode fungsi Anda sebagai rakitan .NET (.dll) dan menyebarkannya ke Lambda dengan runtime terkelola .NET (dotnet8). Untuk nama handler, Lambda mengharapkan string dalam formatAssemblyName::Namespace.Classname::Methodname. Selama fase inisialisasi fungsi, kelas fungsi Anda diinisialisasi, dan kode apa pun di konstruktor dijalankan.

Dalam pendekatan perakitan yang dapat dieksekusi, Anda menggunakan fitur pernyataan tingkat atas yang pertama kali diperkenalkan di C # 9. Pendekatan ini menghasilkan rakitan yang dapat dieksekusi yang dijalankan Lambda setiap kali menerima perintah invoke untuk fungsi Anda. Dalam pendekatan ini, Anda juga menggunakan runtime terkelola .NET (dotnet8). Untuk nama handler, Anda memberikan Lambda dengan nama rakitan yang dapat dieksekusi untuk dijalankan.

Contoh utama pada halaman ini menggambarkan pendekatan perpustakaan kelas. Anda dapat menginisialisasi proyek C# Lambda Anda dengan berbagai cara, tetapi cara termudah adalah dengan menggunakan.NET CLI dengan CLI. Amazon.Lambda.Tools Siapkan Amazon.Lambda.Tools CLI dengan mengikuti langkah-langkah diMenyiapkan lingkungan pengembangan .NET Anda. Kemudian, inisialisasi proyek Anda dengan perintah berikut:

dotnet new lambda.EmptyFunction --name ExampleCS

Perintah ini menghasilkan struktur file berikut:

/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 

Dalam struktur file ini, logika handler utama untuk fungsi Anda berada di Function.cs file.

Contoh kode fungsi C# Lambda

Contoh kode fungsi C# Lambda berikut mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini dalam bucket Amazon S3.

contoh Function.csFungsi lambda

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

Function.csFile ini berisi bagian kode berikut:

• usingpernyataan: Gunakan ini untuk mengimpor kelas C# yang dibutuhkan fungsi Lambda Anda.

• [assembly: LambdaSerializer(...)]: LambdaSerializer adalah atribut perakitan yang memberi tahu Lambda untuk secara otomatis mengonversi muatan peristiwa JSON menjadi objek C# sebelum meneruskannya ke fungsi Anda.

• namespace ExampleLambda: Ini mendefinisikan namespace. Di C#, nama namespace tidak harus cocok dengan nama file.

• public class Order {...}: Ini mendefinisikan bentuk peristiwa input yang diharapkan.

• public class OrderHandler {...}: Ini mendefinisikan kelas C # Anda. Di dalamnya, Anda akan menentukan metode handler utama dan metode pembantu lainnya.

• private static readonly AmazonS3Client s3Client = new();: Ini menginisialisasi klien Amazon S3 dengan rantai penyedia kredensia default, di luar metode pengendali utama. Hal ini menyebabkan Lambda menjalankan kode ini selama fase in isialisasi.

• public async ... HandleRequest (Order order, ILambdaContext context): Ini adalah metode handler utama, yang berisi logika aplikasi utama Anda.

• private async Task UploadReceiptToS3(...) {}: Ini adalah metode pembantu yang direferensikan oleh metode handleRequest handler utama.

Karena fungsi ini memerlukan klien Amazon S3 SDK, Anda harus menambahkannya ke dependensi proyek Anda. Anda dapat melakukannya dengan menavigasi ke src/ExampleCS dan menjalankan perintah berikut:

dotnet add package AWSSDK.S3

Tambahkan informasi metadata ke aws-lambda-tools-defaults.json

Secara default, aws-lambda-tools-defaults.json file yang dihasilkan tidak berisi profile atau region informasi untuk fungsi Anda. Selain itu, perbarui function-handler string ke nilai yang benar (ExampleCS::ExampleLambda.OrderHandler::HandleRequest). Anda dapat membuat pembaruan ini secara manual dan menambahkan metadata yang diperlukan untuk menggunakan profil kredenSIAL tertentu dan wilayah untuk fungsi Anda. Misalnya, aws-lambda-tools-defaults.json file Anda akan terlihat mirip dengan ini:

{
  "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"
}

Agar fungsi ini berfungsi dengan baik, peran pelaksanaannya harus memungkinkan s3:PutObject tindakan. Juga, pastikan Anda mendefinisikan variabel RECEIPT_BUCKET lingkungan. Setelah pemanggilan berhasil, bucket Amazon S3 harus berisi file tanda terima.

Penangan perpustakaan kelas

Kode contoh utama pada halaman ini menggambarkan pengendali pustaka kelas. Penangan pustaka kelas memiliki struktur sebagai berikut:

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

namespace NAMESPACE;

...

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

Saat Anda membuat fungsi Lambda, Anda perlu memberikan Lambda informasi tentang handler fungsi Anda dalam bentuk string di bidang Handler. Ini memberi tahu Lambda metode mana dalam kode Anda yang akan dijalankan ketika fungsi Anda dipanggil. Di C#, untuk penangan pustaka kelas, format string handler adalahASSEMBLY::TYPE::METHOD, di mana:

• ASSEMBLYadalah nama file perakitan .NET untuk aplikasi Anda. Jika Anda menggunakan Amazon.Lambda.Tools CLI untuk membangun aplikasi Anda dan Anda tidak mengatur nama rakitan menggunakan AssemblyName properti dalam .csproj file, maka ASSEMBLY itu hanya nama .csproj file Anda.

• TYPEadalah nama lengkap dari tipe handler, yaituNAMESPACE.CLASSNAME.

• METHODadalah nama metode handler utama dalam kode Anda, yaituMETHODNAME.

Untuk kode contoh utama pada halaman ini, jika rakitan diberi namaExampleCS, maka string handler lengkap adalahExampleCS::ExampleLambda.OrderHandler::HandleRequest.

Penangan perakitan yang dapat dieksekusi

Anda juga dapat mendefinisikan fungsi Lambda di C# sebagai rakitan yang dapat dieksekusi. Handler perakitan yang dapat dieksekusi menggunakan fitur pernyataan tingkat atas C#, di mana kompiler menghasilkan Main() metode dan menempatkan kode fungsi Anda di dalamnya. Saat menggunakan rakitan yang dapat dieksekusi, runtime Lambda harus di-bootstrap.

Untuk melakukan ini, gunakan LambdaBootstrapBuilder.Create metode dalam kode Anda. Input ke metode ini adalah fungsi handler utama serta serializer Lambda untuk digunakan. Berikut ini menunjukkan contoh handler perakitan yang dapat dieksekusi di 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)
    };
};

Di bidang Handler untuk penangan perakitan yang dapat dieksekusi, string handler yang memberi tahu Lambda cara menjalankan kode Anda adalah nama rakitan. Dalam contoh ini, ituGetProductHandler.

Tanda tangan handler yang valid untuk fungsi C #

Di C#, tanda tangan pengendali Lambda yang valid mengambil antara 0 dan 2 argumen. Biasanya, tanda tangan handler Anda memiliki dua argumen, seperti yang ditunjukkan pada contoh utama:

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

Saat memberikan dua argumen, argumen pertama harus input peristiwa, dan argumen kedua harus objek konteks Lambda. Kedua argumen tersebut bersifat opsional. Misalnya, berikut ini juga merupakan tanda tangan pengendali Lambda yang valid di C#:

• public async Task<string> HandleRequest()

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

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

Terlepas dari sintaks dasar dari tanda tangan handler, ada beberapa batasan tambahan:

• Anda tidak dapat menggunakan unsafe kata kunci dalam tanda tangan handler. Namun, Anda dapat menggunakan unsafe konteks di dalam metode handler dan dependensinya. Untuk informasi selengkapnya, lihat tidak aman (referensi C#) di situs web dokumentasi Microsoft.

• Handler tidak dapat menggunakan params kata kunci, atau digunakan ArgIterator sebagai parameter input atau return. Kata kunci ini mendukung sejumlah variabel parameter. Jumlah maksimum argumen yang dapat diterima handler Anda adalah dua.

• Handler tidak bisa menjadi metode generik. Dengan kata lain, itu tidak dapat menggunakan parameter tipe generik seperti<T>.

• Lambda tidak mendukung penangan asinkron dengan async void tanda tangan.

Konvensi penamaan handler

Penangan Lambda di C# tidak memiliki batasan penamaan yang ketat. Namun, Anda harus memastikan bahwa Anda memberikan string handler yang benar ke Lambda saat Anda menerapkan fungsi Anda. String handler yang tepat bergantung pada apakah Anda menerapkan pengendali pustaka kelas atau handler perakitan yang dapat dieksekusi.

Meskipun Anda dapat menggunakan nama apa pun untuk handler Anda, nama fungsi di C # umumnya ada di PascalCase. Juga, meskipun nama file tidak perlu cocok dengan nama kelas atau nama handler, umumnya praktik terbaik untuk menggunakan nama file seperti OrderHandler.cs jika nama kelas Anda adalahOrderHandler. Misalnya, Anda dapat mengubah nama file dalam contoh ini dari Function.cs keOrderHandler.cs.

Serialisasi dalam fungsi C# Lambda

JSON adalah format input yang paling umum dan standar untuk fungsi Lambda. Dalam contoh ini, fungsi mengharapkan input yang mirip dengan berikut ini:

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

Di C#, Anda dapat menentukan bentuk peristiwa input yang diharapkan di kelas. Dalam contoh ini, kita mendefinisikan Order kelas untuk memodelkan input ini:

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

Jika fungsi Lambda menggunakan tipe input atau output selain Stream objek, Anda harus menambahkan pustaka serialisasi ke aplikasi Anda. Anda kemudian dapat mengonversi input JSON menjadi instance kelas yang Anda tentukan. Ada dua metode serialisasi untuk fungsi C# di Lambda: serialisasi berbasis refleksi dan serialisasi yang dihasilkan sumber.

Reflection-based serialisasi

AWS menyediakan pustaka pra-bangun yang dapat Anda tambahkan dengan cepat ke aplikasi Anda. Perpustakaan ini menerapkan serialisasi menggunakan refleksi. Gunakan salah satu paket berikut untuk mengimplementasikan serialisasi berbasis refleksi:

• Amazon.Lambda.Serialization.SystemTextJson- Di backend, paket ini digunakan System.Text.Json untuk melakukan tugas serialisasi.

• Amazon.Lambda.Serialization.Json- Di backend, paket ini digunakan Newtonsoft.Json untuk melakukan tugas serialisasi.

Anda juga dapat membuat pustaka serialisasi Anda sendiri dengan menerapkan ILambdaSerializer antarmuka, yang tersedia sebagai bagian dari pust Amazon.Lambda.Core aka. Antarmuka ini mendefinisikan dua metode:

• T Deserialize<T>(Stream requestStream);

  Anda menerapkan metode ini untuk mendeserialisasi payload permintaan dari Invoke API ke objek yang diteruskan ke pengendali fungsi Lambda Anda.

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

  Anda menerapkan metode ini untuk membuat serial hasil yang dikembalikan dari pengendali fungsi Lambda Anda ke dalam payload respons yang dikembalikan oleh operasi Invoke API.

Contoh utama di halaman ini menggunakan serialisasi berbasis refleksi. Reflection-based serialisasi bekerja di luar kotak dengan AWS Lambda dan tidak memerlukan pengaturan tambahan, menjadikannya pilihan yang baik untuk kesederhanaan. Namun, itu memang membutuhkan lebih banyak penggunaan memori fungsi. Anda mungkin juga melihat latensi fungsi yang lebih tinggi karena refleksi runtime.

Source-generated serialisasi

Dengan serialisasi yang dihasilkan sumber, kode serialisasi dihasilkan pada waktu kompilasi. Ini menghilangkan kebutuhan untuk refleksi dan dapat meningkatkan kinerja fungsi Anda. Untuk menggunakan serialisasi yang dihasilkan sumber dalam fungsi Anda, Anda harus melakukan hal berikut:

• Buat kelas parSIAL baru yang mewarisi dariJsonSerializerContext, menambahkan JsonSerializable atribut untuk semua jenis yang memerlukan serialisasi atau deserialisasi.

• Konfigurasikan LambdaSerializer untuk menggunakan aSourceGeneratorLambdaJsonSerializer<T>.

• Perbarui serialisasi manual dan deserialisasi dalam kode aplikasi Anda untuk menggunakan kelas yang baru dibuat.

Contoh berikut menunjukkan bagaimana Anda dapat memodifikasi contoh utama pada halaman ini, yang menggunakan serialisasi berbasis refleksi, untuk menggunakan serialisasi yang dihasilkan sumber sebagai gantinya.

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

}

Source-generated serialisasi membutuhkan lebih banyak pengaturan daripada serialisasi berbasis refleksi. Namun, fungsi yang menggunakan sumber yang dihasilkan cenderung menggunakan lebih sedikit memori dan memiliki kinerja yang lebih baik karena pembuatan kode waktu kompilasi. Untuk membantu menghilangkan fungsi cold start, pertimbangkan untuk beralih ke serialisasi yang dihasilkan sumber.

catatan

Jika Anda ingin menggunakan kompilasi ahead-of-time asli (AOT) dengan Lambda, Anda harus menggunakan serialisasi yang dihasilkan sumber.

File-based fungsi

Diperkenalkan di.NET 10, aplikasi berbasis file memungkinkan Anda membangun aplikasi.NET dari satu .cs file, tanpa struktur .csproj file atau direktori. Lambda mendukung fungsi berbasis file, dimulai dengan.NET 10. Mereka menawarkan cara yang efisien dan ringan untuk membangun fungsi Lambda di C #.

Cara tercepat untuk mulai membuat fungsi Lambda berbasis file C# adalah dengan menggunakan paket. Amazon.Lambda.Templates Untuk memasang paket, jalankan perintah berikut:

dotnet new install Amazon.Lambda.Templates

Selanjutnya, buat fungsi contoh Lambda berbasis file C#:

dotnet new lambda.FileBased -n MyLambdaFunction

File-based fungsi menggunakan handler perakitan yang dapat dieksekusi. Oleh karena itu Anda harus menyer Amazon.Lambda.RuntimeSupport NuGet takan paket dan menggunakan LambdaBootstrapBuilder.Create metode untuk mendaftarkan fungsi.NET handler untuk jenis peristiwa dan memulai klien runtime .NET Lambda.

File-based fungsi menggunakan.NET Native AOT secara default, yang memerlukan serialisasi yang dihasilkan sumber. Anda dapat menonaktifkan AOT Asli dengan menentukan #:property PublishAot=false di file sumber Anda. Untuk informasi lebih lanjut tentang menggunakan AOT Asli di Lambda, lihat. Kompilasi kode fungsi.NET Lambda ke format runtime asli

Mengakses dan menggunakan objek konteks Lambda

Objek konteks Lambda berisi informasi tentang pemanggilan, fungsi, dan lingkungan eksekusi. Dalam contoh ini, objek konteks adalah tipeAmazon.Lambda.Core.ILambdaContext, dan merupakan argumen kedua dari fungsi handler utama.

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

Objek konteks adalah input opsional. Untuk informasi selengkapnya tentang tanda tangan penangan yang diterima yang valid, lihatTanda tangan handler yang valid untuk fungsi C #.

Objek konteks berguna untuk menghasilkan log fungsi ke Amazon CloudWatch. Anda dapat menggunakan context.getLogger() metode ini untuk mendapatkan LambdaLogger objek untuk logging. Dalam contoh ini, kita dapat menggunakan logger untuk mencatat pesan kesalahan jika pemrosesan gagal karena alasan apa pun:

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

Di luar logging, Anda juga dapat menggunakan objek konteks untuk pemantauan fungsi. Untuk informasi selengkapnya tentang objek konteks, lihatMenggunakan objek konteks Lambda untuk mengambil informasi fungsi C #.

Menggunakan SDK untuk .NET v3 di handler Anda

Seringkali, Anda akan menggunakan fungsi Lambda untuk berinteraksi dengan atau membuat pembaruan ke AWS sumber daya lain. Cara paling sederhana untuk berinteraksi dengan sumber daya ini adalah dengan menggunakan SDK untuk .NET v3.

catatan

SDK untuk .NET (v2) tidak digunakan lagi. Kami menyarankan Anda hanya menggunakan SDK untuk .NET v3.

Anda dapat menambahkan dependensi SDK ke proyek Anda menggunakan Amazon.Lambda.Tools perintah berikut:

dotnet add package <package_name>

Misalnya, dalam contoh utama di halaman ini, kita perlu menggunakan Amazon S3 API untuk mengunggah tanda terima ke S3. Kami dapat mengimpor klien Amazon S3 SDK dengan perintah berikut:

dotnet add package AWSSDK.S3

Perintah ini menambahkan ketergantungan ke proyek Anda. Anda juga harus melihat baris yang mirip dengan berikut ini di .csproj file proyek Anda:

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

Kemudian, impor dependensi langsung di kode C # Anda:

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

Kode contoh kemudian menginisialisasi klien Amazon S3 (menggunakan rantai penyedia kreden sia default) sebagai berikut:

private static readonly AmazonS3Client s3Client = new();

Dalam contoh ini, kami menginisialisasi klien Amazon S3 kami di luar fungsi handler utama untuk menghindari keharusan menginisialisasi setiap kali kami memanggil fungsi kami. Setelah menginisialisasi klien SDK, Anda kemudian dapat menggunakannya untuk berinteraksi dengan AWS layanan lain. Kode contoh memanggil PutObject API Amazon S3 sebagai berikut:

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

await s3Client.PutObjectAsync(putRequest);

Mengakses variabel lingkungan

Dalam kode handler Anda, Anda dapat mereferensikan variabel lingkungan apa pun dengan menggunakan System.Environment.GetEnvironmentVariable metode ini. Dalam contoh ini, kita mereferensi RECEIPT_BUCKET kan variabel lingkungan yang ditentukan menggunakan baris kode berikut:

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

Menggunakan status global

Lambda menjalankan kode statis Anda dan konstruktor kelas selama fase in isialisasi sebelum memanggil fungsi Anda untuk pertama kalinya. Sumber daya yang dibuat selama inisialisasi tetap berada di memori di antara pemanggilan, sehingga Anda dapat menghindari keharusan membuatnya setiap kali Anda memanggil fungsi Anda.

Dalam kode contoh, kode inisialisasi klien S3 berada di luar metode handler utama. Runtime menginisialisasi klien sebelum fungsi menangani peristiwa pertamanya, yang dapat menyebabkan waktu pemrosesan yang lebih lama. Peristiwa selanjutnya jauh lebih cepat karena Lambda tidak perlu menginisialisasi klien lagi.

Sederhanakan kode fungsi dengan kerangka Lambda Annotations

Lambda Annotations adalah kerangka kerja untuk.NET 8 yang menyederhanakan penulisan fungsi Lambda menggunakan C#. Kerangka kerja Anotasi menggunakan generator sumber untuk menghasilkan kode yang diterjemahkan dari model pemrograman Lambda ke kode yang disederhanakan. Dengan kerangka kerja Anotasi, Anda dapat mengganti banyak kode dalam fungsi Lambda yang ditulis menggunakan model pemrograman reguler. Kode yang ditulis menggunakan kerangka kerja menggunakan ekspresi sederhana yang memungkinkan Anda untuk fokus pada logika bisnis Anda. Lihat Amazon.Lambda.Annotations di dokumentasi nuget untuk contoh.

Untuk contoh aplikasi lengkap menggunakan Lambda Annotations, lihat PhotoAssetManager contoh di repositori. awsdocs/aws-doc-sdk-examples GitHub Function.csFile utama dalam PamApiAnnotations direktori menggunakan Lambda Annotations. Sebagai perbandingan, PamApi direktori memiliki file setara yang ditulis menggunakan model pemrograman Lambda biasa.

Injeksi ketergantungan dengan kerangka kerja Anotasi Lambda

Anda juga dapat menggunakan kerangka Lambda Annotations untuk menambahkan injeksi ketergantungan ke fungsi Lambda Anda menggunakan sintaks yang Anda kenal. Saat Anda menambahkan [LambdaStartup] atribut ke Startup.cs file, kerangka Lambda Annotations menghasilkan kode yang diperlukan pada waktu kompilasi.

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

Fungsi Lambda Anda dapat menyuntikkan layanan menggunakan injeksi konstruktor atau dengan menyuntikkan ke metode individual menggunakan atribut. [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);
    }
}

Praktik terbaik kode untuk fungsi C# Lambda

Patuhi pedoman dalam daftar berikut untuk menggunakan praktik pengkodean terbaik saat membangun fungsi Lambda Anda:

• Pisahkan handler Lambda dari logika inti Anda. Dengan pendekatan ini, Anda dapat membuat fungsi yang lebih dapat diuji unit.

• Kontrol dependensi dalam paket penerapan fungsi Anda. Lingkungan AWS Lambda eksekusi berisi sejumlah pustaka. Untuk mengaktifkan serangkaian fitur terbaru dan pembaruan keamanan, Lambda memperbarui pustaka ini secara berkala. Pembaruan ini mungkin memperkenalkan perubahan halus pada perilaku fungsi Lambda Anda. Untuk memiliki kendali penuh atas dependensi yang digunakan fungsi Anda, kemas semua dependensi Anda dengan paket deployment Anda.

• Minimalkan kompleksitas dependensi Anda. Utamakan memilih kerangka kerja lebih sederhana yang cepat dimuat dalam memulai lingkungan eksekusi.

• Minimalkan ukuran paket penerapan Anda sesuai kebutuhan runtime. Ini mengurangi jumlah waktu yang diperlukan untuk paket penerapan Anda untuk diunduh dan dibongkar sebelum pemanggilan. Untuk fungsi yang ditulis di.NET, hindari mengunggah seluruh pustaka AWS SDK sebagai bagian dari paket penerapan Anda. Sebaliknya, secara selektif bergantung pada modul yang mengambil komponen SDK yang Anda butuhkan (misalnya, DynamoDB, modul SDK Amazon S3, dan perpustakaan inti Lambda).

Manfaatkan penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda. Inisialisasi klien SDK dan koneksi basis data di luar fungsi handler, dan lakukan caching aset statis secara lokal di direktori /tmp. Invokasi selanjutnya yang diproses oleh instans yang sama dari fungsi Anda dapat menggunakan kembali sumber daya ini. Ini menghemat biaya dengan mengurangi waktu pengoperasian fungsi.

Untuk menghindari potensi kebocoran data di seluruh invokasi, jangan menggunakan lingkungan eksekusi untuk menyimpan data pengguna, peristiwa, atau informasi lainnya implikasi keamanan. Jika fungsi Anda bergantung pada status yang dapat disenyapkan yang tidak dapat disimpan dalam memori di dalam handler, pertimbangkan untuk membuat fungsi terpisah atau versi terpisah dari fungsi untuk setiap pengguna.

Gunakan direktif keep-alive untuk mempertahankan koneksi yang persisten. Lambda membersihkan koneksi idle dari waktu ke waktu. Mencoba menggunakan ulang koneksi idle saat mengidentifikasi suatu fungsi akan menyebabkan kesalahan koneksi. Untuk mempertahankan koneksi yang persisten, gunakan arahan tetap aktif yang berkaitan dengan runtime Anda. Sebagai contoh, lihat Menggunakan Kem bali Koneksi dengan Keep-Alive in Node.js.

Gunakan variabel lingkungan untuk meneruskan parameter operasional ke fungsi Anda. Misalnya, jika Anda ingin menulis ke bucket Amazon S3 alih-alih melakukan hard-coding nama bucket yang Anda tulis, konfigurasikan nama bucket sebagai variabel lingkungan.

Hindari menggunakan pemanggilan rekursif dalam fungsi Lambda Anda, di mana fungsi memanggil dirinya sendiri atau memulai proses yang dapat memanggil fungsi lagi. Hal ini dapat menyebabkan volume invokasi fungsi yang tidak diinginkan dan peningkatan biaya. Jika Anda melihat volume pemanggilan yang tidak diinginkan, setel fungsi reservasi konkurensi ke 0 segera untuk membatasi semua pemanggilan ke fungsi, saat Anda memperbarui kode.

Jangan gunakan API non-publik yang tidak terdokumentasi dalam kode fungsi Lambda Anda. Untuk runtime AWS Lambda terkelola, Lambda secara berkala menerapkan pembaruan keamanan dan fungsional ke API internal Lambda. Pembaruan API internal ini mungkin tidak kompatibel ke belakang, yang menyebabkan konsekuensi yang tidak diinginkan seperti kegagalan pemanggilan jika fungsi Anda memiliki ketergantungan pada API non-publik ini. Lihat referensi API untuk daftar API yang tersedia untuk umum.

Tulis kode idempotent. Menulis kode idempotent untuk fungsi Anda memastikan bahwa peristiwa duplikat ditangani dengan cara yang sama. Kode Anda harus memvalidasi peristiwa dengan benar dan menangani peristiwa duplikat dengan anggun. Untuk informasi lebih lanjut, lihat Bagaimana cara membuat fungsi Lambda saya idempoten? .