Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun fungsi Lambda dengan C\$1
Anda dapat menjalankan aplikasi.NET Anda di Lambda menggunakan runtime .NET 8 yang dikelola, runtime kustom, atau image container. Setelah kode aplikasi dikompilasi, Anda dapat menerapkannya ke Lambda baik sebagai file.zip atau gambar kontainer. Lambda menyediakan runtime berikut untuk bahasa.NET:
| Nama | Pengidentifikasi | Sistem operasi | Tanggal pengusangan | Buat fungsi blok | Pembaruan fungsi blok |
| --- | --- | --- | --- | --- | --- |
| .NET 10 | `dotnet10` | Amazon Linux 2023 | Nov 14, 2028 | 14 Des 2028 | 15 Jan 2029 |
| .NET 9 (hanya wadah) | `dotnet9` | Amazon Linux 2023 | Nov 10, 2026 | Tidak dijadwalkan | Tidak dijadwalkan |
| .NET 8 | `dotnet8` | Amazon Linux 2023 | Nov 10, 2026 | 10 Des 2026 | 11 Jan 2027 |
## Menyiapkan lingkungan pengembangan .NET Anda
Untuk mengembangkan dan membangun fungsi Lambda Anda, Anda dapat menggunakan salah satu lingkungan pengembangan terintegrasi .NET yang umum tersedia (IDEs), termasuk Microsoft Visual Studio, Visual Studio Code, dan JetBrains Rider. Untuk menyederhanakan pengalaman pengembangan Anda, AWS sediakan satu set template proyek.NET, serta antarmuka baris `Amazon.Lambda.Tools` perintah (CLI).
Jalankan perintah.NET CLI berikut untuk menginstal template proyek dan alat baris perintah ini.
### Menginstal template proyek.NET
Untuk menginstal template proyek, jalankan perintah berikut:
```
dotnet new install Amazon.Lambda.Templates
```
### Menginstal dan memperbarui alat CLI
Jalankan perintah berikut untuk menginstal, memperbarui, dan menghapus `Amazon.Lambda.Tools` CLI.
Untuk menginstal alat baris perintah:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Untuk memperbarui alat baris perintah:
```
dotnet tool update -g Amazon.Lambda.Tools
```
Untuk menghapus alat baris perintah:
```
dotnet tool uninstall -g Amazon.Lambda.Tools
```
# Tentukan penangan fungsi Lambda di C \$1
*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 waktu habis.
Halaman ini menjelaskan cara bekerja dengan penangan fungsi Lambda di C\$1 untuk bekerja dengan runtime yang dikelola .NET, termasuk opsi untuk penyiapan proyek, konvensi penamaan, dan praktik terbaik. Halaman ini juga menyertakan contoh fungsi C\$1 Lambda yang mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon Simple Storage Service (S3). Untuk informasi tentang cara menerapkan fungsi Anda setelah menulisnya, lihat [Bangun dan terapkan fungsi C\$1 Lambda dengan arsip file.zip](csharp-package.md) atau[Deploy fungsi Lambda .NET dengan gambar kontainer](csharp-image.md).
**Topics**
+ [Menyiapkan proyek handler C\$1 Anda](#csharp-handler-setup)
+ [Contoh kode fungsi C\$1 Lambda](#csharp-example-code)
+ [Penangan perpustakaan kelas](#csharp-class-library-handlers)
+ [Penangan perakitan yang dapat dieksekusi](#csharp-executable-assembly-handlers)
+ [Tanda tangan handler yang valid untuk fungsi C \$1](#csharp-handler-signatures)
+ [Konvensi penamaan handler](#csharp-handler-naming)
+ [Serialisasi dalam fungsi C\$1 Lambda](#csharp-handler-serializer)
+ [Fungsi berbasis file](#csharp-file-based-functions)
+ [Mengakses dan menggunakan objek konteks Lambda](#csharp-example-context)
+ [Menggunakan SDK untuk .NET v3 di handler Anda](#csharp-example-sdk-usage)
+ [Mengakses variabel lingkungan](#csharp-example-envvars)
+ [Menggunakan status global](#csharp-handler-state)
+ [Sederhanakan kode fungsi dengan kerangka kerja Anotasi Lambda](#csharp-handler-annotations)
+ [Praktik terbaik kode untuk fungsi C\$1 Lambda](#csharp-best-practices)
## Menyiapkan proyek handler C\$1 Anda
Saat bekerja dengan fungsi Lambda di C \$1, prosesnya melibatkan penulisan kode Anda, lalu menyebarkan 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 pustaka kelas, Anda mengemas kode fungsi Anda sebagai .NET assembly (`.dll`) dan menerapkannya ke Lambda dengan runtime `dotnet8` terkelola .NET (). Untuk nama handler, Lambda mengharapkan string dalam format. `AssemblyName::Namespace.Classname::Methodname` Selama fase inisialisasi fungsi, kelas fungsi Anda diinisialisasi, dan kode apa pun dalam konstruktor dijalankan.
Dalam pendekatan perakitan yang dapat dieksekusi, Anda menggunakan [fitur pernyataan tingkat atas](https://learn.microsoft.com/en-us/dotnet/csharp/tutorials/top-level-statements) yang pertama kali diperkenalkan di C \$1 9. Pendekatan ini menghasilkan perakitan yang dapat dieksekusi yang dijalankan Lambda setiap kali menerima perintah pemanggilan untuk fungsi Anda. Dalam pendekatan ini, Anda juga menggunakan .NET managed runtime (`dotnet8`). Untuk nama handler, Anda memberi Lambda nama rakitan yang dapat dieksekusi untuk dijalankan.
Contoh utama pada halaman ini menggambarkan pendekatan perpustakaan kelas. Anda dapat menginisialisasi proyek C\$1 Lambda Anda dengan berbagai cara, tetapi cara termudah adalah dengan menggunakan CLI .NET dengan CLI. `Amazon.Lambda.Tools` Siapkan `Amazon.Lambda.Tools` CLI dengan mengikuti langkah-langkah di. [Menyiapkan lingkungan pengembangan .NET Anda](lambda-csharp.md#csharp-dev-env) 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\$1 Lambda
Contoh kode fungsi C\$1 Lambda berikut mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di bucket Amazon S3.
**Example `Function.cs`Fungsi 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 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.cs`File ini berisi bagian kode berikut:
+ `using`pernyataan: Gunakan ini untuk mengimpor kelas C\$1 yang diperlukan oleh fungsi Lambda Anda.
+ `[assembly: LambdaSerializer(...)]`: `LambdaSerializer` adalah atribut assembly yang memberi tahu Lambda untuk secara otomatis mengonversi muatan acara JSON menjadi objek C \$1 sebelum meneruskannya ke fungsi Anda.
+ `namespace ExampleLambda`: Ini mendefinisikan namespace. Di C \$1, 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 \$1 Anda. Di dalamnya, Anda akan mendefinisikan metode handler utama dan metode pembantu lainnya.
+ `private static readonly AmazonS3Client s3Client = new();`: Ini menginisialisasi klien Amazon S3 dengan rantai penyedia kredensi default, di luar metode penangan utama. Hal ini menyebabkan Lambda menjalankan kode ini selama fase [inisialisasi](lambda-runtime-environment.md#runtimes-lifecycle-ib).
+ `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 helper yang direferensikan oleh metode `handleRequest` handler utama.
Karena fungsi ini memerlukan klien SDK Amazon S3, 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.json aws-lambda-tools-defaults
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 dan wilayah kredensil tertentu 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](lambda-intro-execution-role.md) harus memungkinkan `s3:PutObject` tindakan. Juga, pastikan bahwa Anda mendefinisikan variabel `RECEIPT_BUCKET` lingkungan. Setelah pemanggilan berhasil, bucket Amazon S3 harus berisi file tanda terima.
## Penangan perpustakaan kelas
[Contoh kode](#csharp-example-code) utama pada halaman ini menggambarkan handler perpustakaan kelas. Penangan perpustakaan kelas memiliki struktur berikut:
```
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace NAMESPACE;
...
public class CLASSNAME {
public async Task METHODNAME (...) {
...
}
}
```
[Saat Anda membuat fungsi Lambda, Anda perlu memberikan Lambda informasi tentang handler fungsi Anda dalam bentuk string di bidang Handler.](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Handler) Ini memberi tahu Lambda metode mana dalam kode Anda untuk dijalankan ketika fungsi Anda dipanggil. Di C \$1, untuk penangan perpustakaan kelas, format string handler adalah`ASSEMBLY::TYPE::METHOD`, di mana:
+ `ASSEMBLY`adalah nama file perakitan .NET untuk aplikasi Anda. Jika Anda menggunakan `Amazon.Lambda.Tools` CLI untuk membangun aplikasi Anda dan Anda tidak mengatur nama assembly menggunakan `AssemblyName` properti dalam `.csproj` file, maka `ASSEMBLY` hanya nama file Anda`.csproj`.
+ `TYPE`adalah nama lengkap dari tipe handler, yaitu`NAMESPACE.CLASSNAME`.
+ `METHOD`adalah nama metode handler utama dalam kode Anda, yaitu`METHODNAME`.
Untuk contoh kode utama pada halaman ini, jika perakitan diberi nama`ExampleCS`, maka string handler penuh adalah`ExampleCS::ExampleLambda.OrderHandler::HandleRequest`.
## Penangan perakitan yang dapat dieksekusi
Anda juga dapat mendefinisikan fungsi Lambda di C \$1 sebagai perakitan yang dapat dieksekusi. Penangan perakitan yang dapat dieksekusi menggunakan fitur pernyataan tingkat atas C\$1, 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 untuk metode ini adalah fungsi handler utama serta serializer Lambda untuk digunakan. Berikut ini menunjukkan contoh handler assembly executable di C \$1:
```
namespace GetProductHandler;
IDatabaseRepository repo = new DatabaseRepository();
await LambdaBootstrapBuilder.Create(Handler, new DefaultLambdaJsonSerializer())
.Build()
.RunAsync();
async Task 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](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-Handler) untuk penangan perakitan yang dapat dieksekusi, string handler yang memberi tahu Lambda cara menjalankan kode Anda adalah nama perakitan. Dalam contoh ini, itu`GetProductHandler`.
## Tanda tangan handler yang valid untuk fungsi C \$1
Di C \$1, tanda tangan penangan 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 HandleRequest(Order order, ILambdaContext context)
```
Saat memberikan dua argumen, argumen pertama harus berupa input peristiwa, dan argumen kedua harus berupa objek konteks Lambda. Kedua argumen bersifat opsional. Misalnya, berikut ini juga merupakan tanda tangan penangan Lambda yang valid di C \$1:
+ `public async Task HandleRequest()`
+ `public async Task HandleRequest(Order order)`
+ `public async Task HandleRequest(ILambdaContext context)`
Terlepas dari sintaks dasar 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 [unsafe (referensi C\$1)](https://msdn.microsoft.com/en-us/library/chfa2zb8.aspx) di situs web dokumentasi Microsoft.
+ Handler tidak boleh menggunakan `params` kata kunci, atau digunakan `ArgIterator` sebagai input atau parameter pengembalian. Kata kunci ini mendukung sejumlah parameter variabel. Jumlah maksimum argumen yang dapat diterima handler Anda adalah dua.
+ Handler mungkin bukan metode generik. Dengan kata lain, itu tidak dapat menggunakan parameter tipe generik seperti``.
+ Lambda tidak mendukung penangan asinkron dengan tanda tangan. `async void`
## Konvensi penamaan handler
Penangan Lambda di C\$1 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 kanan bergantung pada apakah Anda menggunakan handler [perpustakaan kelas atau handler](#csharp-class-library-handlers) perakitan yang dapat [dieksekusi](#csharp-executable-assembly-handlers).
Meskipun Anda dapat menggunakan nama apa pun untuk handler Anda, nama fungsi di C \$1 umumnya masuk. 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. `OrderHandler` Misalnya, Anda dapat mengubah nama file dalam contoh ini dari `Function.cs` ke`OrderHandler.cs`.
## Serialisasi dalam fungsi C\$1 Lambda
JSON adalah format input yang paling umum dan standar untuk fungsi Lambda. Dalam contoh ini, fungsi mengharapkan input yang mirip dengan yang berikut:
```
{
"orderId": "12345",
"amount": 199.99,
"item": "Wireless Headphones"
}
```
Di C \$1, Anda dapat menentukan bentuk peristiwa input yang diharapkan di kelas. Dalam contoh ini, kita mendefinisikan `Order` kelas untuk memodelkan masukan 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 Anda menggunakan jenis input atau output selain `Stream` objek, Anda harus menambahkan pustaka serialisasi ke aplikasi Anda. Ini memungkinkan Anda mengonversi input JSON menjadi instance dari kelas yang Anda tentukan. Ada dua metode serialisasi untuk fungsi C\$1 di Lambda: serialisasi berbasis refleksi dan serialisasi yang dihasilkan sumber.
### Serialisasi berbasis refleksi
AWS menyediakan pustaka pra-bangun yang dapat Anda tambahkan dengan cepat ke aplikasi Anda. [Pustaka ini menerapkan serialisasi menggunakan refleksi.](https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/reflection-and-attributes/) 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 mengimplementasikan `ILambdaSerializer` antarmuka, yang tersedia sebagai bagian dari `Amazon.Lambda.Core` perpustakaan. Antarmuka ini mendefinisikan dua metode:
+ `T Deserialize(Stream requestStream);`
Anda menerapkan metode ini untuk deserialisasi payload permintaan dari `Invoke` API ke objek yang diteruskan ke penangan fungsi Lambda Anda.
+ `T Serialize(T response, Stream responseStream);`
Anda menerapkan metode ini untuk membuat serial hasil yang dikembalikan dari penangan fungsi Lambda ke dalam payload respons yang ditampilkan oleh operasi API. `Invoke`
Contoh utama pada halaman ini menggunakan serialisasi berbasis refleksi. Serialisasi berbasis refleksi 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 juga dapat melihat latensi fungsi yang lebih tinggi karena refleksi runtime.
### Serialisasi yang dihasilkan sumber
Dengan serialisasi yang dihasilkan sumber, kode serialisasi dihasilkan pada waktu kompilasi. Ini menghilangkan kebutuhan akan refleksi dan dapat meningkatkan kinerja fungsi Anda. Untuk menggunakan serialisasi yang dihasilkan sumber dalam fungsi Anda, Anda harus melakukan hal berikut:
+ Buat kelas parsi baru yang mewarisi dari`JsonSerializerContext`, menambahkan `JsonSerializable` atribut untuk semua jenis yang memerlukan serialisasi atau deserialisasi.
+ Konfigurasikan `LambdaSerializer` untuk menggunakan a`SourceGeneratorLambdaJsonSerializer`.
+ Perbarui serialisasi manual dan deserialisasi apa pun 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 HandleRequest(string input, ILambdaContext context)
{
var order = JsonSerializer.Deserialize(input, OrderJsonContext.Default.Order);
...
}
}
```
Serialisasi yang dihasilkan sumber 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](lambda-runtime-environment.md#cold-start-latency), pertimbangkan untuk beralih ke serialisasi yang dihasilkan sumber.
**catatan**
Jika Anda ingin menggunakan [ahead-of-time kompilasi asli (AOT)](dotnet-native-aot.md) dengan Lambda, Anda harus menggunakan serialisasi yang dihasilkan sumber.
## Fungsi berbasis file
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 \$1.
Cara tercepat untuk mulai membuat fungsi Lambda berbasis file C \$1 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 \$1:
```
dotnet new lambda.FileBased -n MyLambdaFunction
```
Fungsi berbasis file menggunakan penangan rakitan yang [dapat dieksekusi](#csharp-executable-assembly-handlers). Oleh karena itu Anda harus menyertakan `Amazon.Lambda.RuntimeSupport` NuGet paket dan menggunakan `LambdaBootstrapBuilder.Create` metode untuk mendaftarkan fungsi handler .NET untuk jenis acara dan memulai klien runtime .NET Lambda.
Fungsi berbasis file 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 selengkapnya tentang penggunaan AOT Asli di Lambda, lihat. [Kompilasi kode fungsi.NET Lambda ke format runtime asli](dotnet-native-aot.md)
## Mengakses dan menggunakan objek konteks Lambda
[Objek konteks](csharp-context.md) Lambda berisi informasi tentang lingkungan pemanggilan, fungsi, dan eksekusi. Dalam contoh ini, objek konteks bertipe`Amazon.Lambda.Core.ILambdaContext`, dan merupakan argumen kedua dari fungsi pengendali utama.
```
public async Task HandleRequest(Order order, ILambdaContext context) {
...
}
```
Objek konteks adalah input opsional. Untuk informasi selengkapnya tentang tanda tangan handler yang diterima valid, lihat. [Tanda tangan handler yang valid untuk fungsi C \$1](#csharp-handler-signatures)
Objek konteks berguna untuk memproduksi 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 lebih lanjut tentang objek konteks, lihat[Menggunakan objek konteks Lambda untuk mengambil informasi fungsi C \$1](csharp-context.md).
## Menggunakan SDK untuk .NET v3 di handler Anda
Seringkali, Anda akan menggunakan fungsi Lambda untuk berinteraksi dengan atau membuat pembaruan ke sumber daya lain AWS . 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 project menggunakan perintah berikut: `Amazon.Lambda.Tools`
```
dotnet add package
```
Misalnya, dalam contoh utama di halaman ini, kita perlu menggunakan Amazon S3 API untuk mengunggah tanda terima ke S3. Kami dapat mengimpor klien SDK Amazon S3 dengan perintah berikut:
```
dotnet add package AWSSDK.S3
```
Perintah ini menambahkan ketergantungan ke proyek Anda. Anda juga harus melihat baris yang mirip dengan yang berikut di `.csproj` file proyek Anda:
```
```
Kemudian, impor dependensi langsung di kode C\$1 Anda:
```
using Amazon.S3;
using Amazon.S3.Model;
```
Kode contoh kemudian menginisialisasi klien Amazon S3 (menggunakan rantai [penyedia kredensi default](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html)) sebagai berikut:
```
private static readonly AmazonS3Client s3Client = new();
```
Dalam contoh ini, kami menginisialisasi klien Amazon S3 kami di luar fungsi pengendali utama untuk menghindari keharusan menginisialisasi setiap kali kami menjalankan fungsi kami. Setelah menginisialisasi klien SDK, Anda dapat menggunakannya untuk berinteraksi dengan layanan lain AWS . Kode contoh memanggil Amazon S3 `PutObject` API 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](configuration-envvars.md) apa pun dengan menggunakan `System.Environment.GetEnvironmentVariable` metode ini. Dalam contoh ini, kami mereferensikan variabel `RECEIPT_BUCKET` 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 inisialisasi](lambda-runtime-environment.md#runtimes-lifecycle-ib) sebelum menjalankan 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 menjalankan 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 lebih lama. Peristiwa selanjutnya jauh lebih cepat karena Lambda tidak perlu menginisialisasi klien lagi.
## Sederhanakan kode fungsi dengan kerangka kerja Anotasi Lambda
[Anotasi Lambda](https://www.nuget.org/packages/Amazon.Lambda.Annotations) adalah kerangka kerja untuk.NET 8 yang menyederhanakan penulisan fungsi Lambda menggunakan C \$1. Kerangka kerja Anotasi menggunakan [generator sumber](https://learn.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/source-generators-overview) 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 biasa. Kode yang ditulis menggunakan kerangka kerja menggunakan ekspresi sederhana yang memungkinkan Anda untuk fokus pada logika bisnis Anda. Lihat [Amazon.Lambda.Annotations](https://www.nuget.org/packages/Amazon.Lambda.Annotations) di dokumentasi nuget untuk contoh.
Untuk contoh aplikasi lengkap yang menggunakan Anotasi Lambda, lihat contoh [ PhotoAssetManager](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAssetManager)di repositori. `awsdocs/aws-doc-sdk-examples` GitHub `Function.cs`File utama dalam `PamApiAnnotations` direktori menggunakan Anotasi Lambda. 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 kerja Anotasi Lambda untuk menambahkan injeksi ketergantungan ke fungsi Lambda Anda menggunakan sintaks yang Anda kenal. Saat Anda menambahkan `[LambdaStartup]` atribut ke `Startup.cs` file, kerangka kerja Anotasi Lambda akan menghasilkan kode yang diperlukan pada waktu kompilasi.
```
[LambdaStartup]
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton();
}
}
```
Fungsi Lambda Anda dapat menyuntikkan layanan menggunakan injeksi konstruktor atau dengan menyuntikkan ke dalam 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 FunctionHandler([FromServices] IDatabaseRepository repository, string id)
{
return await this._repo.GetById(id);
}
}
```
## Praktik terbaik kode untuk fungsi C\$1 Lambda
Patuhi pedoman dalam daftar berikut untuk menggunakan praktik pengkodean terbaik saat membangun fungsi Lambda Anda:
+ **Pisahkan handler Lambda dari logika inti Anda.** Ini memungkinkan Anda untuk membuat fungsi yang lebih dapat teruji.
+ **Kontrol dependensi dalam paket penerapan fungsi Anda.** Lingkungan AWS Lambda eksekusi berisi sejumlah pustaka. Untuk mengaktifkan serangkaian fitur dan pembaruan keamanan terbaru, Lambda akan memperbarui pustaka ini secara berkala. Pembaruan ini dapat memberikan perubahan kecil 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](lambda-runtime-environment.md).
+ **Minimalkan ukuran paket penerapan Anda sesuai kebutuhan runtime-nya.** Ini akan mengurangi jumlah waktu yang dibutuhkan untuk mengunduh dan membongkar paket deployment Anda sebelum invokasi. Untuk fungsi yang ditulis di .NET, hindari mengunggah seluruh pustaka AWS SDK sebagai bagian dari paket penerapan Anda. Sebaliknya, bergantunglah secara selektif pada modul yang mengambil komponen SDK yang Anda perlukan (mis., DynamoDB, modul SDK Amazon S3, dan pustaka 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 arahan 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 Kembali Koneksi dengan Keep-Alive di Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Gunakan [variabel lingkungan](configuration-envvars.md) 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 konkurensi fungsi cadangan untuk `0` segera membatasi semua pemanggilan ke fungsi, saat Anda memperbarui kode.
**Jangan gunakan non-dokumen, non-publik APIs** dalam kode fungsi Lambda Anda. Untuk runtime AWS Lambda terkelola, Lambda secara berkala menerapkan pembaruan keamanan dan fungsional ke internal Lambda. APIs Pembaruan API internal ini mungkin tidak kompatibel ke belakang, yang menyebabkan konsekuensi yang tidak diinginkan seperti kegagalan pemanggilan jika fungsi Anda memiliki ketergantungan pada non-publik ini. APIs Lihat [referensi API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) untuk daftar yang tersedia APIs untuk umum.
**Tulis kode idempoten.** Menulis kode idempoten 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 selengkapnya, lihat [Bagaimana cara membuat fungsi Lambda saya idempoten?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/) .
# Bangun dan terapkan fungsi C\$1 Lambda dengan arsip file.zip
Paket penerapan .NET (arsip file.zip) berisi rakitan yang dikompilasi fungsi Anda bersama dengan semua dependensi perakitannya. Paket ini juga berisi file `proj.deps.json`. Ini memberi sinyal ke runtime .NET semua dependensi fungsi Anda dan `proj.runtimeconfig.json` file, yang digunakan untuk mengonfigurasi runtime.
Untuk menerapkan fungsi Lambda individual, Anda dapat menggunakan CLI Global `Amazon.Lambda.Tools` .NET Lambda. Menggunakan `dotnet lambda deploy-function` perintah secara otomatis membuat paket penyebaran.zip dan menyebarkannya ke Lambda. Namun, kami menyarankan Anda menggunakan kerangka kerja seperti AWS Serverless Application Model (AWS SAM) atau AWS Cloud Development Kit (AWS CDK) untuk menyebarkan aplikasi.NET Anda. AWS
Aplikasi tanpa server biasanya terdiri dari kombinasi fungsi Lambda dan Layanan AWS kerja sama lain yang dikelola untuk melakukan tugas bisnis tertentu. AWS SAM dan AWS CDK menyederhanakan membangun dan menerapkan fungsi Lambda dengan yang lain dalam skala besar. Layanan AWS [Spesifikasi AWS SAM template](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) menyediakan sintaks sederhana dan bersih untuk menggambarkan fungsi Lambda, izin APIs, konfigurasi, dan sumber daya AWS lain yang membentuk aplikasi tanpa server Anda. Dengan [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html)Anda mendefinisikan infrastruktur cloud sebagai kode untuk membantu Anda membangun aplikasi yang andal, terukur, dan hemat biaya di cloud menggunakan bahasa pemrograman modern dan kerangka kerja seperti .NET. Baik AWS CDK dan AWS SAM menggunakan CLI Global .NET Lambda untuk mengemas fungsi Anda.
Meskipun dimungkinkan untuk menggunakan [lapisan Lambda](chapter-layers.md) dengan fungsi di C \$1 dengan [menggunakan CLI CLI.NET Core, kami sarankan](csharp-package-cli.md#csharp-layers) untuk tidak melakukannya. Fungsi dalam C\$1 yang menggunakan lapisan secara manual memuat rakitan bersama ke dalam memori selama[Fase inisialisasi](lambda-runtime-environment.md#runtimes-lifecycle-ib), yang dapat meningkatkan waktu mulai dingin. Sebagai gantinya, sertakan semua kode bersama pada waktu kompilasi untuk menghindari dampak kinerja pemuatan rakitan saat runtime.
Anda dapat menemukan petunjuk untuk membangun dan menerapkan fungsi.NET Lambda menggunakan AWS SAM, CLI Global Lambda, dan .NET Lambda Global di AWS CDK bagian berikut.
**Topics**
+ [Menggunakan CLI Global .NET Lambda](csharp-package-cli.md)
+ [Menyebarkan fungsi C\$1 Lambda menggunakan AWS SAM](csharp-package-sam.md)
+ [Menyebarkan fungsi C\$1 Lambda menggunakan AWS CDK](csharp-package-cdk.md)
+ [Menyebarkan aplikasi ASP.NET](csharp-package-asp.md)
# Menggunakan CLI Global .NET Lambda
.NET CLI dan ekstensi .NET Lambda Global Tools (`Amazon.Lambda.Tools`) menawarkan cara lintas platform untuk membuat aplikasi Lambda berbasis .NET, mengemasnya, dan menyebarkannya ke Lambda. Di bagian ini, Anda mempelajari cara membuat proyek Lambda.NET baru menggunakan templat .NET CLI dan Amazon Lambda, dan mengemas dan menerapkannya menggunakan `Amazon.Lambda.Tools`
**Topics**
+ [Prasyarat](#csharp-package-cli-prerequisites)
+ [Membuat proyek .NET menggunakan .NET CLI](#csharp-package-cli-create)
+ [Menerapkan proyek .NET menggunakan .NET CLI](#csharp-package-cli-deploy)
+ [Menggunakan layer Lambda dengan .NET CLI](#csharp-layers)
## Prasyarat
**.NET 8 SDK**
Jika Anda belum melakukannya, instal SDK [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) dan Runtime.
**AWS Templat proyek Amazon.Lambda.Templates .NET**
Untuk menghasilkan kode fungsi Lambda Anda, gunakan paket. [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet Untuk menginstal paket template ini, jalankan perintah berikut:
```
dotnet new install Amazon.Lambda.Templates
```
**AWS Amazon.Lambda.Tools .NET Alat CLI Global**
Untuk membuat fungsi Lambda Anda, Anda menggunakan [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools)[ekstensi.NET Global Tools](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/). Untuk menginstalAmazon.Lambda.Tools, jalankan perintah berikut:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Untuk informasi selengkapnya tentang Amazon.Lambda.Tools ekstensi.NET CLI, lihat [AWS Ekstensi untuk repositori.NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) di. GitHub
## Membuat proyek .NET menggunakan .NET CLI
Di .NET CLI, Anda menggunakan `dotnet new` perintah untuk membuat proyek .NET dari baris perintah. Lambda menawarkan template tambahan menggunakan paket. [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet
Setelah menginstal paket ini, jalankan perintah berikut untuk melihat daftar template yang tersedia.
```
dotnet new list
```
Untuk memeriksa rincian tentang templat , gunakan opsi `help`. Misalnya, untuk melihat detail tentang `lambda.EmptyFunction` template, jalankan perintah berikut.
```
dotnet new lambda.EmptyFunction --help
```
Untuk membuat template dasar untuk fungsi.NET Lambda, gunakan template. `lambda.EmptyFunction` Ini menciptakan fungsi sederhana yang mengambil string sebagai input dan mengubahnya menjadi huruf besar menggunakan `ToUpper` metode. Template ini mendukung opsi berikut:
+ `--name` – Nama fungsi.
+ `--region`— AWS Wilayah untuk membuat fungsi di.
+ `--profile`— Nama profil di file AWS SDK untuk .NET kredensil Anda. Untuk mempelajari selengkapnya tentang profil kredensial.NET, lihat [Mengonfigurasi AWS kredensil](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) di *SDK for AWS .NET Developer Guide*.
Dalam contoh ini, kita membuat fungsi kosong baru bernama `myDotnetFunction` menggunakan profil default dan Wilayah AWS pengaturan:
```
dotnet new lambda.EmptyFunction --name myDotnetFunction
```
Perintah ini membuat file dan direktori berikut di direktori proyek Anda.
```
└── myDotnetFunction
├── src
│ └── myDotnetFunction
│ ├── Function.cs
│ ├── Readme.md
│ ├── aws-lambda-tools-defaults.json
│ └── myDotnetFunction.csproj
└── test
└── myDotnetFunction.Tests
├── FunctionTest.cs
└── myDotnetFunction.Tests.csproj
```
Di bawah direktori `src/myDotnetFunction`, periksa file-file berikut:
+ **aws-lambda-tools-defaults.json**: Di sinilah Anda menentukan opsi baris perintah saat menerapkan fungsi Lambda Anda. Misalnya:
```
"profile" : "default",
"region" : "us-east-2",
"configuration" : "Release",
"function-architecture": "x86_64",
"function-runtime":"dotnet8",
"function-memory-size" : 256,
"function-timeout" : 30,
"function-handler" : "myDotnetFunction::myDotnetFunction.Function::FunctionHandler"
```
+ **Function.cs**: Kode fungsi handler Lambda Anda. Ini adalah templat C\$1 yang menyertakan pustaka `Amazon.Lambda.Core` default dan atribut `LambdaSerializer` default. Untuk informasi selengkapnya tentang persyaratan dan opsi serialisasi, lihat [Serialisasi dalam fungsi C\$1 Lambda](csharp-handler.md#csharp-handler-serializer). Ini juga mencakup fungsi sampel yang dapat Anda edit untuk menerapkan kode fungsi Lambda Anda.
```
using Amazon.Lambda.Core;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace myDotnetFunction;
public class Function
{
///
/// A simple function that takes a string and does a ToUpper
///
///
///
public string FunctionHandler(string input, ILambdaContext context)
{
return input.ToUpper();
}
}
```
+ **myDotnetFunction.csproj**: [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx)File yang mencantumkan file dan rakitan yang terdiri dari aplikasi Anda.
```
net8.0
enable
enable
true
Lambda
true
true
```
+ **Readme**: Gunakan file ini untuk mendokumentasikan fungsi Lambda Anda.
Di bawah direktori `myfunction/test`, periksa file-file berikut:
+ **myDotnetFunction.tests.csProj**: Seperti disebutkan sebelumnya, ini adalah [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx)file yang mencantumkan file dan rakitan yang terdiri dari proyek pengujian Anda. Perhatikan juga bahwa ini menyertakan `Amazon.Lambda.Core` pustaka, sehingga Anda dapat dengan mulus mengintegrasikan template Lambda apa pun yang diperlukan untuk menguji fungsi Anda.
```
...
...
```
+ **FunctionTest.cs**: File template kode C \$1 yang sama yang disertakan dalam direktori. `src` Edit file ini untuk mencerminkan kode produksi fungsi Anda dan mengujinya sebelum mengunggah fungsi Lambda Anda ke lingkungan produksi.
```
using Xunit;
using Amazon.Lambda.Core;
using Amazon.Lambda.TestUtilities;
using MyFunction;
namespace MyFunction.Tests
{
public class FunctionTest
{
[Fact]
public void TestToUpperFunction()
{
// Invoke the lambda function and confirm the string was upper cased.
var function = new Function();
var context = new TestLambdaContext();
var upperCase = function.FunctionHandler("hello world", context);
Assert.Equal("HELLO WORLD", upperCase);
}
}
}
```
## Menerapkan proyek .NET menggunakan .NET CLI
Untuk membangun paket penyebaran Anda dan menyebarkannya ke Lambda, Anda menggunakan alat CLI. `Amazon.Lambda.Tools` Untuk menerapkan fungsi Anda dari file yang Anda buat di langkah sebelumnya, pertama-tama navigasikan ke folder yang berisi `.csproj` file fungsi Anda.
```
cd myDotnetFunction/src/myDotnetFunction
```
Untuk menyebarkan kode Anda ke Lambda sebagai paket penyebaran .zip, jalankan perintah berikut. Pilih nama fungsi Anda sendiri.
```
dotnet lambda deploy-function myDotnetFunction
```
Selama penyebaran, wizard meminta Anda untuk memilih file. [Mendefinisikan izin fungsi Lambda dengan peran pelaksanaan](lambda-intro-execution-role.md) Untuk contoh ini, pilih`lambda_basic_role`.
Setelah Anda menerapkan fungsi Anda, Anda dapat mengujinya di cloud menggunakan `dotnet lambda invoke-function` perintah. Untuk contoh kode dalam `lambda.EmptyFunction` template, Anda dapat menguji fungsi Anda dengan meneruskan string menggunakan `--payload` opsi.
```
dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
```
Jika fungsi Anda telah berhasil di-deploy, Anda akan melihat output yang mirip dengan berikut ini.
```
dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
Amazon Lambda Tools for .NET Core applications (5.8.0)
Project Home: https://github.com/aws/aws-extensions-for-dotnet-cli, https://github.com/aws/aws-lambda-dotnet
Payload:
"JUST CHECKING IF EVERYTHING IS OK"
Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 1 ms Memory Size: 256 MB Max Memory Used: 12 MB
```
## Menggunakan layer Lambda dengan .NET CLI
**catatan**
Meskipun dimungkinkan untuk menggunakan [lapisan](chapter-layers.md) dengan fungsi di .NET, kami sarankan untuk tidak melakukannya. Fungsi di .NET yang menggunakan lapisan secara manual memuat rakitan bersama ke dalam memori selama `Init` fase, yang dapat meningkatkan waktu mulai dingin. Sebagai gantinya, sertakan semua kode bersama pada waktu kompilasi untuk memanfaatkan pengoptimalan bawaan compiler.NET.
.NET CLI mendukung perintah untuk membantu Anda mempublikasikan lapisan dan menerapkan fungsi C\$1 yang menggunakan lapisan. Untuk memublikasikan layer ke bucket Amazon S3 tertentu, jalankan perintah berikut di direktori yang sama dengan file Anda`.csproj`:
```
dotnet lambda publish-layer --layer-type runtime-package-store --s3-bucket
```
Kemudian, ketika Anda menerapkan fungsi Anda menggunakan .NET CLI, tentukan layer ARN konsumsi dalam perintah berikut:
```
dotnet lambda deploy-function --function-layers arn:aws:lambda:us-east-1:123456789012:layer:layer-name:1
```
Untuk contoh lengkap fungsi Hello World, lihat [ blank-csharp-with-layer](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-csharp-with-layer)sampelnya.
# Menyebarkan fungsi C\$1 Lambda menggunakan AWS SAM
The AWS Serverless Application Model (AWS SAM) adalah toolkit yang membantu merampingkan proses membangun dan menjalankan aplikasi tanpa server. AWS Anda menentukan sumber daya untuk aplikasi Anda dalam template YAMM atau JSON dan menggunakan antarmuka baris AWS SAM perintah (AWS SAM CLI) untuk membangun, mengemas, dan menyebarkan aplikasi Anda. Saat Anda membuat fungsi Lambda dari AWS SAM template, AWS SAM secara otomatis membuat paket penerapan .zip atau gambar kontainer dengan kode fungsi Anda dan dependensi apa pun yang Anda tentukan. AWS SAM kemudian menyebarkan fungsi Anda menggunakan [CloudFormation tumpukan](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html). Untuk mempelajari lebih lanjut cara menggunakan AWS SAM untuk membangun dan menerapkan fungsi Lambda, [lihat Memulai](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) di Panduan AWS SAM*AWS Serverless Application Model Pengembang*.
Langkah-langkah berikut menunjukkan kepada Anda cara mengunduh, membangun, dan menyebarkan contoh aplikasi.NET Hello World menggunakan AWS SAM. Contoh aplikasi ini menggunakan fungsi Lambda dan endpoint Amazon API Gateway untuk mengimplementasikan backend API dasar. Saat Anda mengirim permintaan HTTP GET ke titik akhir API Gateway, API Gateway akan memanggil fungsi Lambda Anda. Fungsi mengembalikan pesan “hello world”, bersama dengan alamat IP dari instance fungsi Lambda yang memproses permintaan Anda.
Saat Anda membangun dan menerapkan aplikasi Anda menggunakan AWS SAM, di belakang layar AWS SAM CLI menggunakan perintah untuk mengemas `dotnet lambda package` bundel kode fungsi Lambda individual.
## Prasyarat
**.NET 8 SDK**
Instal [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) SDK dan Runtime.
**AWS SAM CLI versi 1.39 atau yang lebih baru**
Untuk mempelajari cara menginstal AWS SAM CLI versi terbaru, lihat [Menginstal CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html).
## Menyebarkan aplikasi sampel AWS SAM
1. Inisialisasi aplikasi menggunakan template Hello world .NET menggunakan perintah berikut.
```
sam init --app-template hello-world --name sam-app \
--package-type Zip --runtime dotnet8
```
Perintah ini membuat file dan direktori berikut di direktori proyek Anda.
```
└── sam-app
├── README.md
├── events
│ └── event.json
├── omnisharp.json
├── samconfig.toml
├── src
│ └── HelloWorld
│ ├── Function.cs
│ ├── HelloWorld.csproj
│ └── aws-lambda-tools-defaults.json
├── template.yaml
└── test
└── HelloWorld.Test
├── FunctionTest.cs
└── HelloWorld.Tests.csproj
```
1. Arahkan ke direktori yang berisi file`template.yaml file`. File ini adalah tempate yang mendefinisikan AWS resource untuk aplikasi Anda, termasuk fungsi Lambda Anda dan API Gateway API.
```
cd sam-app
```
1. Untuk membangun sumber aplikasi Anda, jalankan perintah berikut.
```
sam build
```
1. Untuk menyebarkan aplikasi Anda AWS, jalankan perintah berikut.
```
sam deploy --guided
```
Perintah ini mengemas dan menyebarkan aplikasi Anda dengan serangkaian prompt berikut. Untuk menerima opsi default, tekan Enter.
**catatan**
Karena **HelloWorldFunction mungkin tidak memiliki otorisasi yang ditentukan, apakah ini baik-baik saja?** , pastikan untuk masuk`y`.
+ **Nama Stack**: Nama tumpukan yang akan digunakan. CloudFormation Nama ini harus unik untuk Anda Akun AWS dan Wilayah AWS.
+ **Wilayah AWS**: Wilayah AWS Anda ingin menerapkan aplikasi Anda ke.
+ **Konfirmasikan perubahan sebelum menerapkan**: Pilih ya untuk meninjau set perubahan apa pun secara manual sebelum AWS SAM menerapkan perubahan aplikasi. Jika Anda memilih tidak, AWS SAM CLI secara otomatis menyebarkan perubahan aplikasi.
+ **Izinkan pembuatan peran SAM CLI IAM**: Banyak AWS SAM templat, termasuk Hello world dalam contoh ini, buat peran AWS Identity and Access Management (IAM) untuk memberikan izin fungsi Lambda Anda untuk mengakses yang lain. Layanan AWS Pilih Ya untuk memberikan izin untuk menyebarkan CloudFormation tumpukan yang membuat atau memodifikasi peran IAM.
+ **Nonaktifkan rollback**: Secara default, jika AWS SAM menemukan kesalahan selama pembuatan atau penyebaran tumpukan Anda, itu akan memutar tumpukan kembali ke versi sebelumnya. Pilih Tidak untuk menerima default ini.
+ **HelloWorldFunction mungkin tidak memiliki otorisasi yang ditentukan, apakah ini baik-baik saja**: Enter`y`.
+ **Simpan argumen ke samconfig.toml**: Pilih ya untuk menyimpan pilihan konfigurasi Anda. Di masa mendatang, Anda dapat menjalankan ulang `sam deploy` tanpa parameter untuk menerapkan perubahan pada aplikasi Anda.
1. Ketika penerapan aplikasi Anda selesai, CLI mengembalikan Amazon Resource Name (ARN) dari fungsi Hello World Lambda dan peran IAM yang dibuat untuknya. Ini juga menampilkan titik akhir API Gateway API Anda. Untuk menguji aplikasi Anda, buka titik akhir di browser. Anda akan melihat respons yang mirip dengan yang berikut ini.
```
{"message":"hello world","location":"34.244.135.203"}
```
1. Untuk menghapus sumber daya Anda, jalankan perintah berikut. Perhatikan bahwa titik akhir API yang Anda buat adalah titik akhir publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir ini setelah pengujian.
```
sam delete
```
## Langkah selanjutnya
Untuk mempelajari selengkapnya tentang penggunaan AWS SAM untuk membangun dan menerapkan fungsi Lambda menggunakan.NET, lihat sumber daya berikut:
+ [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
+ [Membangun Aplikasi .NET Tanpa Server dengan AWS Lambda dan SAM CLI](https://aws.amazon.com/blogs/dotnet/building-serverless-net-applications-with-aws-lambda-and-the-sam-cli/)
# Menyebarkan fungsi C\$1 Lambda menggunakan AWS CDK
AWS Cloud Development Kit (AWS CDK) Ini adalah kerangka pengembangan perangkat lunak open-source untuk mendefinisikan infrastruktur cloud sebagai kode dengan bahasa pemrograman modern dan kerangka kerja seperti .NET. AWS CDK proyek dijalankan untuk menghasilkan CloudFormation template yang kemudian digunakan untuk menyebarkan kode Anda.
Untuk membangun dan menyebarkan contoh aplikasi Hello world .NET menggunakan AWS CDK, ikuti petunjuk di bagian berikut. Aplikasi sampel mengimplementasikan backend API dasar yang terdiri dari titik akhir API Gateway dan fungsi Lambda. API Gateway memanggil fungsi Lambda saat Anda mengirim permintaan HTTP GET ke titik akhir. Fungsi ini mengembalikan pesan Hello world, bersama dengan alamat IP dari instance Lambda yang memproses permintaan Anda.
## Prasyarat
**.NET 8 SDK**
Instal [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) SDK dan Runtime.
**AWS CDK versi 2**
Untuk mempelajari cara menginstal versi terbaru, AWS CDK lihat [Memulai dengan AWS CDK di](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) *Panduan Pengembang AWS Cloud Development Kit (AWS CDK) v2*.
## Menyebarkan aplikasi sampel AWS CDK
1. Buat direktori proyek untuk aplikasi sampel dan navigasikan ke dalamnya.
```
mkdir hello-world
cd hello-world
```
1. Menginisialisasi AWS CDK aplikasi baru dengan menjalankan perintah berikut.
```
cdk init app --language csharp
```
Perintah membuat file dan direktori berikut di direktori proyek Anda
```
├── README.md
├── cdk.json
└── src
├── HelloWorld
│ ├── GlobalSuppressions.cs
│ ├── HelloWorld.csproj
│ ├── HelloWorldStack.cs
│ └── Program.cs
└── HelloWorld.sln
```
1. Buka `src` direktori dan buat fungsi Lambda baru menggunakan .NET CLI. Ini adalah fungsi yang akan Anda gunakan menggunakan. AWS CDK Dalam contoh ini, Anda membuat fungsi Hello world bernama `HelloWorldLambda` menggunakan `lambda.EmptyFunction` template.
```
cd src
dotnet new lambda.EmptyFunction -n HelloWorldLambda
```
Setelah langkah ini, struktur direktori Anda di dalam direktori proyek Anda akan terlihat seperti berikut.
```
├── README.md
├── cdk.json
└── src
├── HelloWorld
│ ├── GlobalSuppressions.cs
│ ├── HelloWorld.csproj
│ ├── HelloWorldStack.cs
│ └── Program.cs
├── HelloWorld.sln
└── HelloWorldLambda
├── src
│ └── HelloWorldLambda
│ ├── Function.cs
│ ├── HelloWorldLambda.csproj
│ ├── Readme.md
│ └── aws-lambda-tools-defaults.json
└── test
└── HelloWorldLambda.Tests
├── FunctionTest.cs
└── HelloWorldLambda.Tests.csproj
```
1. Buka `HelloWorldStack.cs` file dari `src/HelloWorld` direktori. Ganti isi file dengan kode berikut.
```
using Amazon.CDK;
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.Logs;
using Constructs;
namespace CdkTest
{
public class HelloWorldStack : Stack
{
internal HelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var buildOption = new BundlingOptions()
{
Image = Runtime.DOTNET_8.BundlingImage,
User = "root",
OutputType = BundlingOutput.ARCHIVED,
Command = new string[]{
"/bin/sh",
"-c",
" dotnet tool install -g Amazon.Lambda.Tools"+
" && dotnet build"+
" && dotnet lambda package --output-package /asset-output/function.zip"
}
};
var helloWorldLambdaFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.DOTNET_8,
MemorySize = 1024,
LogRetention = RetentionDays.ONE_DAY,
Handler = "HelloWorldLambda::HelloWorldLambda.Function::FunctionHandler",
Code = Code.FromAsset("./src/HelloWorldLambda/src/HelloWorldLambda", new Amazon.CDK.AWS.S3.Assets.AssetOptions
{
Bundling = buildOption
}),
});
}
}
}
```
Ini adalah kode untuk mengkompilasi dan menggabungkan kode aplikasi, serta definisi fungsi Lambda itu sendiri. `BundlingOptions` objek memungkinkan file zip dibuat, bersama dengan serangkaian perintah yang digunakan untuk menghasilkan konten file zip. Dalam hal ini, `dotnet lambda package` perintah digunakan untuk mengkompilasi dan menghasilkan file zip.
1. Untuk menyebarkan aplikasi Anda, jalankan perintah berikut.
```
cdk deploy
```
1. Memanggil fungsi Lambda yang Anda gunakan menggunakan .NET Lambda CLI.
```
dotnet lambda invoke-function HelloWorldFunction -p "hello world"
```
1. Setelah selesai menguji, Anda dapat menghapus sumber daya yang Anda buat, kecuali Anda ingin mempertahankannya. Jalankan perintah berikut untuk menghapus sumber daya Anda.
```
cdk destroy
```
## Langkah selanjutnya
Untuk mempelajari selengkapnya tentang penggunaan AWS CDK untuk membangun dan menerapkan fungsi Lambda menggunakan.NET, lihat sumber daya berikut:
+ [Bekerja dengan AWS CDK di C \$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Bangun, paket, dan publikasikan fungsi.NET C \$1 Lambda dengan CDK AWS](https://aws.amazon.com/blogs/modernizing-with-aws/build-package-publish-dotnet-csharp-lambda-functions-aws-cdk/)
# Menyebarkan aplikasi ASP.NET
Selain menghosting fungsi berbasis acara, Anda juga dapat menggunakan.NET dengan Lambda untuk meng-host aplikasi ASP.NET ringan. Anda dapat membangun dan menyebarkan aplikasi ASP.NET menggunakan paket. `Amazon.Lambda.AspNetCoreServer` NuGet Di bagian ini, Anda mempelajari cara menerapkan API web ASP.NET ke Lambda menggunakan tooling .NET Lambda CLI.
**Topics**
+ [Prasyarat](#csharp-package-asp-prerequisites)
+ [Menyebarkan API Web ASP.NET ke Lambda](#csharp-package-asp-deploy-api)
+ [Menyebarkan ASP.NET minimal APIs ke Lambda](#csharp-package-asp-deploy-minimal)
## Prasyarat
**.NET 8 SDK**
Instal [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) SDK dan ASP.NET Core Runtime.
**Amazon.Lambda.Tools**
Untuk membuat fungsi Lambda Anda, Anda menggunakan [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools)[ekstensi.NET Global Tools](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/). Untuk menginstalAmazon.Lambda.Tools, jalankan perintah berikut:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Untuk informasi selengkapnya tentang Amazon.Lambda.Tools ekstensi.NET CLI, lihat [AWS Ekstensi untuk repositori.NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) di. GitHub
**Amazon.Lambda.Templates**
Untuk menghasilkan kode fungsi Lambda Anda, gunakan paket. [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet Untuk menginstal paket template ini, jalankan perintah berikut:
```
dotnet new --install Amazon.Lambda.Templates
```
## Menyebarkan API Web ASP.NET ke Lambda
Untuk menerapkan API web menggunakan ASP.NET, Anda dapat menggunakan template .NET Lambda untuk membuat proyek API web baru. Gunakan perintah berikut untuk menginisialisasi proyek API web ASP.NET baru. Dalam perintah contoh, kami memberi nama proyek`AspNetOnLambda`.
```
dotnet new serverless.AspNetCoreWebAPI -n AspNetOnLambda
```
Perintah ini membuat file dan direktori berikut di direktori proyek Anda.
```
.
└── AspNetOnLambda
├── src
│ └── AspNetOnLambda
│ ├── AspNetOnLambda.csproj
│ ├── Controllers
│ │ └── ValuesController.cs
│ ├── LambdaEntryPoint.cs
│ ├── LocalEntryPoint.cs
│ ├── Readme.md
│ ├── Startup.cs
│ ├── appsettings.Development.json
│ ├── appsettings.json
│ ├── aws-lambda-tools-defaults.json
│ └── serverless.template
└── test
└── AspNetOnLambda.Tests
├── AspNetOnLambda.Tests.csproj
├── SampleRequests
│ └── ValuesController-Get.json
├── ValuesControllerTests.cs
└── appsettings.json
```
Ketika Lambda memanggil fungsi Anda, titik masuk yang digunakannya adalah file. `LambdaEntryPoint.cs` File yang dibuat oleh template.NET Lambda berisi kode berikut.
```
namespace AspNetOnLambda;
public class LambdaEntryPoint : Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction
{
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup≪Startup≫();
}
protected override void Init(IHostBuilder builder)
{
}
}
```
Titik masuk yang digunakan oleh Lambda harus mewarisi dari salah satu dari tiga kelas dasar dalam paket. `Amazon.Lambda.AspNetCoreServer` Ketiga kelas dasar ini adalah:
+ `APIGatewayProxyFunction`
+ `APIGatewayHttpApiV2ProxyFunction`
+ `ApplicationLoadBalancerFunction`
Kelas default yang digunakan saat Anda membuat `LambdaEntryPoint.cs` file menggunakan template.NET Lambda yang disediakan adalah. `APIGatewayProxyFunction` Kelas dasar yang Anda gunakan dalam fungsi Anda bergantung pada lapisan API mana yang berada di depan fungsi Lambda Anda.
Masing-masing dari tiga kelas dasar berisi metode publik bernama`FunctionHandlerAsync`. Nama metode ini akan membentuk bagian dari [string handler](csharp-handler.md#csharp-class-library-handlers) yang digunakan Lambda untuk memanggil fungsi Anda. `FunctionHandlerAsync`Metode ini mengubah payload peristiwa masuk menjadi format ASP.NET yang benar dan respons ASP.NET kembali ke muatan respons Lambda. Untuk `AspNetOnLambda` proyek contoh yang ditampilkan, string handler adalah sebagai berikut.
```
AspNetOnLambda::AspNetOnLambda.LambdaEntryPoint::FunctionHandlerAsync
```
Untuk menerapkan API ke Lambda, jalankan perintah berikut untuk menavigasi ke direktori yang berisi file kode sumber Anda dan menerapkan fungsi Anda menggunakan. CloudFormation
```
cd AspNetOnLambda/src/AspNetOnLambda
dotnet lambda deploy-serverless
```
**Tip**
Saat Anda menerapkan API menggunakan `dotnet lambda deploy-serverless` perintah, CloudFormation beri nama pada fungsi Lambda Anda berdasarkan nama tumpukan yang Anda tentukan selama penerapan. Untuk memberikan nama khusus pada fungsi Lambda Anda, edit `serverless.template` file untuk menambahkan `FunctionName` properti ke sumber daya. `AWS::Serverless::Function` Lihat [Jenis nama](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) di *Panduan CloudFormation Pengguna* untuk mempelajari lebih lanjut.
## Menyebarkan ASP.NET minimal APIs ke Lambda
Untuk menerapkan API minimal ASP.NET ke Lambda, Anda dapat menggunakan template .NET Lambda untuk membuat proyek API minimal yang baru. Gunakan perintah berikut untuk menginisialisasi proyek API minimal yang baru. Dalam contoh ini, kami memberi nama proyek`MinimalApiOnLambda`.
```
dotnet new serverless.AspNetCoreMinimalAPI -n MinimalApiOnLambda
```
Perintah membuat file dan direktori berikut di direktori proyek Anda.
```
└── MinimalApiOnLambda
└── src
└── MinimalApiOnLambda
├── Controllers
│ └── CalculatorController.cs
├── MinimalApiOnLambda.csproj
├── Program.cs
├── Readme.md
├── appsettings.Development.json
├── appsettings.json
├── aws-lambda-tools-defaults.json
└── serverless.template
```
`Program.cs`File berisi kode berikut.
```
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Add AWS Lambda support. When application is run in Lambda Kestrel is swapped out as the web server with Amazon.Lambda.AspNetCoreServer. This
// package will act as the webserver translating request and responses between the Lambda event source and ASP.NET Core.
builder.Services.AddAWSLambdaHosting(LambdaEventSource.RestApi);
var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.MapGet("/", () => "Welcome to running ASP.NET Core Minimal API on AWS Lambda");
app.Run();
```
Untuk mengonfigurasi API minimal agar berjalan di Lambda, Anda mungkin perlu mengedit kode ini agar permintaan dan tanggapan antara Lambda dan ASP.NET Core diterjemahkan dengan benar. Secara default, fungsi dikonfigurasi untuk sumber peristiwa REST API. Untuk HTTP API atau penyeimbang beban aplikasi, ganti `(LambdaEventSource.RestApi)` dengan salah satu opsi berikut:
+ `(LambdaEventSource.HttpAPi)`
+ `(LambdaEventSource.ApplicationLoadBalancer)`
Untuk menerapkan API minimal Anda ke Lambda, jalankan perintah berikut untuk menavigasi ke direktori yang berisi file kode sumber Anda dan menerapkan fungsi Anda menggunakan. CloudFormation
```
cd MinimalApiOnLambda/src/MinimalApiOnLambda
dotnet lambda deploy-serverless
```
# Bekerja dengan lapisan untuk fungsi.NET Lambda
Kami tidak menyarankan menggunakan [lapisan](chapter-layers.md) untuk mengelola dependensi untuk fungsi Lambda yang ditulis dalam.NET. Ini karena .NET adalah bahasa yang dikompilasi, dan fungsi Anda masih harus memuat rakitan bersama secara manual ke dalam memori selama fase [Init](lambda-runtime-environment.md#runtimes-lifecycle-ib), yang dapat meningkatkan waktu mulai dingin. Menggunakan lapisan tidak hanya mempersulit proses penerapan, tetapi juga mencegah Anda memanfaatkan pengoptimalan kompiler bawaan.
Untuk menggunakan dependensi eksternal dengan handler.NET Anda, sertakan mereka langsung dalam paket deployment Anda pada waktu kompilasi. Dengan demikian, Anda menyederhanakan proses penerapan dan juga memanfaatkan pengoptimalan compiler.NET bawaan. Untuk contoh cara mengimpor dan menggunakan dependensi seperti NuGet paket dalam fungsi Anda, lihat. [Tentukan penangan fungsi Lambda di C \$1](csharp-handler.md)
# Deploy fungsi Lambda .NET dengan gambar kontainer
Ada tiga cara untuk membangun image container untuk fungsi.NET Lambda:
+ [Menggunakan gambar AWS dasar untuk.NET](#csharp-image-instructions)
[Gambar AWS dasar](images-create.md#runtimes-images-lp) dimuat sebelumnya dengan runtime bahasa, klien antarmuka runtime untuk mengelola interaksi antara Lambda dan kode fungsi Anda, dan emulator antarmuka runtime untuk pengujian lokal.
+ [Menggunakan gambar AWS dasar khusus OS](images-create.md#runtimes-images-provided)
[AWS Gambar dasar khusus OS](https://gallery.ecr.aws/lambda/provided) berisi distribusi Amazon Linux dan emulator antarmuka [runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Gambar-gambar ini biasanya digunakan untuk membuat gambar kontainer untuk bahasa yang dikompilasi, seperti [Go](go-image.md#go-image-provided) dan [Rust](lambda-rust.md), dan untuk versi bahasa atau bahasa yang Lambda tidak menyediakan gambar dasar, seperti Node.js 19. Anda juga dapat menggunakan gambar dasar khusus OS untuk mengimplementasikan runtime [khusus](runtimes-custom.md). Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan [klien antarmuka runtime untuk.NET](#csharp-image-clients) dalam gambar.
+ [Menggunakan gambar AWS non-dasar](#csharp-image-clients)
Anda dapat menggunakan gambar dasar alternatif dari registri kontainer lain, seperti Alpine Linux atau Debian. Anda juga dapat menggunakan gambar kustom yang dibuat oleh organisasi Anda. Untuk membuat gambar kompatibel dengan Lambda, Anda harus menyertakan [klien antarmuka runtime untuk.NET](#csharp-image-clients) dalam gambar.
**Tip**
Untuk mengurangi waktu yang dibutuhkan agar fungsi penampung Lambda menjadi aktif, lihat [Menggunakan build multi-tahap](https://docs.docker.com/build/building/multi-stage/) dalam dokumentasi Docker. Untuk membuat gambar kontainer yang efisien, ikuti [Praktik terbaik untuk menulis Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Halaman ini menjelaskan cara membuat, menguji, dan menyebarkan gambar kontainer untuk Lambda.
**Topics**
+ [AWS gambar dasar untuk .NET](#csharp-image-base)
+ [Menggunakan gambar AWS dasar untuk.NET](#csharp-image-instructions)
+ [Menggunakan gambar dasar alternatif dengan klien antarmuka runtime](#csharp-image-clients)
## AWS gambar dasar untuk .NET
AWS menyediakan gambar dasar berikut untuk .NET:
| Tanda | Waktu berjalan | Sistem operasi | Dockerfile | penghentian |
| --- | --- | --- | --- | --- |
| 10 | .NET 10 | Amazon Linux 2023 | [Dockerfile untuk .NET 10 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet10/Dockerfile.dotnet10) | Nov 14, 2028 |
| 9 | .NET 9 | Amazon Linux 2023 | [Dockerfile untuk .NET 9 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet9/Dockerfile.dotnet9) | Nov 10, 2026 |
| 8 | .NET 8 | Amazon Linux 2023 | [Dockerfile untuk .NET 8 di GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet8/Dockerfile.dotnet8) | Nov 10, 2026 |
[Repositori Amazon ECR: gallery.ecr. aws/lambda/dotnet](https://gallery.ecr.aws/lambda/dotnet)
## Menggunakan gambar AWS dasar untuk.NET
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ [.NET SDK](https://dotnet.microsoft.com/download) — Langkah-langkah berikut menggunakan gambar dasar.NET 8. Pastikan versi.NET Anda cocok dengan versi [gambar dasar](https://gallery.ecr.aws/lambda/dotnet) yang Anda tentukan di Dockerfile Anda.
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
### Membuat dan menyebarkan gambar menggunakan gambar dasar
Dalam langkah-langkah berikut, Anda menggunakan [Amazon.Lambda.Templates dan [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools)](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) untuk membuat proyek.NET. Kemudian, Anda membuat gambar Docker, mengunggah gambar ke Amazon ECR, dan menerapkannya ke fungsi Lambda.
1. Instal paket [Amazon.Lambda.Templates.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Buat proyek.NET menggunakan `lambda.image.EmptyFunction` template.
```
dotnet new lambda.image.EmptyFunction --name MyFunction --region us-east-1
```
File proyek disimpan dalam `MyFunction/src/MyFunction` direktori:
+ **aws-lambda-tools-defaults.json**: Menentukan opsi baris perintah untuk menyebarkan fungsi Lambda Anda.
+ **Function.cs**: Kode fungsi handler Lambda Anda. Ini adalah template C \$1 yang mencakup `Amazon.Lambda.Core` pustaka default dan `LambdaSerializer` atribut default. Untuk informasi selengkapnya tentang persyaratan dan opsi serialisasi, lihat[Serialisasi dalam fungsi C\$1 Lambda](csharp-handler.md#csharp-handler-serializer). Anda dapat menggunakan kode yang disediakan untuk pengujian, atau menggantinya dengan kode Anda sendiri.
+ **MyFunction.csproj**: [File proyek.NET, yang mencantumkan file](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) dan rakitan yang terdiri dari aplikasi Anda.
+ **Dockerfile**: Anda dapat menggunakan Dockerfile yang disediakan untuk pengujian, atau menggantinya dengan milik Anda sendiri. Jika Anda menggunakan milik Anda sendiri, pastikan untuk:
+ Mengatur `FROM` properti ke [URI dari gambar dasar](https://gallery.ecr.aws/lambda/dotnet). Gambar dasar dan `TargetFramework` dalam `MyFunction.csproj` file harus menggunakan versi.NET yang sama. Misalnya, untuk menggunakan .NET 9:
+ Dockerfile: `FROM public.ecr.aws/lambda/dotnet:9`
+ MyFunction.csproj: `net9.0`
+ Atur `CMD` argumen ke penangan fungsi Lambda. Ini harus cocok dengan `image-command` in`aws-lambda-tools-defaults.json`.
1. [Instal Amazon.Lambda.Tools .NET Global Tool.](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/)
```
dotnet tool install -g Amazon.Lambda.Tools
```
Jika Amazon.Lambda.Tools sudah diinstal, pastikan Anda memiliki versi terbaru.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Ubah direktori ke`MyFunction/src/MyFunction`, jika Anda belum ada di sana.
```
cd src/MyFunction
```
1. Gunakan Amazon.Lambda.Tools untuk membuat image Docker, mendorongnya ke repositori Amazon ECR baru, dan menerapkan fungsi Lambda.
[Untuk`--function-role`, tentukan nama peran—bukan Nama Sumber Daya Amazon (ARN) —dari peran eksekusi untuk fungsi tersebut.](lambda-intro-execution-role.md) Misalnya, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Untuk informasi selengkapnya tentang Amazon.Lambda.Tools .NET Global Tool, lihat Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI repository on. GitHub
1. Memanggil fungsi.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Jika semuanya berhasil, Anda melihat respons yang mirip dengan yang berikut:
```
Payload:
{"Lower":"testing the function","Upper":"TESTING THE FUNCTION"}
Log Tail:
INIT_REPORT Init Duration: 9999.81 ms Phase: init Status: timeout
START RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Version: $LATEST
END RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed
REPORT RequestId: 12378346-f302-419b-b1f2-deaa1e8423ed Duration: 3173.06 ms Billed Duration: 3174 ms Memory Size: 512 MB Max Memory Used: 24 MB
```
1. Hapus fungsi Lambda.
```
dotnet lambda delete-function MyFunction
```
## Menggunakan gambar dasar alternatif dengan klien antarmuka runtime
Jika Anda menggunakan gambar [dasar khusus OS atau gambar dasar](images-create.md#runtimes-images-provided) alternatif, Anda harus menyertakan klien antarmuka runtime dalam gambar Anda. Klien antarmuka runtime memperluas[API runtime](runtimes-api.md), yang mengelola interaksi antara Lambda dan kode fungsi Anda.
Contoh berikut menunjukkan bagaimana membangun image container untuk.NET menggunakan image AWS non-base, dan bagaimana menambahkan [Amazon.Lambda. RuntimeSupport ](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)paket, yang merupakan klien antarmuka runtime Lambda untuk.NET. Contoh Dockerfile menggunakan gambar dasar Microsoft .NET 8.
### Prasyarat
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ [.NET SDK](https://dotnet.microsoft.com/download) — Langkah-langkah berikut menggunakan gambar dasar.NET 9. Pastikan versi.NET Anda cocok dengan versi gambar dasar yang Anda tentukan di Dockerfile Anda.
+ [Docker](https://docs.docker.com/get-docker) (versi minimum 25.0.0)
+ Plugin [buildx Docker](https://github.com/docker/buildx/blob/master/README.md).
### Membuat dan menyebarkan gambar menggunakan gambar dasar alternatif
1. Instal paket [Amazon.Lambda.Templates.](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) NuGet
```
dotnet new install Amazon.Lambda.Templates
```
1. Buat proyek.NET menggunakan `lambda.CustomRuntimeFunction` template. Template ini termasuk [Amazon.Lambda. RuntimeSupport](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library)paket.
```
dotnet new lambda.CustomRuntimeFunction --name MyFunction --region us-east-1
```
1. Buka direktori `MyFunction/src/MyFunction` tersebut. Di sinilah file proyek disimpan. Periksa file-file berikut:
+ **aws-lambda-tools-defaults.json** - File ini adalah tempat Anda menentukan opsi baris perintah saat menerapkan fungsi Lambda Anda.
+ **Function.cs** - Kode berisi kelas dengan `Main` metode yang menginisialisasi `Amazon.Lambda.RuntimeSupport` perpustakaan sebagai bootstrap. `Main`Metode ini adalah titik masuk untuk proses fungsi. `Main`Metode ini membungkus fungsi handler dalam pembungkus yang dapat digunakan bootstrap. Untuk informasi selengkapnya, lihat [Menggunakan Amazon.Lambda. RuntimeSupport sebagai pustaka kelas](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library) di GitHub repositori.
+ **MyFunction.csproj** — [File proyek.NET, yang mencantumkan file](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) dan rakitan yang terdiri dari aplikasi Anda.
+ **README.md** - File ini berisi informasi lebih lanjut tentang fungsi Lambda sampel.
1. Buka `aws-lambda-tools-defaults.json` file dan Tambahkan baris berikut:
```
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
```
+ **package-type**: Mendefinisikan paket deployment sebagai image container.
+ **docker-host-build-output-dir**: Menetapkan direktori output untuk proses build.
**Example aws-lambda-tools-defaults.json**
```
{
"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": "",
"region": "us-east-1",
"configuration": "Release",
"function-runtime": "provided.al2023",
"function-memory-size": 256,
"function-timeout": 30,
"function-handler": "bootstrap",
"msbuild-parameters": "--self-contained true",
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
}
```
1. Buat Dockerfile di direktori. `MyFunction/src/MyFunction` Contoh berikut Dockerfile menggunakan gambar dasar Microsoft .NET bukan gambar [AWS dasar](#csharp-image-base).
+ Atur `FROM` properti ke pengenal gambar dasar. Gambar dasar dan `TargetFramework` dalam `MyFunction.csproj` file harus menggunakan versi.NET yang sama.
+ Gunakan `COPY` perintah untuk menyalin fungsi ke `/var/task` direktori.
+ Atur `ENTRYPOINT` ke modul yang Anda inginkan untuk menjalankan wadah Docker saat dimulai. Dalam hal ini, modul adalah bootstrap, yang menginisialisasi `Amazon.Lambda.RuntimeSupport` perpustakaan.
Perhatikan bahwa contoh Dockerfile tidak menyertakan instruksi [USER](https://docs.docker.com/reference/dockerfile/#user). Saat Anda menyebarkan gambar kontainer ke Lambda, Lambda secara otomatis mendefinisikan pengguna Linux default dengan izin yang paling tidak memiliki hak istimewa. Ini berbeda dari perilaku Docker standar yang default ke `root` pengguna ketika tidak ada `USER` instruksi yang diberikan.
**Example Dockerfile**
```
# You can also pull these images from DockerHub amazon/aws-lambda-dotnet:8
FROM mcr.microsoft.com/dotnet/runtime:9.0
# Set the image's internal work directory
WORKDIR /var/task
# Copy function code to Lambda-defined environment variable
COPY "bin/Release/net9.0/linux-x64" .
# Set the entrypoint to the bootstrap
ENTRYPOINT ["/usr/bin/dotnet", "exec", "/var/task/bootstrap.dll"]
```
1. [Instal ekstensi Amazon.Lambda.Tools .NET Global Tools.](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/)
```
dotnet tool install -g Amazon.Lambda.Tools
```
Jika Amazon.Lambda.Tools sudah diinstal, pastikan Anda memiliki versi terbaru.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Gunakan Amazon.Lambda.Tools untuk membuat image Docker, mendorongnya ke repositori Amazon ECR baru, dan menerapkan fungsi Lambda.
[Untuk`--function-role`, tentukan nama peran—bukan Nama Sumber Daya Amazon (ARN) —dari peran eksekusi untuk fungsi tersebut.](lambda-intro-execution-role.md) Misalnya, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
[Untuk informasi selengkapnya tentang ekstensi Amazon.Lambda.Tools .NET CLI, lihat ekstensi untuk repositori.NET CLI di AWS .](https://github.com/aws/aws-extensions-for-dotnet-cli) GitHub
1. Memanggil fungsi.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Jika semuanya berhasil, Anda akan melihat hal berikut:
```
Payload:
"TESTING THE FUNCTION"
Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 1 ms Memory Size: 256 MB Max Memory Used: 12 MB
```
1. Hapus fungsi Lambda.
```
dotnet lambda delete-function MyFunction
```
# Kompilasi kode fungsi.NET Lambda ke format runtime asli
.NET 8 mendukung kompilasi asli ahead-of-time (AOT). Dengan AOT asli, Anda dapat mengkompilasi kode fungsi Lambda Anda ke format runtime asli, yang menghilangkan kebutuhan untuk mengkompilasi kode.NET saat runtime. Kompilasi AOT asli dapat mengurangi waktu mulai dingin untuk fungsi Lambda yang Anda tulis di.NET. Untuk informasi selengkapnya, lihat [Memperkenalkan runtime .NET 8 untuk AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/) di AWS Compute Blog.
**Topics**
+ [waktu aktif Lambda](#dotnet-native-aot-runtime)
+ [Prasyarat](#dotnet-native-aot-prerequisites)
+ [Memulai](#dotnet-native-aot-getting-started)
+ [Serialisasi](#dotnet-native-aot-serialization)
+ [Pemangkasan](#dotnet-native-aot-trimming)
+ [Pemecahan Masalah](#dotnet-native-aot-troubleshooting)
## waktu aktif Lambda
Untuk menerapkan build fungsi Lambda dengan kompilasi AOT asli, gunakan runtime .NET 8 Lambda yang dikelola. Runtime ini mendukung penggunaan arsitektur x86\$164 dan arm64.
Saat Anda menerapkan fungsi.NET Lambda tanpa menggunakan AOT, aplikasi Anda pertama kali dikompilasi ke dalam kode Bahasa Menengah (IL). Saat runtime, compiler just-in-time (JIT) di runtime Lambda mengambil kode IL dan mengkompilasinya ke dalam kode mesin sesuai kebutuhan. Dengan fungsi Lambda yang dikompilasi sebelumnya dengan AOT asli, Anda mengkompilasi kode Anda ke dalam kode mesin saat Anda menerapkan fungsi Anda, jadi Anda tidak bergantung pada runtime .NET atau SDK di runtime Lambda untuk mengkompilasi kode Anda sebelum dijalankan.
Salah satu batasan AOT adalah bahwa kode aplikasi Anda harus dikompilasi dalam lingkungan dengan sistem operasi Amazon Linux 2023 (AL2023) yang sama dengan yang digunakan runtime .NET 8. .NET Lambda CLI menyediakan fungsionalitas untuk mengkompilasi aplikasi Anda dalam wadah Docker menggunakan gambar 023. AL2
Untuk menghindari potensi masalah dengan kompatibilitas lintas arsitektur, kami sangat menyarankan agar Anda mengkompilasi kode Anda di lingkungan dengan arsitektur prosesor yang sama dengan yang Anda konfigurasikan untuk fungsi Anda. Untuk mempelajari lebih lanjut tentang batasan kompilasi lintas arsitektur, lihat [Kompilasi silang](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/cross-compile) dalam dokumentasi Microsoft .NET.
## Prasyarat
**Docker**
Untuk menggunakan AOT asli, kode fungsi Anda harus dikompilasi dalam lingkungan dengan sistem operasi AL2 023 yang sama dengan runtime .NET 8. Perintah.NET CLI di bagian berikut menggunakan Docker untuk mengembangkan dan membangun fungsi Lambda di lingkungan 023. AL2
**.NET 8 SDK**
Kompilasi AOT asli adalah fitur dari .NET 8. Anda harus menginstal [.NET 8 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) pada mesin build Anda, tidak hanya runtime.
**Amazon.Lambda.Tools**
Untuk membuat fungsi Lambda Anda, Anda menggunakan [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools)[Ekstensi Alat Global .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/). Untuk menginstal Amazon.Lambda.Tools, jalankan perintah berikut:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Untuk informasi lebih lanjut tentang Amazon.Lambda.Tools .NET CLI extension, lihat [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) repositori.NET di. GitHub
**Amazon.Lambda.Templates**
Untuk menghasilkan kode fungsi Lambda Anda, gunakan [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet paket. Untuk menginstal paket template ini, jalankan perintah berikut:
```
dotnet new install Amazon.Lambda.Templates
```
## Memulai
Baik .NET Global CLI dan AWS Serverless Application Model (AWS SAM) menyediakan template memulai untuk membangun aplikasi menggunakan AOT asli. Untuk membangun fungsi AOT Lambda asli pertama Anda, lakukan langkah-langkah dalam instruksi berikut.
**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 kita`NativeAotSample`.
```
dotnet new lambda.NativeAOT -n NativeAotSample
cd ./NativeAotSample/src/NativeAotSample
```
`Function.cs`File 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
{
///
/// 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.
///
private static async Task Main()
{
Func handler = FunctionHandler;
await LambdaBootstrapBuilder.Create(handler, new SourceGeneratorLambdaJsonSerializer())
.Build()
.RunAsync();
}
///
/// 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.
///
///
///
///
public static string FunctionHandler(string input, ILambdaContext context)
{
return input.ToUpper();
}
}
///
/// 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.
///
[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 dalam`static Main`, runtime Lambda di-bootstrap dan metode disiapkan. `FunctionHandler` Sebagai bagian dari bootstrap runtime, serializer yang dihasilkan sumber dikonfigurasi menggunakan `new SourceGeneratorLambdaJsonSerializer()`
1. 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 gambar AL2 023 Docker dan mengkompilasi kode aplikasi Anda di dalam wadah yang sedang berjalan. Biner yang dikompilasi dikeluarkan kembali ke sistem file lokal Anda sebelum diterapkan ke Lambda.
1. Uji fungsi Anda dengan menjalankan perintah berikut. Ganti `` dengan nama yang Anda pilih untuk fungsi Anda di wizard penerapan.
```
dotnet lambda invoke-function --payload "hello world"
```
Respons dari CLI mencakup detail kinerja untuk start dingin (durasi inisialisasi) dan total waktu berjalan untuk pemanggilan fungsi Anda.
1. Untuk menghapus AWS sumber daya yang Anda buat dengan mengikuti langkah-langkah sebelumnya, jalankan perintah berikut. Ganti `` 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
```
## Serialisasi
Untuk menyebarkan fungsi ke Lambda menggunakan AOT asli, kode fungsi Anda harus [menggunakan](https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/source-generation-modes?pivots=dotnet-8-0) serialisasi yang dihasilkan sumber. Alih-alih menggunakan refleksi run-time untuk mengumpulkan metadata yang diperlukan untuk mengakses properti objek untuk serialisasi, generator sumber menghasilkan file sumber C\$1 yang dikompilasi saat Anda membangun aplikasi Anda. Untuk mengonfigurasi serializer yang dihasilkan sumber Anda dengan benar, pastikan Anda menyertakan objek input dan output apa pun yang digunakan fungsi Anda, serta jenis kustom apa pun. Misalnya, fungsi Lambda yang menerima peristiwa dari API API Gateway REST API dan mengembalikan `Product` tipe kustom akan menyertakan serializer yang didefinisikan sebagai berikut.
```
[JsonSerializable(typeof(APIGatewayProxyRequest))]
[JsonSerializable(typeof(APIGatewayProxyResponse))]
[JsonSerializable(typeof(Product))]
public partial class CustomSerializer : JsonSerializerContext
{
}
```
## Pemangkasan
Native AOT memangkas kode aplikasi Anda sebagai bagian dari kompilasi untuk memastikan bahwa biner sekecil mungkin. .NET 8 untuk Lambda memberikan dukungan pemangkasan yang lebih baik dibandingkan dengan versi sebelumnya .NET. Support telah ditambahkan ke [pustaka runtime Lambda](https://github.com/aws/aws-lambda-dotnet/pull/1596), .NET [SDK,AWS .NET Lambda Annotations](https://github.com/aws/aws-sdk-net/pulls?q=is%3Apr+trimming)[, dan .NET](https://github.com/aws/aws-lambda-dotnet/pull/1610) 8 itu sendiri.
Peningkatan ini menawarkan potensi untuk menghilangkan peringatan pemangkasan waktu pembuatan, tetapi .NET tidak akan pernah sepenuhnya aman. Ini berarti bahwa bagian pustaka yang diandalkan fungsi Anda dapat dipangkas sebagai bagian dari langkah kompilasi. Anda dapat mengelola ini dengan mendefinisikan `TrimmerRootAssemblies` sebagai bagian dari `.csproj` file Anda seperti yang ditunjukkan pada contoh berikut.
```
```
Perhatikan bahwa saat Anda menerima peringatan trim, menambahkan kelas yang menghasilkan peringatan `TrimmerRootAssembly` mungkin tidak menyelesaikan masalah. Peringatan trim menunjukkan bahwa kelas mencoba mengakses beberapa kelas lain yang tidak dapat ditentukan hingga runtime. Untuk menghindari kesalahan runtime, tambahkan kelas kedua ini ke`TrimmerRootAssembly`.
Untuk mempelajari selengkapnya tentang mengelola peringatan trim, lihat [Pengantar untuk memangkas peringatan](https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/fixing-warnings) di dokumentasi Microsoft .NET.
## Pemecahan Masalah
**Kesalahan: Kompilasi asli lintas-OS tidak didukung.**
Versi Anda dari Amazon.Lambda.Tools Alat global.NET Core sudah ketinggalan zaman. Perbarui ke versi terbaru dan coba lagi.
**Docker: sistem operasi gambar “linux” tidak dapat digunakan pada platform ini.**
Docker pada sistem Anda dikonfigurasi untuk menggunakan wadah Windows. Tukar ke wadah Linux untuk menjalankan lingkungan build AOT asli.
Untuk informasi selengkapnya tentang kesalahan umum, lihat repositori [AWS NativeAOT for](https://github.com/awslabs/dotnet-nativeaot-labs#common-errors) .NET di. GitHub
# Menggunakan objek konteks Lambda untuk mengambil informasi fungsi C \$1
Saat Lambda menjalankan fungsi Anda, Lambda meneruskan objek konteks ke [handler](csharp-handler.md). Objek ini menyediakan properti dengan informasi tentang lingkungan invokasi, fungsi, dan eksekusi.
**Properti konteks**
+ `FunctionName` – Nama fungsi Lambda.
+ `FunctionVersion` – [Versi](configuration-versions.md) fungsi.
+ `InvokedFunctionArn` – Amazon Resource Name (ARN) yang digunakan untuk memicu fungsi. Menunjukkan jika pemicu menyebutkan nomor versi atau alias.
+ `MemoryLimitInMB` – Jumlah memori yang dialokasikan untuk fungsi tersebut.
+ `AwsRequestId` – Pengidentifikasi permintaan invokasi.
+ `LogGroupName` – Grup log untuk fungsi.
+ `LogStreamName` – Aliran log untuk instans fungsi.
+ `RemainingTime` (`TimeSpan`) – Jumlah milidetik yang tersisa sebelum waktu eksekusi habis.
+ `Identity` – (aplikasi seluler) Informasi tentang identitas Amazon Cognito yang mengesahkan permintaan.
+ `ClientContext` – (aplikasi seluler) Konteks klien yang disediakan untuk Lambda oleh aplikasi klien.
+ `Logger` [Objek logger](csharp-logging.md) untuk fungsi.
Anda dapat menggunakan informasi dalam `ILambdaContext` objek untuk menampilkan informasi tentang pemanggilan fungsi Anda untuk tujuan pemantauan. Kode berikut memberikan contoh bagaimana menambahkan informasi konteks ke kerangka logging terstruktur. Dalam contoh ini, fungsi `AwsRequestId` menambah output log. Fungsi ini juga menggunakan `RemainingTime` properti untuk membatalkan tugas dalam penerbangan jika batas waktu fungsi Lambda akan tercapai.
```
[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 FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
Logger.AppendKey("AwsRequestId", context.AwsRequestId);
var id = request.PathParameters["id"];
using var cts = new CancellationTokenSource();
try
{
cts.CancelAfter(context.RemainingTime.Add(TimeSpan.FromSeconds(-1)));
var databaseRecord = await this._repo.GetById(id, cts.Token);
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = JsonSerializer.Serialize(databaseRecord)
};
}
catch (Exception ex)
{
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.InternalServerError,
Body = JsonSerializer.Serialize(new { error = ex.Message })
};
}
finally
{
cts.Cancel();
}
}
}
```
# Log dan pantau fungsi C\$1 Lambda
AWS Lambda secara otomatis memonitor fungsi Lambda dan mengirim entri log ke Amazon. CloudWatch Fungsi Lambda Anda dilengkapi dengan grup CloudWatch log Log dan aliran log untuk setiap instance fungsi Anda. Lingkungan runtime Lambda mengirimkan detail tentang setiap pemanggilan dan output lainnya dari kode fungsi Anda ke aliran log. Untuk informasi selengkapnya tentang CloudWatch Log, lihat[Mengirim log fungsi Lambda ke Log CloudWatch](monitoring-cloudwatchlogs.md).
**Topics**
+ [Membuat fungsi yang mengembalikan log](#csharp-logging-output)
+ [Menggunakan kontrol logging lanjutan Lambda dengan.NET](#csharp-logging-advanced)
+ [Alat dan pustaka pencatatan tambahan](#csharp-tools-libraries)
+ [Menggunakan Powertools untuk AWS Lambda (.NET) dan AWS SAM untuk logging terstruktur](#dotnet-logging-sam)
+ [Melihat log di konsol Lambda](#csharp-logging-console)
+ [Melihat log di CloudWatch konsol](#csharp-logging-cwconsole)
+ [Melihat log menggunakan AWS Command Line Interface (AWS CLI)](#csharp-logging-cli)
+ [Menghapus log](#csharp-logging-delete)
## Membuat fungsi yang mengembalikan log
Untuk mengeluarkan log dari kode fungsi, Anda dapat menggunakan [ILambdaLogger](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Core/ILambdaLogger.cs) pada objek konteks, metode di [kelas Console](https://docs.microsoft.com/en-us/dotnet/api/system.console), atau pustaka logging apa pun yang menulis ke `stdout` atau`stderr`.
Runtime .NET mencatat baris `START`, `END`, dan `REPORT` untuk setiap invokasi. Baris laporan memberikan perincian berikut.
**Laporkan bidang data baris**
+ **RequestId** – ID permintaan unik untuk invokasi.
+ **Durasi** – Jumlah waktu yang digunakan oleh metode handler fungsi Anda gunakan untuk memproses peristiwa.
+ **Durasi yang Ditagih** – Jumlah waktu yang ditagihkan untuk invokasi.
+ **Ukuran Memori** – Jumlah memori yang dialokasikan untuk fungsi.
+ **Memori Maks yang Digunakan** – Jumlah memori yang digunakan oleh fungsi. Saat pemanggilan berbagi lingkungan eksekusi, Lambda melaporkan memori maksimum yang digunakan di semua pemanggilan. Perilaku ini dapat menghasilkan nilai yang dilaporkan lebih tinggi dari yang diharapkan.
+ **Durasi Init** – Untuk permintaan pertama yang dilayani, lama waktu yang diperlukan runtime untuk memuat fungsi dan menjalankan kode di luar metode handler.
+ **XRAY TraceId** — Untuk permintaan yang dilacak, ID [AWS X-Ray jejak](services-xray.md).
+ **SegmentId** – Untuk permintaan yang dilacak, ID segmen X-Ray.
+ **Diambil Sampel** – Untuk permintaan yang dilacak, hasil pengambilan sampel.
## Menggunakan kontrol logging lanjutan Lambda dengan.NET
Untuk memberi Anda kontrol lebih besar atas bagaimana log fungsi Anda ditangkap, diproses, dan digunakan, Anda dapat mengonfigurasi opsi logging berikut untuk runtime .NET yang didukung:
+ **Format log** - pilih antara teks biasa dan format JSON terstruktur untuk log fungsi Anda
+ **Tingkat log** - untuk log dalam format JSON, pilih tingkat detail log yang dikirim CloudWatch Lambda, seperti ERROR, DEBUG, atau INFO
+ **Grup log** - pilih grup CloudWatch log yang dikirimkan oleh fungsi Anda
Untuk informasi selengkapnya tentang opsi pencatatan ini, dan petunjuk tentang cara mengonfigurasi fungsi Anda untuk menggunakannya, lihat[Mengkonfigurasi kontrol logging lanjutan untuk fungsi Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
Untuk menggunakan format log dan opsi tingkat log dengan fungsi.NET Lambda Anda, lihat panduan di bagian berikut.
### Menggunakan format log JSON terstruktur dengan.NET
Jika Anda memilih JSON untuk format log fungsi Anda, Lambda akan mengirim output log [ILambdamenggunakan](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Core/ILambdaLogger.cs) Logger sebagai JSON terstruktur. Setiap objek log JSON berisi setidaknya lima pasangan nilai kunci dengan kunci berikut:
+ `"timestamp"`- waktu pesan log dihasilkan
+ `"level"`- tingkat log yang ditetapkan untuk pesan
+ `"requestId"`- ID permintaan unik untuk pemanggilan fungsi
+ `"traceId"`- variabel `_X_AMZN_TRACE_ID` lingkungan
+ `"message"`- isi pesan log
`ILambdaLogger`Instance dapat menambahkan pasangan nilai kunci tambahan, misalnya saat mencatat pengecualian. Anda juga dapat menyediakan parameter tambahan Anda sendiri seperti yang dijelaskan di bagian ini[Parameter log yang disediakan pelanggan](#csharp-logging-advanced-JSON-user-supplied).
**catatan**
Jika kode Anda sudah menggunakan pustaka logging lain untuk menghasilkan log berformat JSON, pastikan format log fungsi Anda disetel ke teks biasa. Menyetel format log ke JSON akan menghasilkan output log Anda dikodekan ganda.
Contoh perintah logging berikut menunjukkan cara menulis pesan log dengan tingkat`INFO`.
**Example Kode logging .NET**
```
context.Logger.LogInformation("Fetching cart from database");
```
Anda juga dapat menggunakan metode log generik yang mengambil tingkat log sebagai argumen seperti yang ditunjukkan pada contoh berikut.
```
context.Logger.Log(LogLevel.Information, "Fetching cart from database");
```
Output log oleh cuplikan kode contoh ini akan ditangkap di CloudWatch Log sebagai berikut:
**Example Catatan log JSON**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Information",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "Fetching cart from database"
}
```
**catatan**
Jika Anda mengonfigurasi format log fungsi Anda untuk menggunakan teks biasa daripada JSON, maka tingkat log yang ditangkap dalam pesan mengikuti konvensi Microsoft menggunakan label empat karakter. Misalnya, tingkat log `Debug` direpresentasikan dalam pesan sebagai`dbug`.
Saat Anda mengonfigurasi fungsi Anda untuk menggunakan log berformat JSON, level log yang ditangkap di log menggunakan label lengkap seperti yang ditunjukkan pada contoh catatan log JSON.
Jika Anda tidak menetapkan level ke output log Anda, Lambda akan secara otomatis menetapkannya INFO level.
#### Pengecualian logging di JSON
Saat menggunakan logging JSON terstruktur`ILambdaLogger`, Anda dapat mencatat pengecualian dalam kode Anda seperti yang ditunjukkan pada contoh berikut.
**Example penggunaan pencatatan pengecualian**
```
try
{
connection.ExecuteQuery(query);
}
catch(Exception e)
{
context.Logger.LogWarning(e, "Error executing query");
}
```
Output format log oleh kode ini ditunjukkan dalam contoh berikut JSON. Perhatikan bahwa `message` properti di JSON diisi menggunakan argumen pesan yang disediakan dalam `LogWarning` panggilan, sedangkan `errorMessage` properti berasal dari `Message` properti pengecualian itu sendiri.
**Example Catatan log JSON**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Warning",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "Error executing query",
"errorType": "System.Data.SqlClient.SqlException",
"errorMessage": "Connection closed",
"stackTrace": [""]
}
```
Jika format logging fungsi Anda disetel ke JSON, Lambda juga mengeluarkan pesan log berformat JSON saat kode Anda melempar pengecualian yang tidak tertangkap. Contoh cuplikan kode berikut dan pesan log menunjukkan bagaimana pengecualian yang tidak tertangkap dicatat.
**Example kode pengecualian**
```
throw new ApplicationException("Invalid data");
```
**Example Catatan log JSON**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Error",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "Invalid data",
"errorType": "System.ApplicationException",
"errorMessage": "Invalid data",
"stackTrace": [""]
}
```
#### Parameter log yang disediakan pelanggan
Dengan pesan log berformat JSON, Anda dapat menyediakan parameter log tambahan dan memasukkannya ke dalam log. `message` Contoh cuplikan kode berikut menunjukkan perintah untuk menambahkan dua parameter yang disediakan pengguna berlabel dan. `retryAttempt` `uri` Dalam contoh, nilai parameter ini berasal dari `uriDestination` argumen `retryAttempt` dan diteruskan ke perintah logging.
**Example Perintah logging JSON dengan parameter tambahan**
```
context.Logger.LogInformation("Starting retry {retryAttempt} to make GET request to {uri}", retryAttempt, uriDestination);
```
Output pesan log oleh perintah ini ditunjukkan dalam contoh berikut JSON.
**Example Catatan log JSON**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Information",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "Starting retry 1 to make GET request to http://example.com/",
"retryAttempt": 1,
"uri": "http://example.com/"
}
```
**Tip**
Anda juga dapat menggunakan properti posisi alih-alih nama saat menentukan parameter tambahan. Misalnya, perintah logging pada contoh sebelumnya juga dapat ditulis sebagai berikut:
```
context.Logger.LogInformation("Starting retry {0} to make GET request to {1}", retryAttempt, uriDestination);
```
Perhatikan bahwa saat Anda menyediakan parameter logging tambahan, Lambda menangkapnya sebagai properti tingkat atas dalam catatan log JSON. Pendekatan ini berbeda dari beberapa pustaka logging .NET populer seperti`Serilog`, yang menangkap parameter tambahan dalam objek anak yang terpisah.
Jika argumen yang Anda berikan untuk parameter tambahan adalah objek yang kompleks, secara default Lambda menggunakan `ToString()` metode untuk memberikan nilai. Untuk menunjukkan bahwa argumen harus JSON serial, gunakan `@` awalan seperti yang ditunjukkan dalam cuplikan kode berikut. Dalam contoh ini, `User` adalah objek dengan `FirstName` dan `LastName` properti.
**Example Perintah logging JSON dengan objek serial JSON**
```
context.Logger.LogInformation("User {@user} logged in", User);
```
Output pesan log oleh perintah ini ditunjukkan dalam contoh berikut JSON.
**Example Catatan log JSON**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Information",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "User {@user} logged in",
"user":
{
"FirstName": "John",
"LastName": "Doe"
}
}
```
Jika argumen untuk parameter tambahan adalah array atau mengimplementasikan `IList` atau`IDictionary`, maka Lambda menambahkan argumen ke pesan log JSON sebagai array seperti yang ditunjukkan dalam contoh berikut catatan log JSON. Dalam contoh ini, `{users}` mengambil `IList` argumen yang berisi contoh `User` properti dengan format yang sama seperti contoh sebelumnya. Lambda mengubah ini `IList` menjadi array, dengan setiap nilai yang dibuat menggunakan metode. `ToString`
**Example Catatan log JSON dengan argumen `IList`**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Information",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "{users} have joined the group",
"users":
[
"Rosalez, Alejandro",
"Stiles, John"
]
}
```
Anda juga dapat membuat serial JSON daftar dengan menggunakan `@` awalan dalam perintah logging Anda. Dalam contoh catatan log JSON berikut, `users` properti adalah serial JSON.
**Example Catatan log JSON dengan argumen serial JSON `IList`**
```
{
"timestamp": "2025-09-07T01:30:06.977Z",
"level": "Information",
"requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
"traceId": "1-6408af34-50f56f5b5677a7d763973804",
"message": "{@users} have joined the group",
"users":
[
{
"FirstName": "Alejandro",
"LastName": "Rosalez"
},
{
"FirstName": "John",
"LastName": "Stiles"
}
]
}
```
### Menggunakan penyaringan tingkat log dengan.NET
Dengan mengonfigurasi penyaringan tingkat log, Anda dapat memilih untuk mengirim hanya log dengan tingkat detail tertentu atau lebih rendah ke Log. CloudWatch Untuk mempelajari cara mengonfigurasi pemfilteran tingkat log untuk fungsi Anda, lihat. [Pemfilteran tingkat log](monitoring-cloudwatchlogs-log-level.md)
AWS Lambda Untuk memfilter pesan log Anda berdasarkan tingkat log, Anda dapat menggunakan log berformat JSON atau menggunakan `Console` metode.NET untuk menampilkan pesan log. Untuk membuat log berformat JSON, [konfigurasikan jenis log fungsi Anda ke JSON](monitoring-cloudwatchlogs-logformat.md#monitoring-cloudwatchlogs-set-format) dan gunakan instance. `ILambdaLogger`
Dengan log berformat JSON, Lambda memfilter output log Anda menggunakan pasangan nilai kunci “level” di objek JSON yang dijelaskan di. [Menggunakan format log JSON terstruktur dengan.NET](#csharp-logging-advanced-JSON)
Jika Anda menggunakan `Console` metode.NET untuk menulis pesan ke CloudWatch Log, Lambda menerapkan tingkat log ke pesan Anda sebagai berikut:
+ **Konsol. WriteLine **metode - Lambda menerapkan log-level `INFO`
+ **Metode Console.Error -** Lambda menerapkan log-level `ERROR`
Ketika Anda mengonfigurasi fungsi Anda untuk menggunakan pemfilteran tingkat log, Anda harus memilih dari opsi berikut untuk tingkat log yang ingin Lambda kirim ke Log. CloudWatch Perhatikan pemetaan level log yang digunakan oleh Lambda dengan level Microsoft standar yang digunakan oleh.NET. `ILambdaLogger`
| Tingkat log Lambda | Level Microsoft yang setara | Penggunaan standar |
| --- | --- | --- |
| TRACE (paling detail) | Jejak | Informasi paling halus yang digunakan untuk melacak jalur eksekusi kode Anda |
| DEBUG | Debug | Informasi terperinci untuk debugging sistem |
| INFO | Informasi | Pesan yang merekam operasi normal fungsi Anda |
| WARN | Peringatan | Pesan tentang potensi kesalahan yang dapat menyebabkan perilaku tak terduga jika tidak ditangani |
| ERROR | Kesalahan | Pesan tentang masalah yang mencegah kode berfungsi seperti yang diharapkan |
| FATAL (paling detail) | Kritis | Pesan tentang kesalahan serius yang menyebabkan aplikasi berhenti berfungsi |
Lambda mengirimkan log dari tingkat detail yang dipilih dan lebih rendah ke. CloudWatch Misalnya, jika Anda mengonfigurasi level log WARN, Lambda akan mengirim log yang sesuai dengan level WARN, ERROR, dan FATAL.
## Alat dan pustaka pencatatan tambahan
[Powertools for AWS Lambda (.NET)](https://docs.aws.amazon.com/powertools/dotnet/) adalah toolkit pengembang untuk mengimplementasikan praktik terbaik Tanpa Server dan meningkatkan kecepatan pengembang. [Utilitas Logging](https://docs.aws.amazon.com/powertools/dotnet/core/logging/) menyediakan logger yang dioptimalkan Lambda yang mencakup informasi tambahan tentang konteks fungsi di semua fungsi Anda dengan output terstruktur sebagai JSON. Gunakan utilitas ini untuk melakukan hal berikut:
+ Tangkap bidang kunci dari konteks Lambda, cold start, dan struktur logging output sebagai JSON
+ Log peristiwa pemanggilan Lambda saat diinstruksikan (dinonaktifkan secara default)
+ Cetak semua log hanya untuk persentase pemanggilan melalui pengambilan sampel log (dinonaktifkan secara default)
+ Tambahkan kunci tambahan ke log terstruktur kapan saja
+ Gunakan pemformat log kustom (Bring Your Own Formatter) untuk mengeluarkan log dalam struktur yang kompatibel dengan RFC Logging organisasi Anda
## Menggunakan Powertools untuk AWS Lambda (.NET) dan AWS SAM untuk logging terstruktur
Ikuti langkah-langkah di bawah ini untuk mengunduh, membangun, dan menyebarkan contoh aplikasi Hello World C \$1 dengan [Powertools terintegrasi untuk modul AWS Lambda (.NET)](https://docs.powertools.aws.dev/lambda-dotnet) menggunakan modul. AWS SAM Aplikasi ini mengimplementasikan backend API dasar dan menggunakan Powertools untuk memancarkan log, metrik, dan jejak. Ini terdiri dari titik akhir Amazon API Gateway dan fungsi Lambda. Saat Anda mengirim permintaan GET ke titik akhir API Gateway, fungsi Lambda memanggil, mengirim log dan metrik menggunakan Format Metrik Tertanam CloudWatch ke, dan mengirimkan jejak ke. AWS X-Ray Fungsi mengembalikan `hello world` pesan.
**Prasyarat**
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ .NET 8
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versi 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) atau yang lebih baru. Jika Anda memiliki versi CLI yang lebih lama, lihat [Memutakhirkan AWS SAM CLI. AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade)
**Menyebarkan aplikasi sampel AWS SAM**
1. Inisialisasi aplikasi menggunakan TypeScript template Hello World.
```
sam init --app-template hello-world-powertools-dotnet --name sam-app --package-type Zip --runtime dotnet6 --no-tracing
```
1. Bangun aplikasi.
```
cd sam-app && sam build
```
1. Terapkan aplikasi.
```
sam deploy --guided
```
1. Ikuti petunjuk di layar. Untuk menerima opsi default yang disediakan dalam pengalaman interaktif, tekan`Enter`.
**catatan**
Karena **HelloWorldFunction mungkin tidak memiliki otorisasi yang ditentukan, Apakah ini baik-baik saja?** , pastikan untuk masuk`y`.
1. Dapatkan URL aplikasi yang digunakan:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Memanggil titik akhir API:
```
curl -X GET
```
Jika berhasil, Anda akan melihat tanggapan ini:
```
{"message":"hello world"}
```
1. Untuk mendapatkan log untuk fungsi tersebut, jalankan [log sam](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Untuk informasi selengkapnya, lihat [Bekerja dengan log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) di *Panduan AWS Serverless Application Model Pengembang*.
```
sam logs --stack-name sam-app
```
Output log terlihat seperti ini:
```
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:27.988000 INIT_START Runtime Version: dotnet:6.v13 Runtime Version ARN: arn:aws:lambda:ap-southeast-2::runtime:699f346a05dae24c58c45790bc4089f252bf17dae3997e79b17d939a288aa1ec
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:28.229000 START RequestId: bed25b38-d012-42e7-ba28-f272535fb80e Version: $LATEST
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:29.259000 2025-09-20T14:15:29.201Z bed25b38-d012-42e7-ba28-f272535fb80e info {"_aws":{"Timestamp":1676902528962,"CloudWatchMetrics":[{"Namespace":"sam-app-logging","Metrics":[{"Name":"ColdStart","Unit":"Count"}],"Dimensions":[["FunctionName"],["Service"]]}]},"FunctionName":"sam-app-HelloWorldFunction-haKIoVeose2p","Service":"PowertoolsHelloWorld","ColdStart":1}
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.479000 2025-09-20T14:15:30.479Z bed25b38-d012-42e7-ba28-f272535fb80e info {"ColdStart":true,"XrayTraceId":"1-63f3807f-5dbcb9910c96f50742707542","CorrelationId":"d3d4de7f-4ccc-411a-a549-4d67b2fdc015","FunctionName":"sam-app-HelloWorldFunction-haKIoVeose2p","FunctionVersion":"$LATEST","FunctionMemorySize":256,"FunctionArn":"arn:aws:lambda:ap-southeast-2:123456789012:function:sam-app-HelloWorldFunction-haKIoVeose2p","FunctionRequestId":"bed25b38-d012-42e7-ba28-f272535fb80e","Timestamp":"2025-09-20T14:15:30.4602970Z","Level":"Information","Service":"PowertoolsHelloWorld","Name":"AWS.Lambda.Powertools.Logging.Logger","Message":"Hello world API - HTTP 200"}
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.599000 2025-09-20T14:15:30.599Z bed25b38-d012-42e7-ba28-f272535fb80e info {"_aws":{"Timestamp":1676902528922,"CloudWatchMetrics":[{"Namespace":"sam-app-logging","Metrics":[{"Name":"ApiRequestCount","Unit":"Count"}],"Dimensions":[["Service"]]}]},"Service":"PowertoolsHelloWorld","ApiRequestCount":1}
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.680000 END RequestId: bed25b38-d012-42e7-ba28-f272535fb80e
2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.680000 REPORT RequestId: bed25b38-d012-42e7-ba28-f272535fb80e Duration: 2450.99 ms Billed Duration: 2692 ms Memory Size: 256 MB Max Memory Used: 74 MB Init Duration: 240.05 ms
XRAY TraceId: 1-63f3807f-5dbcb9910c96f50742707542 SegmentId: 16b362cd5f52cba0
```
1. Ini adalah titik akhir API publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir setelah pengujian.
```
sam delete
```
### Mengelola retensi log
Grup log tidak terhapus secara otomatis ketika Anda menghapus suatu fungsi. Untuk menghindari penyimpanan log tanpa batas waktu, hapus grup log, atau konfigurasikan periode retensi setelah itu secara CloudWatch otomatis menghapus log. Untuk mengatur penyimpanan log, tambahkan yang berikut ini ke AWS SAM templat Anda:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
# Omitting other properties
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
RetentionInDays: 7
```
## Melihat log di konsol Lambda
Anda dapat menggunakan konsol Lambda untuk melihat output log setelah Anda memanggil fungsi Lambda.
Jika kode Anda dapat diuji dari editor **Kode** tertanam, Anda akan menemukan log dalam **hasil eksekusi**. Saat Anda menggunakan fitur pengujian konsol untuk menjalankan fungsi, Anda akan menemukan **Keluaran Log** di bagian **Detail**.
## Melihat log di CloudWatch konsol
Anda dapat menggunakan CloudWatch konsol Amazon untuk melihat log untuk semua pemanggilan fungsi Lambda.
**Untuk melihat log di CloudWatch konsol**
1. Buka [halaman Grup log](https://console.aws.amazon.com/cloudwatch/home?#logs:) di CloudWatch konsol.
1. Pilih grup log untuk fungsi Anda (**/aws/lambda/ *your-function-name***).
1. Pilih pengaliran log.
Setiap aliran log sesuai dengan [instans fungsi Anda](lambda-runtime-environment.md). Aliran log muncul saat Anda memperbarui fungsi Lambda, dan saat instance tambahan dibuat untuk menangani pemanggilan bersamaan. Untuk menemukan log untuk pemanggilan tertentu, kami sarankan untuk menginstrumentasi fungsi Anda dengan. AWS X-Ray X-Ray mencatat detail tentang permintaan dan pengaliran log di jejak.
## Melihat log menggunakan AWS Command Line Interface (AWS CLI)
AWS CLI Ini adalah alat sumber terbuka yang memungkinkan Anda berinteraksi dengan AWS layanan menggunakan perintah di shell baris perintah Anda. Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) untuk mengambil log untuk invokasi menggunakan opsi perintah `--log-type`. Respons berisi bidang `LogResult` yang memuat hingga 4 KB log berkode base64 dari invokasi.
**Example mengambil ID log**
Contoh berikut menunjukkan cara mengambil *ID log* dari `LogResult` untuk fungsi bernama `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Anda akan melihat output berikut:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example mendekode log**
Pada prompt perintah yang sama, gunakan utilitas `base64` untuk mendekodekan log. Contoh berikut menunjukkan cara mengambil log berkode base64 untuk `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.
Anda akan melihat output berikut:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
Utilitas `base64` tersedia di Linux, macOS, dan [Ubuntu pada Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Pengguna macOS mungkin harus menggunakan `base64 -D`.
**Example Skrip get-logs.sh**
Pada prompt perintah yang sama, gunakan script berikut untuk mengunduh lima peristiwa log terakhir. Skrip menggunakan `sed` untuk menghapus kutipan dari file output, dan akan tidur selama 15 detik untuk memberikan waktu agar log tersedia. Output mencakup respons dari Lambda dan output dari perintah `get-log-events`.
Salin konten dari contoh kode berikut dan simpan dalam direktori proyek Lambda Anda sebagai `get-logs.sh`.
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS dan Linux (khusus)**
Pada prompt perintah yang sama, pengguna macOS dan Linux mungkin perlu menjalankan perintah berikut untuk memastikan skrip dapat dijalankan.
```
chmod -R 755 get-logs.sh
```
**Example mengambil lima log acara terakhir**
Pada prompt perintah yang sama, gunakan skrip berikut untuk mendapatkan lima log acara terakhir.
```
./get-logs.sh
```
Anda akan melihat output berikut:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Menghapus log
Grup log tidak terhapus secara otomatis ketika Anda menghapus suatu fungsi. Untuk menghindari penyimpanan log secara tidak terbatas, hapus kelompok log, atau [lakukan konfigurasi periode penyimpanan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention), yang setelahnya log akan dihapus secara otomatis.
# Menginstrumentasi kode C \$1 di AWS Lambda
Lambda terintegrasi dengan AWS X-Ray untuk membantu Anda melacak, men-debug, dan mengoptimalkan aplikasi Lambda. Anda dapat menggunakan X-Ray untuk melacak permintaan saat melintasi sumber daya dalam aplikasi Anda, yang mungkin termasuk fungsi Lambda dan layanan lainnya. AWS
Untuk mengirim data penelusuran ke X-Ray, Anda dapat menggunakan salah satu dari tiga pustaka SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel) — Distribusi SDK () yang aman, siap produksi, dan AWS didukung. OpenTelemetry OTel
+ [AWS X-Ray SDK for .NET](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-dotnet.html)SDK untuk menghasilkan dan mengirim data jejak ke X-Ray.
+ [Powertools for AWS Lambda (.NET)](https://docs.aws.amazon.com/powertools/dotnet/) — Toolkit pengembang untuk menerapkan praktik terbaik Tanpa Server dan meningkatkan kecepatan pengembang.
Masing-masing SDKs menawarkan cara untuk mengirim data telemetri Anda ke layanan X-Ray. Anda kemudian dapat menggunakan X-Ray untuk melihat, memfilter, dan mendapatkan wawasan tentang metrik kinerja aplikasi Anda untuk mengidentifikasi masalah dan peluang untuk pengoptimalan.
**penting**
X-Ray dan Powertools untuk AWS Lambda SDKs adalah bagian dari solusi instrumentasi terintegrasi yang ditawarkan oleh. AWS Lapisan Lambda ADOT adalah bagian dari standar industri untuk melacak instrumentasi yang mengumpulkan lebih banyak data secara umum, tetapi mungkin tidak cocok untuk semua kasus penggunaan. Anda dapat menerapkan end-to-end penelusuran di X-Ray menggunakan salah satu solusi. Untuk mempelajari lebih lanjut tentang memilih di antara mereka, lihat [Memilih antara AWS Distro untuk Telemetri Terbuka dan](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) X-Ray. SDKs
**Topics**
+ [Menggunakan Powertools untuk AWS Lambda (.NET) dan AWS SAM untuk melacak](#dotnet-tracing-sam)
+ [Menggunakan X-Ray SDK untuk instrumen fungsi.NET Anda](#dotnet-xray-sdk)
+ [Mengaktifkan penelusuran dengan konsol Lambda](#dotnet-tracing-console)
+ [Mengaktifkan penelusuran dengan Lambda API](#dotnet-tracing-api)
+ [Mengaktifkan penelusuran dengan CloudFormation](#dotnet-tracing-cloudformation)
+ [Menafsirkan jejak X-Ray](#dotnet-tracing-interpretation)
## Menggunakan Powertools untuk AWS Lambda (.NET) dan AWS SAM untuk melacak
Ikuti langkah-langkah di bawah ini untuk mengunduh, membangun, dan menyebarkan contoh aplikasi Hello World C \$1 dengan [Powertools terintegrasi untuk modul AWS Lambda (.NET)](https://docs.powertools.aws.dev/lambda-dotnet) menggunakan modul. AWS SAM Aplikasi ini mengimplementasikan backend API dasar dan menggunakan Powertools untuk memancarkan log, metrik, dan jejak. Ini terdiri dari titik akhir Amazon API Gateway dan fungsi Lambda. Saat Anda mengirim permintaan GET ke titik akhir API Gateway, fungsi Lambda memanggil, mengirim log dan metrik menggunakan Format Metrik Tertanam CloudWatch ke, dan mengirimkan jejak ke. AWS X-Ray Fungsi mengembalikan pesan hello world.
**Prasyarat**
Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ .NET 8
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versi 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) atau yang lebih baru. Jika Anda memiliki versi CLI yang lebih lama, lihat [Memutakhirkan AWS SAM CLI. AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade)
**Menyebarkan aplikasi sampel AWS SAM**
1. Inisialisasi aplikasi menggunakan TypeScript template Hello World.
```
sam init --app-template hello-world-powertools-dotnet --name sam-app --package-type Zip --runtime dotnet6 --no-tracing
```
1. Bangun aplikasi.
```
cd sam-app && sam build
```
1. Terapkan aplikasi.
```
sam deploy --guided
```
1. Ikuti petunjuk di layar. Untuk menerima opsi default yang disediakan dalam pengalaman interaktif, tekan`Enter`.
**catatan**
Karena **HelloWorldFunction mungkin tidak memiliki otorisasi yang ditentukan, Apakah ini baik-baik saja?** , pastikan untuk masuk`y`.
1. Dapatkan URL aplikasi yang digunakan:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Memanggil titik akhir API:
```
curl
```
Jika berhasil, Anda akan melihat tanggapan ini:
```
{"message":"hello world"}
```
1. Untuk mendapatkan jejak untuk fungsi tersebut, jalankan [jejak sam](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
Output jejak terlihat seperti ini:
```
New XRay Service Graph
Start time: 2023-02-20 23:05:16+08:00
End time: 2023-02-20 23:05:16+08:00
Reference Id: 0 - AWS::Lambda - sam-app-HelloWorldFunction-pNjujb7mEoew - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 2.814
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-pNjujb7mEoew - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 2.429
Reference Id: 2 - (Root) AWS::ApiGateway::Stage - sam-app/Prod - Edges: [0]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 2.839
Reference Id: 3 - client - sam-app/Prod - Edges: [2]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 3] at (2023-02-20T23:05:16.521000) with id (1-63f38c2c-270200bf1d292a442c8e8a00) and duration (2.877s)
- 2.839s - sam-app/Prod [HTTP: 200]
- 2.836s - Lambda [HTTP: 200]
- 2.814s - sam-app-HelloWorldFunction-pNjujb7mEoew [HTTP: 200]
- 2.429s - sam-app-HelloWorldFunction-pNjujb7mEoew
- 0.230s - Initialization
- 2.389s - Invocation
- 0.600s - ## FunctionHandler
- 0.517s - Get Calling IP
- 0.039s - Overhead
```
1. Ini adalah titik akhir API publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir setelah pengujian.
```
sam delete
```
X-Ray tidak melacak semua permintaan ke aplikasi Anda. X-Ray menerapkan algoritma pengambilan sampel untuk memastikan bahwa penelusuran efisien, sambil tetap memberikan sampel yang representatif dari semua permintaan. Tingkat pengambilan sampel adalah 1 permintaan per detik dan 5 persen dari permintaan tambahan. Anda tidak dapat mengonfigurasi laju pengambilan sampel X-Ray untuk fungsi Anda.
## Menggunakan X-Ray SDK untuk instrumen fungsi.NET Anda
Anda dapat menggunakan instrumen kode fungsi Anda untuk merekam metadata dan melacak panggilan downstream. Untuk merekam detail tentang panggilan yang dilakukan fungsi Anda ke sumber daya dan layanan lain, gunakan file AWS X-Ray SDK for .NET. Untuk mendapatkan SDK, tambahkan paket `AWSXRayRecorder` ke file proyek Anda.
```
net8.0
true
Lambda
```
Ada berbagai paket Nuget yang menyediakan instrumentasi otomatis untuk AWS SDKs, Entity Framework dan permintaan HTTP. Untuk melihat set lengkap opsi konfigurasi, lihat [AWS X-Ray SDK for](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-dotnet.html) .NET di Panduan *AWS X-Ray Pengembang*.
Setelah Anda menambahkan paket Nuget yang diinginkan, konfigurasikan instrumentasi otomatis. Praktik terbaik adalah melakukan konfigurasi ini di luar fungsi handler fungsi Anda. Hal ini memungkinkan Anda untuk mengambil keuntungan dari penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda. Dalam contoh kode berikut, `RegisterXRayForAllServices` metode ini dipanggil dalam konstruktor fungsi untuk menambahkan instrumentasi untuk semua panggilan AWS SDK.
```
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace GetProductHandler;
public class Function
{
private readonly IDatabaseRepository _repo;
public Function()
{
// Add auto instrumentation for all AWS SDK calls
// It is important to call this method before initializing any SDK clients
AWSSDKHandler.RegisterXRayForAllServices();
this._repo = new DatabaseRepository();
}
public async Task 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)
};
}
}
```
## Mengaktifkan penelusuran dengan konsol Lambda
Untuk mengaktifkan penelusuran aktif pada fungsi Lambda Anda dengan konsol, ikuti langkah-langkah berikut:
**Untuk mengaktifkan penelusuran aktif**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi.
1. Pilih **Konfigurasi** dan kemudian pilih **Alat Pemantauan dan operasi**.
1. Di bawah **Alat pemantauan tambahan**, pilih **Edit**.
1. Di bawah **Sinyal CloudWatch Aplikasi dan AWS X-Ray**, pilih **Aktifkan** untuk **jejak layanan Lambda**.
1. Pilih **Simpan**.
## Mengaktifkan penelusuran dengan Lambda API
Konfigurasikan penelusuran pada fungsi Lambda Anda dengan AWS CLI AWS atau SDK, gunakan operasi API berikut:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
Contoh AWS CLI perintah berikut memungkinkan penelusuran aktif pada fungsi bernama **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
Mode penelusuran adalah bagian dari konfigurasi khusus versi saat Anda memublikasikan versi fungsi Anda. Anda tidak dapat mengubah mode pelacakan pada versi yang telah diterbitkan.
## Mengaktifkan penelusuran dengan CloudFormation
Untuk mengaktifkan penelusuran pada `AWS::Lambda::Function` sumber daya dalam CloudFormation templat, gunakan `TracingConfig` properti.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Konfigurasi pelacakan**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Untuk sumber `AWS::Serverless::Function` daya AWS Serverless Application Model (AWS SAM), gunakan `Tracing` properti.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Konfigurasi pelacakan**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Menafsirkan jejak X-Ray
Fungsi Anda memerlukan izin untuk mengunggah data jejak ke X-Ray. [Saat Anda mengaktifkan penelusuran di konsol Lambda, Lambda menambahkan izin yang diperlukan ke peran eksekusi fungsi Anda.](lambda-intro-execution-role.md) Atau, tambahkan kebijakan [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) ke peran eksekusi.
Setelah mengonfigurasi penelusuran aktif, Anda dapat mengamati permintaan tertentu melalui aplikasi Anda. [Grafik layanan X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) menunjukkan informasi tentang aplikasi Anda dan semua komponennya. Contoh berikut menunjukkan aplikasi dengan dua fungsi. Fungsi utama memproses kejadian dan terkadang mengembalikan kesalahan. Fungsi kedua di bagian atas memproses kesalahan yang muncul di grup log pertama dan menggunakan AWS SDK untuk memanggil X-Ray, Amazon Simple Storage Service (Amazon S3), dan Amazon Logs. CloudWatch
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
X-Ray tidak melacak semua permintaan ke aplikasi Anda. X-Ray menerapkan algoritma pengambilan sampel untuk memastikan bahwa penelusuran efisien, sambil tetap memberikan sampel yang representatif dari semua permintaan. Tingkat pengambilan sampel adalah 1 permintaan per detik dan 5 persen dari permintaan tambahan. Anda tidak dapat mengonfigurasi laju pengambilan sampel X-Ray untuk fungsi Anda.
Di X-Ray, *jejak* merekam informasi tentang permintaan yang diproses oleh satu atau beberapa *layanan*. Lambda mencatat 2 segmen per jejak, yang menciptakan dua node pada grafik layanan. Gambar berikut menyoroti dua node ini:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/xray-servicemap-function.png)
Node pertama di sebelah kiri mewakili layanan Lambda, yang menerima permintaan pemanggilan. Node kedua mewakili fungsi Lambda spesifik Anda. Contoh berikut menunjukkan jejak dengan dua segmen ini. Keduanya bernama **fungsi saya**, tetapi yang satu memiliki asal `AWS::Lambda` dan yang lainnya memiliki asal usul. `AWS::Lambda::Function` Jika `AWS::Lambda` segmen menunjukkan kesalahan, layanan Lambda mengalami masalah. Jika `AWS::Lambda::Function` segmen menunjukkan kesalahan, fungsi Anda mengalami masalah.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Contoh ini memperluas `AWS::Lambda::Function` segmen untuk menunjukkan tiga subsegmennya.
**catatan**
AWS saat ini menerapkan perubahan pada layanan Lambda. Karena perubahan ini, Anda mungkin melihat perbedaan kecil antara struktur dan konten pesan log sistem dan segmen pelacakan yang dipancarkan oleh fungsi Lambda yang berbeda di Anda. Akun AWS
Contoh jejak yang ditunjukkan di sini menggambarkan segmen fungsi gaya lama. Perbedaan antara segmen gaya lama dan baru dijelaskan dalam paragraf berikut.
Perubahan ini akan diterapkan selama beberapa minggu mendatang, dan semua fungsi di semua Wilayah AWS kecuali China GovCloud dan wilayah akan bertransisi untuk menggunakan pesan log format baru dan segmen pelacakan.
Segmen fungsi gaya lama berisi subsegmen berikut:
+ **Inisialisasi** – Mewakili waktu yang dihabiskan untuk memuat fungsi dan menjalankan [kode inisialisasi](foundation-progmodel.md). Subsegmen ini hanya muncul untuk peristiwa pertama yang diproses oleh setiap instance fungsi Anda.
+ **Doa** - Merupakan waktu yang dihabiskan untuk menjalankan kode handler Anda.
+ **Overhead** - Merupakan waktu yang dihabiskan runtime Lambda untuk mempersiapkan diri untuk menangani acara berikutnya.
Segmen fungsi gaya baru tidak berisi subsegmen. `Invocation` Sebagai gantinya, subsegmen pelanggan dilampirkan langsung ke segmen fungsi. Untuk informasi lebih lanjut tentang struktur segmen fungsi gaya lama dan baru, lihat. [Memahami jejak X-Ray](services-xray.md#services-xray-traces)
Anda juga dapat melakukan instrumentasi klien HTTP, merekam kueri SQL, dan membuat subsegmen khusus dengan anotasi dan metadata. Untuk informasi selengkapnya, lihat [AWS X-Ray SDK for .NET](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-dotnet.html)di *Panduan AWS X-Ray Pengembang*.
**Harga**
Anda dapat menggunakan penelusuran X-Ray secara gratis setiap bulan hingga batas tertentu sebagai bagian dari Tingkat AWS Gratis. Di luar ambang batas itu, X-Ray mengenakan biaya untuk penyimpanan dan pengambilan jejak. Untuk informasi lebih lanjut, lihat [ Harga AWS X-Ray](https://aws.amazon.com/xray/pricing/).
# AWS Lambda pengujian fungsi di C \$1
**catatan**
Lihat bagian [Fungsi pengujian](testing-guide.md) untuk pengenalan lengkap tentang teknik dan praktik terbaik untuk menguji solusi tanpa server.
Menguji fungsi tanpa server menggunakan jenis dan teknik pengujian tradisional, tetapi Anda juga harus mempertimbangkan pengujian aplikasi tanpa server secara keseluruhan. Pengujian berbasis cloud akan memberikan ukuran kualitas **yang paling akurat** dari fungsi dan aplikasi tanpa server Anda.
Arsitektur aplikasi tanpa server mencakup layanan terkelola yang menyediakan fungsionalitas aplikasi penting melalui panggilan API. Untuk alasan ini, siklus pengembangan Anda harus menyertakan pengujian otomatis yang memverifikasi fungsionalitas saat fungsi dan layanan Anda berinteraksi.
Jika Anda tidak membuat pengujian berbasis cloud, Anda dapat mengalami masalah karena perbedaan antara lingkungan lokal dan lingkungan yang diterapkan. Proses integrasi berkelanjutan Anda harus menjalankan pengujian terhadap serangkaian sumber daya yang disediakan di cloud sebelum mempromosikan kode Anda ke lingkungan penerapan berikutnya, seperti QA, Staging, atau Production.
Lanjutkan membaca panduan singkat ini untuk mempelajari strategi pengujian untuk aplikasi tanpa server, atau kunjungi [repositori Sampel Uji Tanpa Server](https://github.com/aws-samples/serverless-test-samples) untuk menyelami contoh-contoh praktis, khusus untuk bahasa dan runtime pilihan Anda.
![\[illustration showing the relationship between types of tests\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/test-type-illustration2.png)
Untuk pengujian tanpa server, Anda masih akan menulis *unit*, *integrasi*, dan *end-to-end*pengujian.
+ **Tes unit** - Tes yang dijalankan terhadap blok kode yang terisolasi. Misalnya, memverifikasi logika bisnis untuk menghitung biaya pengiriman yang diberikan item dan tujuan tertentu.
+ **Tes integrasi** - Tes yang melibatkan dua atau lebih komponen atau layanan yang berinteraksi, biasanya di lingkungan cloud. Misalnya, memverifikasi fungsi memproses peristiwa dari antrian.
+ **End-to-end tes** - Tes yang memverifikasi perilaku di seluruh aplikasi. Misalnya, memastikan infrastruktur diatur dengan benar dan bahwa peristiwa mengalir antar layanan seperti yang diharapkan untuk merekam pesanan pelanggan.
## Menguji aplikasi tanpa server Anda
Anda biasanya akan menggunakan campuran pendekatan untuk menguji kode aplikasi tanpa server Anda, termasuk pengujian di cloud, pengujian dengan tiruan, dan kadang-kadang menguji dengan emulator.
### Pengujian di cloud
Pengujian di cloud sangat berharga untuk semua fase pengujian, termasuk pengujian unit, pengujian integrasi, dan end-to-end pengujian. Anda menjalankan pengujian terhadap kode yang diterapkan di cloud dan berinteraksi dengan layanan berbasis cloud. Pendekatan ini memberikan ukuran kualitas kode Anda yang **paling akurat**.
Cara mudah untuk men-debug fungsi Lambda Anda di cloud adalah melalui konsol dengan acara pengujian. *Peristiwa pengujian* adalah input JSON ke fungsi Anda. Jika fungsi Anda tidak memerlukan input, acara dapat berupa dokumen `({})` JSON kosong. Konsol menyediakan contoh peristiwa untuk berbagai integrasi layanan. Setelah membuat acara di konsol, Anda dapat membagikannya dengan tim Anda untuk membuat pengujian lebih mudah dan konsisten.
**catatan**
[Menguji fungsi di konsol](testing-functions.md) adalah cara cepat untuk memulai, tetapi mengotomatiskan siklus pengujian Anda memastikan kualitas aplikasi dan kecepatan pengembangan.
### Alat pengujian
Untuk mempercepat siklus pengembangan Anda, ada sejumlah alat dan teknik yang dapat Anda gunakan saat menguji fungsi Anda. Misalnya, [AWS SAM Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-sync.html) dan [AWS CDK watch mode](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch) mengurangi waktu yang diperlukan untuk memperbarui lingkungan cloud.
Cara Anda mendefinisikan kode fungsi Lambda Anda membuatnya mudah untuk menambahkan pengujian unit. Lambda membutuhkan konstruktor publik tanpa parameter untuk menginisialisasi kelas Anda. Memperkenalkan konstruktor internal kedua memberi Anda kendali atas dependensi yang digunakan aplikasi Anda.
```
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace GetProductHandler;
public class Function
{
private readonly IDatabaseRepository _repo;
public Function(): this(null)
{
}
internal Function(IDatabaseRepository repo)
{
this._repo = repo ?? new DatabaseRepository();
}
public async Task 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)
};
}
}
```
Untuk menulis tes untuk fungsi ini, Anda dapat menginisialisasi instance baru `Function` kelas Anda dan meneruskan implementasi tiruan dari. `IDatabaseRepository` Contoh di bawah ini menggunakan `XUnit``Moq`,, dan `FluentAssertions` untuk menulis tes sederhana memastikan `FunctionHandler` pengembalian kode status 200.
```
using Xunit;
using Moq;
using FluentAssertions;
public class FunctionTests
{
[Fact]
public async Task TestLambdaHandler_WhenInputIsValid_ShouldReturn200StatusCode()
{
// Arrange
var mockDatabaseRepository = new Mock();
var functionUnderTest = new Function(mockDatabaseRepository.Object);
// Act
var response = await functionUnderTest.FunctionHandler(new APIGatewayProxyRequest());
// Assert
response.StatusCode.Should().Be(200);
}
}
```
Untuk contoh yang lebih rinci, termasuk contoh pengujian asinkron, lihat repositori [sampel pengujian .NET](https://github.com/aws-samples/serverless-test-samples/tree/main/dotnet-test-samples) pada. GitHub