# Implantar funções do Lambda em .NET com imagens de contêiner
Existem três maneiras de criar uma imagem de contêiner para uma função do Lambda em .NET:
+ [Usar uma imagem base da AWS para .NET](#csharp-image-instructions)
As [imagens base da AWS](images-create.md#runtimes-images-lp) são pré-carregadas com um runtime de linguagem, um cliente de interface de runtime para gerenciar a interação entre o Lambda e o código da sua função e um emulador de interface de runtime para testes locais.
+ [Usar uma imagem base somente para sistema operacional da AWS](images-create.md#runtimes-images-provided)
[As imagens base somente para sistema operacional da AWS](https://gallery.ecr.aws/lambda/provided) contêm uma distribuição do Amazon Linux e o [emulador de interface de runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Essas imagens são comumente usadas para criar imagens de contêiner para linguagens compiladas, como [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md) e para uma linguagem ou versão de linguagem para a qual o Lambda não fornece uma imagem base, como Node.js 19. Você também pode usar imagens base somente para sistema operacional para implementar um [runtime personalizado](runtimes-custom.md). Para tornar a imagem compatível com o Lambda, você deve incluir [o cliente de interface de runtime do .NET](#csharp-image-clients) na imagem.
+ [Usar uma imagem base que não é da AWS](#csharp-image-clients)
Você também pode usar uma imagem base alternativa de outro registro de contêiner, como Alpine Linux ou Debian. Você também pode usar uma imagem personalizada criada por sua organização. Para tornar a imagem compatível com o Lambda, você deve incluir [o cliente de interface de runtime do .NET](#csharp-image-clients) na imagem.
**dica**
Para reduzir o tempo necessário para que as funções do contêiner do Lambda se tornem ativas, consulte [Use multi-stage builds](https://docs.docker.com/build/building/multi-stage/) na documentação do Docker. Para criar imagens de contêiner eficientes, siga as [Melhores práticas para gravar Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Esta página explica como criar, testar e implantar imagens de contêiner para o Lambda.
**Topics**
+ [
## Imagens base da AWS para .NET
](#csharp-image-base)
+ [
## Usar uma imagem base da AWS para .NET
](#csharp-image-instructions)
+ [
## Usar uma imagem base alternativa com o cliente da interface de runtime
](#csharp-image-clients)
## Imagens base da AWS para .NET
A AWS oferece as seguintes imagens base para .NET:
| Tags | Runtime | Sistema operacional | Dockerfile | Desaprovação |
| --- | --- | --- | --- | --- |
| 10 | .NET 10 | Amazon Linux 2023 | [Dockerfile para .NET 10 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet10/Dockerfile.dotnet10) | 14 de novembro de 2028 |
| 9 | .NET 9 | Amazon Linux 2023 | [Dockerfile para .NET 9 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet9/Dockerfile.dotnet9) | 10 de novembro de 2026 |
| 8 | .NET 8 | Amazon Linux 2023 | [Dockerfile para .NET 8 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet8/Dockerfile.dotnet8) | 10 de novembro de 2026 |
Repositório do Amazon ECR: [gallery.ecr.aws/lambda/dotnet](https://gallery.ecr.aws/lambda/dotnet)
## Usar uma imagem base da AWS para .NET
### Pré-requisitos
Para executar as etapas desta seção, você deve ter o seguinte:
+ [.NET SDK](https://dotnet.microsoft.com/download): as etapas a seguir usam a imagem base do .NET 8. Certifique-se de que sua versão do .NET corresponda à versão da [imagem base](https://gallery.ecr.aws/lambda/dotnet) que você especifica em seu Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (versão mínima 25.0.0)
+ O plug-in [buildx](https://github.com/docker/buildx/blob/master/README.md) do Docker.
### Criação e implantação de uma imagem usando uma imagem base
Nas etapas a seguir, você usará [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) e [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) para criar um projeto.NET. Em seguida, você construirá uma imagem do Docker, fará upload da imagem no Amazon ECR e a implantará em uma função do Lambda.
1. Instale o pacote [NuGet Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates).
```
dotnet new install Amazon.Lambda.Templates
```
1. Crie um projeto .NET usando o modelo `lambda.image.EmptyFunction`.
```
dotnet new lambda.image.EmptyFunction --name MyFunction --region us-east-1
```
Os arquivos do projeto são armazenados no diretório `MyFunction/src/MyFunction`:
+ **aws-lambda-tools-defaults.json**: especifica as opções de linha de comando para implantar a função do Lambda.
+ **Function.cs**: o código da função do manipulador do Lambda. Ele é um modelo em 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). É possível usar o código fornecido para testes ou substituí-lo pelo seu.
+ **MyFunction.csproj**: um [arquivo de projeto](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) .NET que lista os arquivos e conjuntos que compõem a aplicação.
+ **Dockerfile**: é possível usar o Dockerfile fornecido para testes ou substituí-lo pelo seu próprio. Se você usar o seu próprio, certifique-se de:
+ Definir a propriedade `FROM` como o [URI da imagem base](https://gallery.ecr.aws/lambda/dotnet). A imagem de base e a `TargetFramework` no arquivo `MyFunction.csproj` devem usar a mesma versão do .NET. Por exemplo, para usar o .NET 9:
+ Dockerfile: `FROM public.ecr.aws/lambda/dotnet:9`
+ MyFunction.csproj: `net9.0`
+ Definir o argumento `CMD` para o manipulador de funções do Lambda. Isso deve corresponder ao `image-command` em `aws-lambda-tools-defaults.json`.
1. Instale a [.NET Global Tool](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) do Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Se o Amazon.Lambda.Tools já estiver instalado, certifique-se de ter a versão mais recente.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Altere o diretório para `MyFunction/src/MyFunction`, caso você ainda não esteja lá.
```
cd src/MyFunction
```
1. Use o Amazon.Lambda.Tools para construir a imagem do Docker, enviá-la para um novo repositório do Amazon ECR e implantar a função do Lambda.
Em `--function-role`, especifique o nome do perfil, não o nome do recurso da Amazon (ARN), do [perfil de execução](lambda-intro-execution-role.md) da função. Por exemplo, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Para obter mais informações sobre a ferramenta do Amazon.Lambda.Tools do .NET Global, consulte o repositório [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) no GitHub.
1. Invoque a função.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Se tudo estiver certo, você verá uma resposta como a seguinte:
```
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. Exclua a função do Lambda.
```
dotnet lambda delete-function MyFunction
```
## Usar uma imagem base alternativa com o cliente da interface de runtime
Se você usar uma [imagem base somente para sistema operacional](images-create.md#runtimes-images-provided) ou uma imagem base alternativa, deverá incluir o cliente de interface de runtime na imagem. O cliente de interface de runtime estende [API de runtime](runtimes-api.md), que gerencia a interação entre o Lambda e o código da sua função.
O exemplo a seguir demonstra como criar uma imagem de contêiner para .NET usando uma imagem base que não é da AWS e como adicionar o [pacote 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), que é o cliente da interface de runtime do Lambda para .NET. O Dockerfile do exemplo usa a imagem base do Microsoft .NET 8.
### Pré-requisitos
Para executar as etapas desta seção, você deve ter o seguinte:
+ [.NET SDK](https://dotnet.microsoft.com/download): as etapas a seguir usam uma imagem de base do .NET 9. Certifique-se de que sua versão do .NET corresponda à versão da imagem base que você especifica em seu Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (versão mínima 25.0.0)
+ O plug-in [buildx](https://github.com/docker/buildx/blob/master/README.md) do Docker.
### Criar e implantar uma imagem usando uma imagem base alternativa
1. Instale o pacote [NuGet Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates).
```
dotnet new install Amazon.Lambda.Templates
```
1. Crie um projeto .NET usando o modelo `lambda.CustomRuntimeFunction`. Esse modelo inclui o pacote [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).
```
dotnet new lambda.CustomRuntimeFunction --name MyFunction --region us-east-1
```
1. Navegue até o diretório `MyFunction/src/MyFunction`. É aqui o local em que os arquivos do projeto são armazenados. Examine os seguintes arquivos:
+ **aws-lambda-tools-defaults.json**: este arquivo é onde você especifica as opções de linha de comando ao implantar sua função do Lambda.
+ **Function.cs**: o código contém uma classe com um método `Main` que inicializa a biblioteca `Amazon.Lambda.RuntimeSupport` como bootstrap. O método `Main` é o ponto de entrada para o processo da função. O método `Main` ajusta o manipulador da função em um wrappper com o qual o bootstrap pode trabalhar. Para obter mais informações, consulte [Usar Amazon.Lambda.RuntimeSupport como uma biblioteca de classes](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library) no repositório do GitHub.
+ **MyFunction.csproj**: um [arquivo de projeto](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) .NET que lista os arquivos e conjuntos que compõem sua aplicação.
+ **Readme.md**: este arquivo contém mais informações sobre a função do Lambda de exemplo.
1. Abra o arquivo `aws-lambda-tools-defaults.json` e adicione as seguintes linhas:
```
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
```
+ **package-type**: define o pacote de implantação como uma imagem de contêiner.
+ **docker-host-build-output-dir**: define o diretório de saída para o processo de compilação.
**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. Crie um Dockerfile no diretório `MyFunction/src/MyFunction`. O Dockerfile de exemplo a seguir usa uma imagem base do Microsoft.NET em vez de uma [imagem base da AWS](#csharp-image-base).
+ Defina a propriedade `FROM` como o identificador da imagem base. A imagem de base e a `TargetFramework` no arquivo `MyFunction.csproj` devem usar a mesma versão do .NET.
+ Use o comando `COPY` para copiar a função para o diretório `/var/task`.
+ Defina o `ENTRYPOINT` como o módulo em que você deseja que o contêiner do Docker seja executado quando for iniciado. Nesse caso, o módulo é o bootstrap, que inicializa a biblioteca `Amazon.Lambda.RuntimeSupport`.
Observe que o Dockerfile de exemplo não inclui uma [instrução USER](https://docs.docker.com/reference/dockerfile/#user). Quando você implanta uma imagem de contêiner no Lambda, o Lambda define automaticamente um usuário padrão do Linux com permissões de privilégio mínimo. Isso é diferente do comportamento padrão do Docker, que adota o usuário `root` como padrão quando nenhuma instrução `USER` é fornecida.
**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. Instale a [extensão .NET Global Tools](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Se o Amazon.Lambda.Tools já estiver instalado, certifique-se de ter a versão mais recente.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Use o Amazon.Lambda.Tools para criar a imagem do Docker, enviá-la para um novo repositório do Amazon ECR e implantar a função do Lambda.
Em `--function-role`, especifique o nome do perfil, não o nome do recurso da Amazon (ARN), do [perfil de execução](lambda-intro-execution-role.md) da função. Por exemplo, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Para obter mais informações sobre a extensão da CLi Amazon.Lambda.Tools .NET, consulte o repositório [AWS Extensions for .NET CLI](https://github.com/aws/aws-extensions-for-dotnet-cli) no GitHub.
1. Invoque a função.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Se tudo for bem-sucedido, você verá o seguinte:
```
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. Exclua a função do Lambda.
```
dotnet lambda delete-function MyFunction
```