Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan CLI Global .NET Lambda
<a name="csharp-package-cli"></a>

.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
<a name="csharp-package-cli-prerequisites"></a>

**.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
<a name="csharp-package-cli-create"></a>

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
  {
  
      /// <summary>
      /// A simple function that takes a string and does a ToUpper
      /// </summary≫
      /// <param name="input"></param>
      /// <param name="context"></param>
      /// <returns></returns>
      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.

  ```
  <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
      <TargetFramework>net8.0</TargetFramework>
      <ImplicitUsings>enable</ImplicitUsings>
      <Nullable>enable</Nullable>
      <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
      <AWSProjectType>Lambda</AWSProjectType>
      <!-- This property makes the build directory similar to a publish directory and helps the AWS .NET Lambda Mock Test Tool find project dependencies. -->
      <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
      <!-- Generate ready to run images during publishing to improve cold start time. -->
      <PublishReadyToRun>true</PublishReadyToRun>
    </PropertyGroup>
    <ItemGroup>
      <PackageReference Include="Amazon.Lambda.Core" Version="2.2.0" />
      <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.4.0" />
    </ItemGroup>
  </Project>
  ```
+ **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.

  ```
  <Project Sdk="Microsoft.NET.Sdk">
     ... 
  
      <PackageReference Include="Amazon.Lambda.Core" Version="2.2.0 " />
     ...
  ```
+ **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
<a name="csharp-package-cli-deploy"></a>

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
<a name="csharp-layers"></a>

**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_name> --layer-type runtime-package-store --s3-bucket <s3_bucket_name>
```

Kemudian, ketika Anda menerapkan fungsi Anda menggunakan .NET CLI, tentukan layer ARN konsumsi dalam perintah berikut:

```
dotnet lambda deploy-function <function_name> --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.