# Criar e implantar funções do Lambda em C\$1 com arquivos .zip
Um pacote de implantação do .NET (arquivo .zip) contém o assembly compilado da função junto com todas as suas dependências de assembly. O pacote também contém um arquivo `proj.deps.json`. Isso sinaliza para o runtime do .NET todas as dependências da função e um arquivo `proj.runtimeconfig.json`, que é usado para configurar o runtime.
Para implantar funções do Lambda individuais, você pode usar a CLI do .NET Lambda Global `Amazon.Lambda.Tools`. O uso do comando `dotnet lambda deploy-function` cria automaticamente um pacote de implantação .zip e o implanta no Lambda. Porém, recomendamos que você use estruturas como o AWS Serverless Application Model (AWS SAM) ou o AWS Cloud Development Kit (AWS CDK) para implantar as aplicações do .NET na AWS.
As aplicações com tecnologia sem servidor geralmente incluem uma combinação de funções do Lambda e outros Serviços da AWS gerenciados trabalhando juntos para realizar uma tarefa de negócios específica. O AWS SAM e o AWS CDK simplificam a criação e implantação de funções do Lambda com outros Serviços da AWS em escala. A [especificação do modelo do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) fornece uma sintaxe simples e clara para descrever as funções, APIs, permissões, configurações e outros recursos do da AWS que compõem sua aplicação com tecnologia sem servidor. Com o [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html), você define a infraestrutura de nuvem como código para ajudar a criar aplicações confiáveis, escaláveis e econômicas na nuvem, usando linguagens e estruturas de programação modernas, como o .NET. Tanto o AWS CDK quanto o AWS SAM usam a CLI do .NET Lambda Global para empacotar as funções.
Embora seja possível usar as [Camadas do Lambda](chapter-layers.md) com funções em C\$1 [usando a CLI do .NET Core](csharp-package-cli.md#csharp-layers), não recomendamos. Funções em C\$1 que usam camadas carregam manualmente os conjuntos compartilhados na memória durante o [Fase de inicialização](lambda-runtime-environment.md#runtimes-lifecycle-ib), 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 evitar o impacto no desempenho do carregamento de assemblies em runtime.
Você pode encontrar instruções para criar e implantar as funções do Lambda do .NET usando o AWS SAM o AWS CDK e a CLI do .NET Lambda Global nas seções a seguir.
**Topics**
+ [
# Usando a CLI do .NET Lambda Global
](csharp-package-cli.md)
+ [
# Implantar funções do Lambda em C\$1 usando o AWS SAM
](csharp-package-sam.md)
+ [
# Implantar funções do Lambda em C\$1 usando o AWS CDK
](csharp-package-cdk.md)
+ [
# Implementar aplicações ASP.NET
](csharp-package-asp.md)
# Usando a CLI do .NET Lambda Global
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
**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
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
{
///
/// A simple function that takes a string and does a ToUpper
///
///
///
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.
```
net8.0
enable
enable
true
Lambda
true
true
```
+ **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.
```
...
...
```
+ **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
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
**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-type runtime-package-store --s3-bucket
```
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-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).
# Implantar funções do Lambda em C\$1 usando o AWS SAM
O AWS Serverless Application Model (AWS SAM) é um kit de ferramentas que ajuda a simplificar o processo de criação e execução de aplicações com tecnologia sem servidor na AWS. Você define os recursos para a aplicação em um modelo YAML ou JSON e usa a interface da linha de comando do AWS SAM (CLI do AWS SAM) para criar, empacotar e implantar aplicações. Quando você cria uma função do Lambda com base em um modelo do AWS SAM, o AWS SAM cria automaticamente um pacote de implantação .zip ou uma imagem de contêiner com o código da função e todas as dependências que você especificar. O AWS SAM então implanta a função usando uma [pilha do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html) Para saber mais sobre como usar o AWS SAM para criar e implantar funções do Lambda, consulte [Conceitos básicos do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) no *Guia do desenvolvedor do AWS Serverless Application Model*.
As etapas a seguir mostram como baixar, criar e implantar um exemplo de aplicação Hello World do .NET usando o AWS SAM. Essa aplicação de exemplo usa uma função do Lambda e um endpoint do Amazon API Gateway para implementar um back-end básico de API. Quando você envia uma solicitação HTTP GET ao endpoint do API Gateway, o API Gateway invoca a sua função do Lambda. A função retorna uma mensagem "Hello world, juntamente com o endereço IP da instância da função do Lambda que processa a solicitação.
Quando você criar e implanta a aplicação usando o AWS SAM, nos bastidores, a CLI do AWS SAM usa o comando `dotnet lambda package` para empacotar os pacotes individuais de códigos de função do Lambda.
## Pré-requisitos
**SDK do .NET 8**
Instale o SDK e o runtime do [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).
**CLI do AWS SAM versão 1.39 ou posterior**
Para saber como instalar a versão mais recente da CLI do AWS SAM, consulte [Instalar a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html).
## Implantar uma aplicação de exemplo do AWS SAM
1. Inicialize a aplicação usando o modelo de Hello world do .NET com o comando a seguir.
```
sam init --app-template hello-world --name sam-app \
--package-type Zip --runtime dotnet8
```
Esse comando cria os seguintes arquivos e diretórios no diretório do seu projeto.
```
└── 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. Navegue até o diretório que contém o `template.yaml file`. Esse arquivo é um modelo que define os recursos da AWS da sua aplicação, incluindo a função do Lambda e uma API do API Gateway.
```
cd sam-app
```
1. Para criar o código-fonte da aplicação, execute o comando a seguir.
```
sam build
```
1. Para implantar a aplicação no AWS, execute o comando a seguir.
```
sam deploy --guided
```
Esse comando empacota e implanta a aplicação com a série de prompts a seguir. Para aceitar as opções padrão, pressione Enter.
**nota**
Para **HelloWorldFunction pode não ter autorização definida, tudo bem?**, certifique-se de inserir `y`.
+ **Nome da pilha**: o nome da pilha a implantar para CloudFormation. Esse nome deve ser exclusivo para a sua Conta da AWS e a Região da AWS.
+ **Região da AWS**: a Região da AWS em que você deseja implantar a aplicação.
+ **Confirmar as alterações antes da implantação**: selecione Sim para revisar manualmente qualquer conjunto de alterações antes do AWS SAM implantar as alterações da aplicação. Se você selecionar Não, a CLI do AWS SAM implantará automaticamente as alterações da aplicação.
+ **Permitir a criação de perfil do IAM do SAM CLI**: muitos modelos do AWS SAM, incluindo o Hello world neste exemplo, criam perfis do AWS Identity and Access Management (IAM) para dar permissão às suas funções do Lambda para acessar outras Serviços da AWS. Selecione Sim para fornecer permissão para implantar uma pilha CloudFormation que cria ou modifica os perfis do IAM.
+ **Desativar a reversão**: por padrão, se o AWS SAM encontrar um erro durante a criação ou implantação da pilha, ela reverte a pilha para a versão anterior. Selecione Não para aceitar esse padrão.
+ **HelloWorldFunction pode não ter autorização definida, tudo bem?**: insira `y`.
+ **Salvar argumentos em samconfig.toml**: selecione Sim para salvar suas opções de configuração. No futuro, você poderá executar o `sam deploy` novamente sem parâmetros para implantar alterações na aplicação.
1. Quando a implantação da aplicação estiver concluída, a CLI retornará o nome do recurso da Amazon (ARN) da função do Lambda Hello World e o perfil do IAM criado para ela. Ela também exibe o endpoint da API do API Gateway. Para testar a aplicação, abra o endpoint em um navegador. Você verá uma resposta semelhante a que se segue.
```
{"message":"hello world","location":"34.244.135.203"}
```
1. Para excluir os seus recursos, execute o comando a seguir. Observe que o endpoint da API que você criou é um endpoint público acessível pela Internet. Recomendamos excluir este endpoint após o teste.
```
sam delete
```
## Próximas etapas
Para saber mais sobre o uso do AWS SAM para criar e implantar funções do Lambda usando o .NET, consulte os seguintes recursos:
+ O [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)
+ [Criar aplicações do .NET com tecnologia sem servidor com o AWS Lambda e com a CLI do SAM](https://aws.amazon.com/blogs/dotnet/building-serverless-net-applications-with-aws-lambda-and-the-sam-cli/)
# Implantar funções do Lambda em C\$1 usando o AWS CDK
O AWS Cloud Development Kit (AWS CDK) é uma estrutura de desenvolvimento de software de código aberto para definição da infraestrutura em nuvem como código com linguagens de programação e estruturas modernas, como o .NET. Os projetos do AWS CDK são executados para gerar modelos do CloudFormation que são usados para implantar o código.
Para criar e implantar um exemplo de aplicação Hello world do .NET usando o AWS CDK, siga as instruções nas seções a seguir. A aplicação de amostra implementa um back-end de API básica que consiste em um endpoint do API Gateway e uma função do Lambda. O API Gateway invoca a função do Lambda quando você envia uma solicitação HTTP GET ao endpoint. A função retorna uma mensagem Hello world, juntamente com o endereço IP da instância do Lambda que processa a sua solicitação.
## Pré-requisitos
**SDK do .NET 8**
Instale o SDK e o runtime do [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).
**AWS CDK versão 2**
Para saber como instalar a versão mais recente do AWS CDK, consulte [Conceitos básicos do AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) no *Guia do desenvolvedor do AWS Cloud Development Kit (AWS CDK) v2*.
## Implantar uma aplicação de exemplo do AWS CDK
1. Crie um diretório de projeto para a aplicação de amostra e navegue até ele.
```
mkdir hello-world
cd hello-world
```
1. Inicialize uma nova aplicação do AWS CDK executando o comando a seguir.
```
cdk init app --language csharp
```
O comando cria os seguintes arquivos e diretórios no diretório do projeto.
```
├── README.md
├── cdk.json
└── src
├── HelloWorld
│ ├── GlobalSuppressions.cs
│ ├── HelloWorld.csproj
│ ├── HelloWorldStack.cs
│ └── Program.cs
└── HelloWorld.sln
```
1. Abra o diretório `src` e crie uma nova função do Lambda usando a CLI do .NET. Essa é a função que você implantará usando o AWS CDK. Neste exemplo, você cria uma função Hello world denominada `HelloWorldLambda` usando o modelo `lambda.EmptyFunction`.
```
cd src
dotnet new lambda.EmptyFunction -n HelloWorldLambda
```
Após esta etapa, a estrutura de diretórios dentro do projeto deve ser semelhante à apresentada a seguir.
```
├── 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. Abra o arquivo `HelloWorldStack.cs` do diretório `src/HelloWorld`. Substitua o conteúdo do arquivo pelo código a seguir.
```
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
}),
});
}
}
}
```
Esse é o código para compilar e empacotar o código da aplicação, bem como a definição da própria função do Lambda. O objeto `BundlingOptions` permite que um arquivo zip seja criado, juntamente com um conjunto de comandos usados para gerar o conteúdo do arquivo zip. Nessa instância, o comando `dotnet lambda package` é usado para compilar e gerar o arquivo zip.
1. Para implantar a aplicação, execute o comando a seguir.
```
cdk deploy
```
1. Invoque sua função do Lambda implantada usando a CLI do .NET Lambda.
```
dotnet lambda invoke-function HelloWorldFunction -p "hello world"
```
1. Depois de finalizados os testes, você poderá excluir os recursos criados, a menos que deseje mantê-los. Execute o comando a seguir para excluir os seus recursos.
```
cdk destroy
```
## Próximas etapas
Para saber mais sobre o uso do AWS CDK para criar e implantar funções do Lambda usando o .NET, consulte os seguintes recursos:
+ [Trabalhar com o AWS CDK em C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Criar, empacotar e publicar funções do Lambda no .NET C\$1 com o CDK do AWS](https://aws.amazon.com/blogs/modernizing-with-aws/build-package-publish-dotnet-csharp-lambda-functions-aws-cdk/)
# Implementar aplicações ASP.NET
Além de hospedar funções orientadas por eventos, você também pode usar o .NET com o Lambda para hospedar aplicações leves do ASP.NET. Você pode criar e implantar aplicações ASP.NET usando o pacote NuGet `Amazon.Lambda.AspNetCoreServer`. Nesta seção, você aprenderá a implantar uma API da Web do ASP.NET no Lambda usando as ferramentas CLI do .NET Lambda.
**Topics**
+ [
## Pré-requisitos
](#csharp-package-asp-prerequisites)
+ [
## Implantando uma API Web do ASP.NET no Lambda
](#csharp-package-asp-deploy-api)
+ [
## Implantar APIs mínimas do ASP.NET no Lambda
](#csharp-package-asp-deploy-minimal)
## Pré-requisitos
**SDK do .NET 8**
Instale o SDK do [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) e o Runtime do ASP.NET Core.
**Amazon.Lambda.Tools**
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.
**Amazon.Lambda.Templates**
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
```
## Implantando uma API Web do ASP.NET no Lambda
Para implantar uma API da Web usando o ASP.NET, você pode usar os modelos do .NET Lambda para criar um novo projeto de API da Web. Use o comando a seguir para inicializar um novo projeto de API da Web do ASP.NET. No comando de exemplo, denominamos o projeto `AspNetOnLambda`.
```
dotnet new serverless.AspNetCoreWebAPI -n AspNetOnLambda
```
Esse comando cria os seguintes arquivos e diretórios no diretório do seu projeto.
```
.
└── 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
```
Quando o Lambda invoca sua função, o ponto de entrada usado é o arquivo `LambdaEntryPoint.cs`. O arquivo criado pelo modelo do .NET Lambda contém o seguinte código de função.
```
namespace AspNetOnLambda;
public class LambdaEntryPoint : Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction
{
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup≪Startup≫();
}
protected override void Init(IHostBuilder builder)
{
}
}
```
O ponto de entrada usado pelo Lambda deve herdar de uma das três classes básicas do pacote `Amazon.Lambda.AspNetCoreServer`. Essas três classes básicas são:
+ `APIGatewayProxyFunction`
+ `APIGatewayHttpApiV2ProxyFunction`
+ `ApplicationLoadBalancerFunction`
A classe padrão usada quando você cria o arquivo `LambdaEntryPoint.cs` usando o modelo do .NET Lambda fornecido é `APIGatewayProxyFunction`. A classe básica que você usa na função depende de qual camada de API está na frente da função do Lambda.
Cada uma das três classes básicas contém um método público denominado `FunctionHandlerAsync`. O nome desse método fará parte da [string do manipulador](csharp-handler.md#csharp-class-library-handlers) que o Lambda usa para invocar a função. O método `FunctionHandlerAsync` transforma a carga útil do evento de entrada no formato ASP.NET correto e a resposta do ASP.NET em uma carga útil de resposta do Lambda. Para o projeto de exemplo `AspNetOnLambda` mostrado, a string do manipulador seria como a que se segue.
```
AspNetOnLambda::AspNetOnLambda.LambdaEntryPoint::FunctionHandlerAsync
```
Para implantar a API no Lambda, execute os comandos a seguir para navegar até o diretório que contém o arquivo de código-fonte e implantar a função usando o CloudFormation.
```
cd AspNetOnLambda/src/AspNetOnLambda
dotnet lambda deploy-serverless
```
**dica**
Quando você implanta uma API usando o comando `dotnet lambda deploy-serverless`, o CloudFormation atribui um nome à função do Lambda com base no nome da pilha que você especificou durante a implantação. Para dar um nome personalizado à função do Lambda, edite o arquivo `serverless.template` para adicionar uma propriedade `FunctionName` ao recurso `AWS::Serverless::Function`. Para saber mais, consulte [Tipo de nome](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) no *Guia do usuário do CloudFormation*.
## Implantar APIs mínimas do ASP.NET no Lambda
Para implantar uma API mínima do ASP.NET no Lambda, você pode usar os modelos do .NET Lambda para criar um novo projeto de API mínimo. Use o comando a seguir para inicializar um novo projeto de API mínima. Neste exemplo, denominamos o projeto `MinimalApiOnLambda`.
```
dotnet new serverless.AspNetCoreMinimalAPI -n MinimalApiOnLambda
```
O comando cria os arquivos e diretórios a seguir no diretório do seu projeto.
```
└── MinimalApiOnLambda
└── src
└── MinimalApiOnLambda
├── Controllers
│ └── CalculatorController.cs
├── MinimalApiOnLambda.csproj
├── Program.cs
├── Readme.md
├── appsettings.Development.json
├── appsettings.json
├── aws-lambda-tools-defaults.json
└── serverless.template
```
O arquivo `Program.cs` contém o código a seguir.
```
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();
```
Para configurar a API mínima para ser executada no Lambda, pode ser necessário editar esse código para que as solicitações e respostas entre o Lambda e o ASP.NET Core sejam traduzidas adequadamente. Por padrão, a função é configurada para uma fonte de eventos API REST. Para uma API HTTP ou um Application Load Balancer, substitua `(LambdaEventSource.RestApi)` por uma das seguintes opções:
+ `(LambdaEventSource.HttpAPi)`
+ `(LambdaEventSource.ApplicationLoadBalancer)`
Para implantar a API mínima no Lambda, execute os comandos a seguir para navegar até o diretório que contém o arquivo de código-fonte e implantar a função usando o CloudFormation.
```
cd MinimalApiOnLambda/src/MinimalApiOnLambda
dotnet lambda deploy-serverless
```