# Implementar funciones de Lambda .NET con imágenes de contenedor
Hay tres formas de crear una imagen de contenedor para una función de Lambda en .NET:
+ [Uso de una imagen base de AWS para .NET](#csharp-image-instructions)
Las [imágenes base de AWS](images-create.md#runtimes-images-lp) vienen precargadas con un tiempo de ejecución de lenguaje, un cliente de interfaz de tiempo de ejecución para administrar la interacción entre Lambda y el código de la función y un emulador de interfaz de tiempo de ejecución para realizar pruebas a nivel local.
+ [Uso de una imagen base exclusiva del sistema operativo de AWS](images-create.md#runtimes-images-provided)
[Las imágenes base exclusivas del sistema operativo de AWS](https://gallery.ecr.aws/lambda/provided)contienen una distribución de Amazon Linux y el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Por lo general, estas imágenes se utilizan para crear imágenes contenedoras para lenguajes compilados, como [Go](go-image.md#go-image-provided) y [Rust](lambda-rust.md), y para un lenguaje o versión de un lenguaje para los que Lambda no proporciona una imagen base, como Node.js 19. También puede usar imágenes base exclusivas del sistema operativo para implementar un [tiempo de ejecución personalizado](runtimes-custom.md). Para que la imagen sea compatible con Lambda, debe incluir el [cliente de interfaz de tiempo de ejecución para .NET](#csharp-image-clients) en la imagen.
+ [Uso de una imagen base que no sea de AWS](#csharp-image-clients)
Puede utilizar una imagen base alternativa de otro registro de contenedores, como Alpine Linux o Debian. También puede utilizar una imagen personalizada creada por su organización. Para que la imagen sea compatible con Lambda, debe incluir el [cliente de interfaz de tiempo de ejecución para .NET](#csharp-image-clients) en la imagen.
**sugerencia**
Para reducir el tiempo que tardan las funciones de contenedor de Lambda en activarse, consulte [Uso de compilaciones de varias fases](https://docs.docker.com/build/building/multi-stage/) en la documentación de Docker. Para compilar imágenes de contenedores eficientes, siga [Prácticas recomendadas para escribir Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
En esta página, se explica cómo compilar, probar e implementar imágenes de contenedor para Lambda.
**Topics**
+ [
## AWS imágenes base para .NET
](#csharp-image-base)
+ [
## Uso de una imagen base de AWS para .NET
](#csharp-image-instructions)
+ [
## Uso de una imagen base alternativa con el cliente de interfaz de tiempo de ejecución
](#csharp-image-clients)
## AWS imágenes base para .NET
AWS proporciona las siguientes imágenes base para .NET:
| Etiquetas | Tiempo de ejecución | Sistema operativo | Dockerfile | Obsolescencia |
| --- | --- | --- | --- | --- |
| 10 | .NET 10 | Amazon Linux 2023 | [Dockerfile para .NET 10 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet10/Dockerfile.dotnet10) | 14 de noviembre de 2028 |
| 9 | .NET 9 | Amazon Linux 2023 | [Dockerfile para .NET 9 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet9/Dockerfile.dotnet9) | 10 de noviembre de 2026 |
| 8 | .NET 8 | Amazon Linux 2023 | [Dockerfile para .NET 8 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/dotnet8/Dockerfile.dotnet8) | 10 de noviembre de 2026 |
Repositorio de Amazon ECR: [gallery.ecr.aws/lambda/dotnet](https://gallery.ecr.aws/lambda/dotnet)
## Uso de una imagen base de AWS para .NET
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [SDK de .NET](https://dotnet.microsoft.com/download): en los siguientes pasos se utiliza la imagen base de .NET 8. Asegúrese de que su versión de .NET coincida con la versión de la [imagen base](https://gallery.ecr.aws/lambda/dotnet) que especifique en su Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
### Creación e implementación de una imagen con una imagen base
En los siguientes pasos, utilizará [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates) y [Amazon.Lambda.Tools](https://github.com/aws/aws-extensions-for-dotnet-cli#aws-lambda-amazonlambdatools) para crear un proyecto .NET. A continuación, creará una imagen de Docker, cargará la imagen a Amazon ECR y la implementará en una función de Lambda.
1. Instale el paquete NuGet de [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates).
```
dotnet new install Amazon.Lambda.Templates
```
1. Cree un proyecto de .NET con la plantilla `lambda.image.EmptyFunction`.
```
dotnet new lambda.image.EmptyFunction --name MyFunction --region us-east-1
```
Los archivos de proyecto se almacenan en el directorio `MyFunction/src/MyFunction`:
+ **aws-lambda-tools-defaults.json**: especifica las opciones de línea de comando para implementar su función de Lambda.
+ **Function.cs**: el código de la función de controlador de Lambda. Es una plantilla de C\$1 que incluye la biblioteca `Amazon.Lambda.Core` predeterminada y un atributo `LambdaSerializer` predeterminado. Para obtener más información acerca de las opciones y los requisitos de serialización, consulte [Serialización en C\$1 de las funciones de Lambda](csharp-handler.md#csharp-handler-serializer). Puede utilizar el código proporcionado para realizar pruebas o sustituirlo por su propio código.
+ **MyFunction.csproj**: un [archivo de proyecto](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) .NET que enumera los archivos y ensamblados que componen la aplicación.
+ **Dockerfile**: puede usar el Dockerfile proporcionado para realizar pruebas o sustituirlo por el suyo propio. Si usa el suyo propio, asegúrese de que se cumpla lo siguiente:
+ Establezca la propiedad `FROM` en el [URI de la imagen base](https://gallery.ecr.aws/lambda/dotnet). Tanto la imagen base como el `TargetFramework` en el archivo `MyFunction.csproj` deben usar la misma versión .NET. Por ejemplo, para utilizar .NET 9:
+ Dockerfile: `FROM public.ecr.aws/lambda/dotnet:9`
+ MyFunction.csproj: `net9.0`
+ Establezca el argumento `CMD` para el controlador de la función de Lambda. Esto debe coincidir con `image-command` en `aws-lambda-tools-defaults.json`.
1. Instale la [herramienta global .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) de Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Si ya se ha instalado Amazon.Lambda.Tools, asegúrese de que posee la versión más reciente.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Cambie el directorio a `MyFunction/src/MyFunction` si aún no se encuentra allí.
```
cd src/MyFunction
```
1. Utilice Amazon.Lambda.Tools para crear la imagen de Docker, subirla a un nuevo repositorio de Amazon ECR e implementar la función de Lambda.
En `--function-role`, especifique el nombre del rol (no el nombre de recurso de Amazon (ARN)) del [rol de ejecución](lambda-intro-execution-role.md) de la función. Por ejemplo, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Para obtener más información acerca de la herramienta global de .NET de Amazon.Lambda.Tools, consulte el repositorio [Extensiones de AWS para la CLI de .NET](https://github.com/aws/aws-extensions-for-dotnet-cli) en GitHub.
1. Invoque la función.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Si todo es correcto, verá una respuesta similar a la siguiente:
```
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. Elimine la función de Lambda.
```
dotnet lambda delete-function MyFunction
```
## Uso de una imagen base alternativa con el cliente de interfaz de tiempo de ejecución
Si usa una [imagen base exclusiva del sistema operativo](images-create.md#runtimes-images-provided) o una imagen base alternativa, debe incluir el cliente de interfaz de tiempo de ejecución en su imagen. El cliente de interfaz de tiempo de ejecución extiende el [API de tiempo de ejecución](runtimes-api.md), que administra la interacción entre Lambda y el código de la función.
En el siguiente ejemplo, se muestra cómo crear una imagen de contenedor para .NET con una imagen base que no es de AWS y cómo agregar el [paquete 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 es el cliente de interfaz de tiempo de ejecución de Lambda para .NET. El Dockerfile de ejemplo utiliza la imagen base de .NET 8 para Microsoft.
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [SDK de .NET ](https://dotnet.microsoft.com/download): en los siguientes pasos, se utiliza una imagen base de .NET 9. Asegúrese de que su versión de .NET coincida con la versión de la imagen base que especifique en su Dockerfile.
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
### Creación e implementación de una imagen con una imagen base alternativa
1. Instale el paquete NuGet de [Amazon.Lambda.Templates](https://github.com/aws/aws-lambda-dotnet#dotnet-cli-templates).
```
dotnet new install Amazon.Lambda.Templates
```
1. Cree un proyecto de .NET con la plantilla `lambda.CustomRuntimeFunction`. Esta plantilla incluye el paquete [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. Vaya al directorio `MyFunction/src/MyFunction`. Aquí es donde se almacenan los archivos del proyecto. Examine los siguientes archivos:
+ **aws-lambda-tools-defaults.json**: en este archivo se especifican las opciones de la línea de comandos al implementar su función de Lambda.
+ **Function.cs**: el código contiene una clase con un método `Main` que inicializa la biblioteca `Amazon.Lambda.RuntimeSupport` como el arranque. El método `Main` es el punto de entrada para el proceso de la función. El método `Main` empaqueta el controlador de funciones en un contenedor con el que puede funcionar el arranque. Para obtener más información, consulte [Uso de Amazon.Lambda.RuntimeSupport como biblioteca de clases](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.RuntimeSupport/README.md#using-amazonlambdaruntimesupport-as-a-class-library) en el repositorio de GitHub.
+ **MyFunction.csproj**: un [archivo de proyecto](https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview#project-files) de .NET que enumera los archivos y ensamblados que componen la aplicación.
+ **Readme.md**: este archivo contiene más información sobre la función de Lambda de muestra.
1. Abra el archivo `aws-lambda-tools-defaults.json` y agregue las siguientes líneas:
```
"package-type": "image",
"docker-host-build-output-dir": "./bin/Release/lambda-publish"
```
+ **package-type**: define el paquete de despliegue como una imagen de contenedor.
+ **docker-host-build-output-dir**: establece el directorio de salida para el proceso de compilación.
**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. Cree un Dockerfile en el directorio `MyFunction/src/MyFunction`. El siguiente Dockerfile de ejemplo usa una imagen base de .NET para Microsoft en lugar de una [imagen base de AWS](#csharp-image-base).
+ Establezca la propiedad `FROM` como el identificador de la imagen base. Tanto la imagen base como el `TargetFramework` en el archivo `MyFunction.csproj` deben usar la misma versión .NET.
+ Utilice el comando `COPY` para copiar la función en el directorio `/var/task`.
+ Configure `ENTRYPOINT` como el módulo que desea que el contenedor de Docker ejecute cuando se inicie. En este caso, el módulo es el arranque, que inicializa la biblioteca `Amazon.Lambda.RuntimeSupport`.
Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**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 la [extensión de herramientas globales de .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) de Amazon.Lambda.Tools.
```
dotnet tool install -g Amazon.Lambda.Tools
```
Si ya se ha instalado Amazon.Lambda.Tools, asegúrese de que posee la versión más reciente.
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Utilice Amazon.Lambda.Tools para crear la imagen de Docker, subirla a un nuevo repositorio de Amazon ECR e implementar la función de Lambda.
En `--function-role`, especifique el nombre del rol (no el nombre de recurso de Amazon (ARN)) del [rol de ejecución](lambda-intro-execution-role.md) de la función. Por ejemplo, `lambda-role`.
```
dotnet lambda deploy-function MyFunction --function-role lambda-role
```
Para obtener más información acerca de la extensión CLI de la herramienta global de .NET de Amazon Lambda, consulte el repositorio [Extensiones de AWS para la CLI de .NET](https://github.com/aws/aws-extensions-for-dotnet-cli) en GitHub.
1. Invoque la función.
```
dotnet lambda invoke-function MyFunction --payload "Testing the function"
```
Si todo es correcto, verá lo siguiente:
```
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. Elimine la función de Lambda.
```
dotnet lambda delete-function MyFunction
```