Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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
```