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

A CLI do .NET e a extensão .NET Lambda Global Tools (`Amazon.Lambda.Tools`) oferecem uma maneira multiplataforma de criar aplicações do Lambda baseadas no .NET, empacotá-las e implantá-las no Lambda. Nesta seção, você aprenderá a criar novos projetos do Lambda do .NET usando a CLI do .NET e os modelos do Amazon Lambda e a empacotá-los e implantá-los usando o `Amazon.Lambda.Tools`

**Topics**
+ [Pré-requisitos](#csharp-package-cli-prerequisites)
+ [Criar projetos do .NET usando a CLI do .NET](#csharp-package-cli-create)
+ [Implantar projetos do .NET usando a CLI do .NET](#csharp-package-cli-deploy)
+ [Usar camadas Lambda com a CLI do .NET](#csharp-layers)

## Pré-requisitos
<a name="csharp-package-cli-prerequisites"></a>

**SDK do .NET 8**  
Se você ainda não o fez, instale o SDK e o runtime do [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).

**Modelos de projetos do AWS Amazon.Lambda.Templates do .NET**  
Para gerar o código da função do Lambda, use o Pacote do NuGet [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates). Para instalar esse pacote de modelo, execute o comando a seguir:  

```
dotnet new install Amazon.Lambda.Templates
```

**Ferramentas AWS Amazon.Lambda.Tools da CLI Global do .NET**  
Para criar as funções do Lambda, você usa a [extensão .NET Global Tools](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) do [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools). Para instalar Amazon.Lambda.Tools, execute o comando a seguir:  

```
dotnet tool install -g Amazon.Lambda.Tools
```
Para obter mais informações sobre a extensão Amazon.Lambda.Tools da CLI do .NET, consulte o repositório [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) no GitHub.

## Criar projetos do .NET usando a CLI do .NET
<a name="csharp-package-cli-create"></a>

Na CLI do .NET, você usa o comando `dotnet new` para criar projetos do .NET em uma linha de comando. O Lambda oferece modelos adicionais usando o pacote NuGet [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates).

Depois de instalar o pacote, execute o comando a seguir para ver uma lista dos modelos disponíveis.

```
dotnet new list
```

Para examinar detalhes sobre um modelo, use a opção `help`. Por exemplo, para ver detalhes sobre o modelo de `lambda.EmptyFunction`, execute o comando a seguir.

```
dotnet new lambda.EmptyFunction --help
```

Para criar um modelo básico para uma função do .NET Lambda, use o modelo `lambda.EmptyFunction`. Isso cria uma função simples que pega uma string como entrada e a converte em maiúsculas usando o método `ToUpper`. O modelo é compatível com as opções a seguir: 
+ `--name`: o nome da função.
+ `--region`: a região da AWS na qual criar a função.
+ `--profile`: o nome de um perfil no arquivo de credenciais do AWS SDK para .NET. Para saber mais sobre perfis de credenciais no .NET, consulte [Configure AWS credentials](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) no *AWS SDK for .NET Developer Guide*.

Neste exemplo, criamos uma nova função vazia denominada `myDotnetFunction` usando o perfil e as configurações do Região da AWS padrão:

```
dotnet new lambda.EmptyFunction --name myDotnetFunction
```

Esse comando cria os seguintes arquivos e diretórios no diretório do seu projeto.

```
└── myDotnetFunction
    ├── src
    │   └── myDotnetFunction
    │       ├── Function.cs
    │       ├── Readme.md
    │       ├── aws-lambda-tools-defaults.json
    │       └── myDotnetFunction.csproj
    └── test
        └── myDotnetFunction.Tests
            ├── FunctionTest.cs
            └── myDotnetFunction.Tests.csproj
```

No diretório `src/myDotnetFunction`, examine os seguintes arquivos:
+ **aws-lambda-tools-defaults.json**: este é o local em que você especifica as opções de linha de comando ao implantar sua função do Lambda. Por exemplo:

  ```
    "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**: o código da função do manipulador do Lambda. É um modelo C \$1 que inclui a biblioteca `Amazon.Lambda.Core` padrão e um atributo `LambdaSerializer` padrão. Para obter mais informações sobre os requisitos e as opções de serialização, consulte [Serialização em funções do Lambda em C\$1](csharp-handler.md#csharp-handler-serializer). Isso também inclui uma função de exemplo que você pode editar para aplicar o código de sua função do Lambda.

  ```
  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**: um arquivo [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx) que lista os arquivos e assemblies que compõem a aplicação.

  ```
  <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**: use este arquivo para documentar sua função do Lambda.

No diretório `myfunction/test`, examine os seguintes arquivos:
+ **myDotnetFunction.Tests.csproj**: conforme observado anteriormente, este é um arquivo [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx) que lista os arquivos e assemblies que compõem seu projeto de teste. Observe também que ele inclui a biblioteca `Amazon.Lambda.Core`, portanto, é possível integrar perfeitamente qualquer modelo do Lambda necessário para testar sua função.

  ```
  <Project Sdk="Microsoft.NET.Sdk">
     ... 
  
      <PackageReference Include="Amazon.Lambda.Core" Version="2.2.0 " />
     ...
  ```
+ **FunctionTest.cs**: o mesmo arquivo de modelo de código C \$1 que é incluído no diretório `src`. Edite esse arquivo para espelhar o código de produção de sua função e testá-lo antes de carregar sua função do Lambda em um ambiente de produção.

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

## Implantar projetos do .NET usando a CLI do .NET
<a name="csharp-package-cli-deploy"></a>

Para criar o pacote de implantação e implantá-lo no Lambda, você usa as ferramentas da CLI de `Amazon.Lambda.Tools`. Para implantar a função usando os arquivos que você criou nas etapas anteriores, primeiro navegue até a pasta que contém o arquivo `.csproj` da função.

```
cd myDotnetFunction/src/myDotnetFunction
```

Para implantar o código no Lambda como um pacote de implantação .zip, execute o comando a seguir. Escolha o nome da sua função.

```
dotnet lambda deploy-function myDotnetFunction
```

Durante a implantação, o assistente solicita que você selecione um [Definir permissões de uma função do Lambda com um perfil de execução](lambda-intro-execution-role.md). Para esse exemplo, selecione `lambda_basic_role`.

Depois de implantar a função, você poderá testá-la na nuvem usando o comando `dotnet lambda invoke-function`. Para o código de exemplo no modelo da `lambda.EmptyFunction`, você pode testar a função passando uma string usando a opção `--payload`.

```
dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
```

Se a função foi implantada com sucesso, você deverá ver um resultado semelhante ao apresentado a seguir.

```
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
```

## Usar camadas Lambda com a CLI do .NET
<a name="csharp-layers"></a>

**nota**  
Embora seja possível usar as [camadas](chapter-layers.md) com funções em .NET, não recomendamos essa prática. Funções em .NET que usam camadas carregam manualmente os assemblies compartilhados na memória durante a fase de `Init`, o que pode aumentar o tempo de início a frio. Em vez disso, inclua todo o código compartilhado no momento da compilação para aproveitar as otimizações integradas do compilador .NET.

A CLI do .NET é compatível com comandos que ajudam a publicar camadas e implantar funções C\$1 que consomem camadas. Para publicar uma camada em um bucket específico do Amazon S3, execute o seguinte comando no mesmo diretório do seu arquivo `.csproj`:

```
dotnet lambda publish-layer <layer_name> --layer-type runtime-package-store --s3-bucket <s3_bucket_name>
```

Em seguida, ao implantar sua função usando a CLI do .NET, especifique o ARN da camada a ser consumida no comando a seguir:

```
dotnet lambda deploy-function <function_name> --function-layers arn:aws:lambda:us-east-1:123456789012:layer:layer-name:1
```

Para obter um exemplo completo de uma função Hello World, consulte a amostra [blank-csharp-com-layer](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-csharp-with-layer).