# Crear e implementar funciones de Lambda C\$1 con archivos de archivo .zip
Un paquete de implementación .NET (archivo de archivo .zip) contiene el ensamblado compilado de su función junto con todas sus dependencias de ensamblado. El paquete también contiene un archivo `proj.deps.json`. Esto indica al tiempo de ejecución .NET todas las dependencias de su función y un archivo `proj.runtimeconfig.json`, que se utiliza para configurar el tiempo de ejecución.
Para implementar funciones individuales de Lambda, puede usar la `Amazon.Lambda.Tools` CLI de .NET Lambda Global. El uso del comando `dotnet lambda deploy-function` crea automáticamente un paquete de implementación .zip y lo implementa en Lambda. Sin embargo, le recomendamos que utilice marcos como AWS Serverless Application Model (AWS SAM) o el AWS Cloud Development Kit (AWS CDK) para implementar sus aplicaciones.NET en AWS.
Las aplicaciones sin servidor suelen incluir una combinación de funciones de Lambda y otros servicios administrados de Servicios de AWS que trabajan juntos para realizar una tarea empresarial determinada. AWS SAM y AWS CDK simplifican la creación e implementación de funciones de Lambda con otros Servicios de AWS a escala. La [especificación de plantillas de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) proporciona una sintaxis sencilla y organizada para describir las funciones de Lambda, las API, los permisos, las configuraciones y los otros recursos de AWS que constituyen la aplicación sin servidor. Con [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html) puede definir la infraestructura de nube como código para ayudarle a crear aplicaciones fiables, escalables y rentables en la nube mediante marcos y lenguajes de programación modernos, como .NET. Tanto AWS CDK como AWS SAM utilizan la CLI de .NET Lambda Global para empaquetar sus funciones.
Si bien es posible utilizar [Capas de Lambda](chapter-layers.md) con funciones en C\$1 al [utilizar la CLI de.NET Core](csharp-package-cli.md#csharp-layers), se recomienda que no lo haga. Las funciones en C\$1 que utilizan capas cargan de forma manual los ensamblajes compartidos en la memoria durante el [Fase "init"](lambda-runtime-environment.md#runtimes-lifecycle-ib), lo que puede aumentar los tiempos de arranque en frío. En su lugar, incluya todo el código compartido en el momento de la compilación para evitar el impacto en el rendimiento de la carga de los ensamblajes durante el tiempo de ejecución.
En las siguientes secciones, encontrará instrucciones para crear e implementar funciones de Lamba .NET mediante AWS SAM, AWS CDK y la CLI de .NET Lambda Global y la CLI.
**Topics**
+ [
# Uso de la CLI de .NET Lambda Global
](csharp-package-cli.md)
+ [
# Implemente las funciones de Lambda C\$1 utilizando AWS SAM
](csharp-package-sam.md)
+ [
# Implemente las funciones de Lambda C\$1 utilizando AWS CDK
](csharp-package-cdk.md)
+ [
# Implementación de aplicaciones ASP .NET
](csharp-package-asp.md)
# Uso de la CLI de .NET Lambda Global
La CLI de .NET y la extensión .NET Lambda Global Tools (`Amazon.Lambda.Tools`) ofrecen una forma multiplataforma para crear aplicaciones Lambda basadas en .NET, empaquetarlas e implementarlas en Lambda. En esta sección, aprenderá a crear nuevos proyectos .NET de Lambda mediante la CLI de .NET y las plantillas de Amazon Lambda, y a empaquetarlos e implementarlos mediante `Amazon.Lambda.Tools`
**Topics**
+ [
## Requisitos previos
](#csharp-package-cli-prerequisites)
+ [
## Creación de proyectos .NET mediante la CLI de .NET
](#csharp-package-cli-create)
+ [
## Implementación de proyectos.NET mediante la CLI de .NET
](#csharp-package-cli-deploy)
+ [
## Uso de capas de Lambda con la CLI de .NET
](#csharp-layers)
## Requisitos previos
**SDK para .NET 8**
Si aún no lo ha hecho, instale el SDK y el tiempo de ejecución de [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).
**AWS Plantillas de proyecto .NET Amazon.Lambda.Templates**
Para generar el código de la función de Lambda, utilice el paquete NuGet [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates). Para instalar este paquete de plantillas, ejecute el siguiente comando:
```
dotnet new install Amazon.Lambda.Templates
```
**AWS Herramientas globales para la CLI de .NET Amazon.Lambda.Tools**
Para crear sus funciones de Lambda, utilice la [extensión de herramientas globales de .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools). Ejecute el siguiente comando para instalar Amazon.Lambda.Tools:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Para obtener más información sobre la Amazon.Lambda.Tools de la extensión de la CLI de .NET, consulte el repositorio en GitHub [ Extensiones de AWS para la CLI de .NET](https://github.com/aws/aws-extensions-for-dotnet-cli).
## Creación de proyectos .NET mediante la CLI de .NET
En la CLI de .NET se usa el comando `dotnet new` para crear proyectos .NET desde la línea de comando. Lambda ofrece plantillas adicionales mediante el paquete [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates) NuGet.
Tras la instalación de este paquete, ejecute el siguiente comando para ver una lista de las plantillas disponibles.
```
dotnet new list
```
Para examinar los detalles acerca de una plantilla, utilice la opción `help`. Por ejemplo, para ver los detalles de la plantilla `lambda.EmptyFunction`, ejecute el siguiente comando.
```
dotnet new lambda.EmptyFunction --help
```
Para crear una plantilla básica para una función de Lambda .NET, utilice la plantilla `lambda.EmptyFunction`. Esto crea una función sencilla que toma una cadena como entrada y la convierte a mayúsculas mediante el método `ToUpper`. Esta plantilla es compatible con las siguientes opciones:
+ `--name`: el nombre de la función.
+ `--region`: la región AWS para crear la función dentro.
+ `--profile`: el nombre de un perfil en su archivo de credenciales de AWS SDK para .NET. Para obtener más información sobre los perfiles de credenciales en .NET, consulte [Configurar credenciales AWS](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html) en *SDK AWS para Guía para desarrolladores de .NET*.
En este ejemplo, creamos una nueva función vacía llamada `myDotnetFunction` con el perfil y la configuración Región de AWS predeterminados:
```
dotnet new lambda.EmptyFunction --name myDotnetFunction
```
Este comando crea los siguientes archivos y directorios en el directorio de su proyecto.
```
└── myDotnetFunction
├── src
│ └── myDotnetFunction
│ ├── Function.cs
│ ├── Readme.md
│ ├── aws-lambda-tools-defaults.json
│ └── myDotnetFunction.csproj
└── test
└── myDotnetFunction.Tests
├── FunctionTest.cs
└── myDotnetFunction.Tests.csproj
```
En el directorio `src/myDotnetFunction`, examine los archivos siguientes:
+ **aws-lambda-tools-defaults.json**: aquí se especifican las opciones de línea de comando al implementar su función de Lambda. Por ejemplo:
```
"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**: 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). También incluye una función de muestra que puede editar para aplicar el código de su función de 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**: un archivo [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx) que enumera los archivos y ensamblados que componen la aplicación.
```
net8.0
enable
enable
true
Lambda
true
true
```
+ **Readme**: use este archivo para documentar su función de Lambda.
En el directorio `myfunction/test`, examine los archivos siguientes:
+ **myDotnetFunction.Tests.csproj**: como se ha indicado con anterioridad, este es un archivo [MSBuild](https://msdn.microsoft.com/en-us/library/dd393574.aspx) que enumera los archivos y los ensamblados que componen el proyecto de prueba. Tenga en cuenta que también incluye la biblioteca `Amazon.Lambda.Core`, de modo que puede integrar a la perfección cualquier plantilla de Lambda necesaria para probar la función.
```
...
...
```
+ **FunctionTest.cs**: el mismo archivo de plantilla de código C\$1 que se incluye en el directorio `src`. Edite este archivo para reflejar el código de producto de su función y probarlo antes de cargar su función de Lambda en un entorno de producción.
```
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);
}
}
}
```
## Implementación de proyectos.NET mediante la CLI de .NET
Para crear su paquete de implementación e implementarlo en Lambda, utilice las herramientas de CLI `Amazon.Lambda.Tools`. Para implementar la función a partir de los archivos que creó en los pasos anteriores, primero navegue hasta la carpeta que contiene el archivo `.csproj` de la función.
```
cd myDotnetFunction/src/myDotnetFunction
```
Para implementar el código en Lambda como un paquete de implementación .zip, ejecute el siguiente comando. Elija su propio nombre de función.
```
dotnet lambda deploy-function myDotnetFunction
```
Durante la implementación, el asistente le pide que seleccione un [Definición de permisos de funciones de Lambda con un rol de ejecución](lambda-intro-execution-role.md). Para este ejemplo, seleccione `lambda_basic_role`.
Una vez implementada la función, puede probarla en la nube con el comando `dotnet lambda invoke-function`. Para el código de ejemplo de la plantilla `lambda.EmptyFunction`, puede probar su función pasando una cadena mediante la opción `--payload`.
```
dotnet lambda invoke-function myDotnetFunction --payload "Just checking if everything is OK"
```
Si la función se ha implementado correctamente, debería ver un resultado similar al siguiente.
```
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
```
## Uso de capas de Lambda con la CLI de .NET
**nota**
Si bien es posible utilizar [capas](chapter-layers.md) con funciones en .NET, se recomienda que no lo haga. Las funciones en .NET que utilizan capas cargan de forma manual los ensamblajes compartidos en la memoria durante la fase de `Init`, lo que puede aumentar los tiempos de arranque en frío. En su lugar, incluya todo el código compartido en el momento de la compilación para aprovechar las optimizaciones integradas en el compilador de .NET.
La CLI de .NET admite comandos que lo ayudan a publicar capas e implementar funciones de C\$1 que consumen capas. Para publicar una capa en un bucket de Amazon S3 específico, ejecute el siguiente comando en el mismo directorio que su archivo `.csproj`:
```
dotnet lambda publish-layer --layer-type runtime-package-store --s3-bucket
```
Luego, cuando implemente la función mediante la CLI de .NET, especifique el ARN de la capa que consumirá en el siguiente comando:
```
dotnet lambda deploy-function --function-layers arn:aws:lambda:us-east-1:123456789012:layer:layer-name:1
```
Para conocer un ejemplo completo de una función “Hola, mundo”, consulte la muestra [blank-csharp-with-layer](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-csharp-with-layer).
# Implemente las funciones de Lambda C\$1 utilizando AWS SAM
AWS Serverless Application Model (AWS SAM) es un conjunto de herramientas que ayuda a agilizar el proceso de creación y ejecución de aplicaciones sin servidor en AWS. Defina los recursos de su aplicación en una plantilla YAML o JSON y utilice la interfaz de la línea de comandos de AWS SAM (AWS SAM CLI) para crear, empaquetar e implementar sus aplicaciones. Al crear una función de Lambda a partir de una plantilla de AWS SAM, AWS SAM crea automáticamente un paquete de implementación .zip o una imagen de contenedor con el código de la función y las dependencias que especifique. Después, AWS SAM implementa la función mediante una [pila CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html).zip Para obtener más información sobre el uso de AWS SAM para crear e implementar funciones de Lambda, consulte [Introducción a AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.
Los siguientes pasos muestran cómo descargar, crear e implementar una aplicación Hello World .NET de muestra mediante AWS SAM. Esta aplicación de muestra utiliza una función de Lambda y un punto de conexión de Amazon API Gateway para implementar un backend de API básico. Cuando envía una solicitud GET de HTTP a su punto de conexión de API Gateway, la última invoca la función de Lambda. La función devuelve un mensaje “Hello world”, junto con la dirección IP de la instancia de la función de Lambda que procesa la solicitud.
Al crear e implementar la aplicación mediante AWS SAM, entre bastidores, la CLI AWS SAM utiliza el comando `dotnet lambda package` para empaquetar los grupos de códigos de las funciones de Lambda individuales.
## Requisitos previos
**SDK para .NET 8**
Instale el SDK y el tiempo de ejecución de [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).
**Versión 1.39 o posterior de la CLI de AWS SAM**
Para instalar la última versión de la CLI de AWS SAM, consulte [Instalación de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html).
## Implementar una aplicación de ejemplo de AWS SAM
1. Inicialice la aplicación con la plantilla Hello world de .NET con el siguiente comando.
```
sam init --app-template hello-world --name sam-app \
--package-type Zip --runtime dotnet8
```
Este comando crea los siguientes archivos y directorios en el directorio de su proyecto.
```
└── 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 hasta el directorio que contiene el `template.yaml file`. Este archivo es una plantilla que define los recursos AWS de la aplicación, incluida la función de Lambda y una API de API Gateway.
```
cd sam-app
```
1. Para crear la fuente de la aplicación, ejecute el siguiente comando.
```
sam build
```
1. Para implementar la aplicación en AWS, ejecute el siguiente comando.
```
sam deploy --guided
```
Este comando empaqueta e implementa la aplicación con la siguiente serie de solicitudes. Para aceptar las opciones predeterminadas, pulse Enter.
**nota**
Puede que **HelloWorldFunction no tenga definida la autorización, ¿está bien?** Asegúrese de ingresar `y`.
+ **Nombre de la pila**: el nombre de la pila para la implementación en CloudFormation. Este nombre debe ser exclusivo para Cuenta de AWS y Región de AWS.
+ **Región de AWS**: El Región de AWS en el que desea implementar su aplicación.
+ **Confirme los cambios antes de la implementación**: seleccione “Sí” para revisar manualmente cualquier conjunto de cambios antes de que AWS SAM implemente los cambios en la aplicación. Si selecciona “No”, la CLI AWS SAM implementa automáticamente los cambios en las aplicaciones.
+ **Permitir la creación de roles de IAM en la CLI de SAM**: muchas plantillas AWS SAM, incluida la de Hello world en este ejemplo, crean roles (de IAM) AWS Identity and Access Management para dar permiso a las funciones de Lambda para acceder a otras Servicios de AWS. Seleccione “Sí” para conceder permiso para implementar una pila CloudFormation que cree o modifique los roles de IAM.
+ **Desactivar la reversión**: de forma predeterminada, si AWS SAM encuentra un error durante la creación o la implementación de la pila, la devuelve a la versión anterior. Seleccione “No” para aceptar este valor predeterminado.
+ Puede que **HelloWorldFunction no tenga definida la autorización, ¿está bien?**: Ingrese `y`.
+ **Guardar los argumentos en samconfig.toml**: seleccione “Sí” para guardar las opciones de configuración. En el futuro, podrá volver a ejecutar `sam deploy` sin parámetros para implementar cambios en la aplicación.
1. Una vez finalizada la implementación de la aplicación, la CLI devuelve el nombre de recurso de Amazon (ARN) de la función de Lambda de Hello World y el rol de IAM creado para la misma. También muestra el punto de conexión de la API de API Gateway. Para probar la aplicación, abra el punto de conexión en un navegador. Verá una respuesta parecida a la siguiente.
```
{"message":"hello world","location":"34.244.135.203"}
```
1. Use el siguiente comando para eliminar los recursos. Tenga en cuenta que el punto de conexión de la API que ha creado es un punto de conexión público al que se puede acceder a través de Internet. Se recomienda eliminar este punto de conexión después de las pruebas.
```
sam delete
```
## Pasos a seguir a continuación
Para obtener más información sobre AWS SAM para crear e implementar funciones de Lambda mediante .NET, consulte los siguientes recursos:
+ La [guía para desarrolladores de *AWS Serverless Application Model (AWS SAM)*](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
+ [Creación de aplicaciones .NET sin servidor con la CLI AWS Lambda de SAM](https://aws.amazon.com/blogs/dotnet/building-serverless-net-applications-with-aws-lambda-and-the-sam-cli/)
# Implemente las funciones de Lambda C\$1 utilizando AWS CDK
AWS Cloud Development Kit (AWS CDK) es un marco de desarrollo de software de código abierto para definir la infraestructura de nube como código con marcos y lenguajes de programación modernos, como .NET. Los proyectos AWS CDK se ejecutan para generar plantillas CloudFormation que luego se utilizan para implementar el código.
Para crear e implementar un ejemplo de aplicación Hello world .NET mediante AWS CDK, siga las instrucciones de las siguientes secciones. La aplicación de ejemplo implementa un backend de API básico que consta de un punto de conexión API Gateway y una función de Lambda. Cuando se envía una solicitud HTTP GET al punto de conexión, API Gateway invoca la función de Lambda. La función devuelve un mensaje “Hello world”, junto con la dirección IP de la instancia Lambda que procesa la solicitud.
## Requisitos previos
**SDK para .NET 8**
Instale el SDK y el tiempo de ejecución de [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0).
**Versión 2 de la AWS CDK**
Para obtener información sobre cómo instalar la última versión de AWS CDK consulte [Introducción a la AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) en la *Guía para desarrolladores de AWS Cloud Development Kit (AWS CDK) versión 2.*.
## Implementar una aplicación de ejemplo de AWS CDK
1. Cree un directorio de proyectos para la aplicación de ejemplo y navegue hasta él.
```
mkdir hello-world
cd hello-world
```
1. Inicialice una nueva aplicación AWS CDK mediante la ejecución del siguiente comando.
```
cdk init app --language csharp
```
El comando crea los siguientes archivos y directorios en el directorio del proyecto
```
├── README.md
├── cdk.json
└── src
├── HelloWorld
│ ├── GlobalSuppressions.cs
│ ├── HelloWorld.csproj
│ ├── HelloWorldStack.cs
│ └── Program.cs
└── HelloWorld.sln
```
1. Abra el directorio `src` y cree una nueva función de Lambda mediante la CLI de .NET. Esta es la función que implementará mediante AWS CDK. En este ejemplo, se crea una función Hello world denominada `HelloWorldLambda` mediante la plantilla `lambda.EmptyFunction`.
```
cd src
dotnet new lambda.EmptyFunction -n HelloWorldLambda
```
Después de este paso, la estructura dentro del directorio de proyectos debería tener el siguiente aspecto.
```
├── 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 el archivo `HelloWorldStack.cs` del directorio `src/HelloWorld`. Reemplace el contenido del archivo por lo siguiente.
```
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
}),
});
}
}
}
```
Este es el código para compilar y empaquetar el código de la aplicación, así como la definición de la propia función de Lambda. El objeto `BundlingOptions` permite crear un archivo zip junto con un conjunto de comandos que se utilizan para generar el contenido del archivo zip. En este caso, el comando `dotnet lambda package` se usa para compilar y generar el archivo zip.
1. Para implementar la aplicación, ejecute el siguiente comando.
```
cdk deploy
```
1. Invoque la función de Lambda implementada mediante la CLI de .NET Lambda.
```
dotnet lambda invoke-function HelloWorldFunction -p "hello world"
```
1. Al acabar las prueba, a menos que desee retener los recursos que creó, puede eliminarlos. Use el siguiente comando para eliminar los recursos.
```
cdk destroy
```
## Pasos a seguir a continuación
Para obtener más información sobre AWS CDK para crear e implementar funciones de Lambda mediante .NET, consulte los siguientes recursos:
+ [Utilización del CDK AWS en C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
+ [Cree, empaquete y publique funciones de Lambda C\$1 de .NET con el CDK AWS](https://aws.amazon.com/blogs/modernizing-with-aws/build-package-publish-dotnet-csharp-lambda-functions-aws-cdk/)
# Implementación de aplicaciones ASP .NET
Además de alojar funciones basadas en eventos, también puede utilizar .NET con Lambda para alojar aplicaciones ASP .NET ligeras. Puede crear e implementar aplicaciones ASP .NET mediante el paquete NuGet `Amazon.Lambda.AspNetCoreServer`. En esta sección, aprenderá a implementar una API web de ASP .NET en Lambda mediante las herramientas de CLI de Lambda .NET.
**Topics**
+ [
## Requisitos previos
](#csharp-package-asp-prerequisites)
+ [
## Implementación de una API web de ASP.NET en Lambda
](#csharp-package-asp-deploy-api)
+ [
## Implementación de API mínimas de ASP .NET en Lambda
](#csharp-package-asp-deploy-minimal)
## Requisitos previos
**SDK para .NET 8**
Instale el SDK de [.NET 8](https://dotnet.microsoft.com/en-us/download/dotnet/8.0) y el tiempo de ejecución de ASP .NET Core.
**Amazon.Lambda.Tools**
Para crear sus funciones de Lambda, utilice la [extensión de herramientas globales de .NET](https://aws.amazon.com/blogs/developer/net-core-global-tools-for-aws/) [https://www.nuget.org/packages/Amazon.Lambda.Tools](https://www.nuget.org/packages/Amazon.Lambda.Tools). Ejecute el siguiente comando para instalar Amazon.Lambda.Tools:
```
dotnet tool install -g Amazon.Lambda.Tools
```
Para obtener más información sobre la Amazon.Lambda.Tools de la extensión de la CLI de .NET, consulte el repositorio en GitHub [ Extensiones de AWS para la CLI de .NET](https://github.com/aws/aws-extensions-for-dotnet-cli).
**Amazon.Lambda.Templates**
Para generar el código de la función de Lambda, utilice el paquete NuGet [https://www.nuget.org/packages/Amazon.Lambda.Templates](https://www.nuget.org/packages/Amazon.Lambda.Templates). Para instalar este paquete de plantillas, ejecute el siguiente comando:
```
dotnet new --install Amazon.Lambda.Templates
```
## Implementación de una API web de ASP.NET en Lambda
Para implementar una API web mediante ASP .NET, puede usar las plantillas .NET Lambda para crear un nuevo proyecto de API web. Utilice el siguiente comando para inicializar un nuevo proyecto de API web de ASP .NET. En el comando de ejemplo, asignamos un nombre al proyecto `AspNetOnLambda`.
```
dotnet new serverless.AspNetCoreWebAPI -n AspNetOnLambda
```
Este comando crea los siguientes archivos y directorios en el directorio de su proyecto.
```
.
└── 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
```
Cuando Lambda invoca la función, el punto de entrada que utiliza es el archivo `LambdaEntryPoint.cs`. El archivo creado por la plantilla Lambda de .NET contiene el siguiente código.
```
namespace AspNetOnLambda;
public class LambdaEntryPoint : Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction
{
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup≪Startup≫();
}
protected override void Init(IHostBuilder builder)
{
}
}
```
El punto de entrada utilizado por Lambda debe heredar de una de las tres clases base del paquete `Amazon.Lambda.AspNetCoreServer`. Estas tres clases base son:
+ `APIGatewayProxyFunction`
+ `APIGatewayHttpApiV2ProxyFunction`
+ `ApplicationLoadBalancerFunction`
La clase predeterminada que se utiliza al crear el archivo `LambdaEntryPoint.cs` con la plantilla .NET Lambda proporcionada es `APIGatewayProxyFunction`. La clase base que utilice en la función depende de la capa de API situada delante de la función de Lambda.
Cada una de las tres clases base contiene un método público denominado `FunctionHandlerAsync`. El nombre de este método formará parte de la [cadena de controladores](csharp-handler.md#csharp-class-library-handlers) que Lambda utiliza para invocar la función. El método `FunctionHandlerAsync` transforma la carga útil del evento entrante en el formato de ASP .NET correcto y la respuesta de ASP .NET en una carga útil de respuesta de Lambda. Para el proyecto `AspNetOnLambda` de ejemplo que se muestra, la cadena del controlador sería la siguiente.
```
AspNetOnLambda::AspNetOnLambda.LambdaEntryPoint::FunctionHandlerAsync
```
Para implementar la API en Lambda, ejecute los siguientes comandos para navegar al directorio que contiene el archivo de código fuente e implementar la función mediante CloudFormation.
```
cd AspNetOnLambda/src/AspNetOnLambda
dotnet lambda deploy-serverless
```
**sugerencia**
Al implementar una API mediante el comando `dotnet lambda deploy-serverless`, CloudFormation asigna un nombre a la función de Lambda según el nombre de pila que especifique durante la implementación. Para asignar un nombre personalizado a la función de Lambda, edite el archivo `serverless.template` para agregar una propiedad `FunctionName` al recurso `AWS::Serverless::Function`. Para obtener más información, consulte [Tipo de nombre](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html) en la *Guía del usuario de CloudFormation*.
## Implementación de API mínimas de ASP .NET en Lambda
Para implementar una API mínima de ASP .NET en Lambda, puede usar las plantillas Lambda .NET para crear un nuevo proyecto de API mínima. Use el siguiente comando para inicializar un nuevo proyecto de API mínima. En este ejemplo, usamos el nombre de proyecto `MinimalApiOnLambda`.
```
dotnet new serverless.AspNetCoreMinimalAPI -n MinimalApiOnLambda
```
El comando crea los siguientes archivos y directorios en el directorio de su proyecto.
```
└── MinimalApiOnLambda
└── src
└── MinimalApiOnLambda
├── Controllers
│ └── CalculatorController.cs
├── MinimalApiOnLambda.csproj
├── Program.cs
├── Readme.md
├── appsettings.Development.json
├── appsettings.json
├── aws-lambda-tools-defaults.json
└── serverless.template
```
El archivo `Program.cs` contiene la salida siguiente.
```
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 su API mínima para que se ejecute en Lambda, es posible que necesite editar este código para que las solicitudes y respuestas entre Lambda y ASP .NET Core se traduzcan correctamente. De forma predeterminada, la función está configurada para una fuente de eventos de la API de REST. En el caso de una API HTTP o un equilibrador de carga de aplicación, sustituya `(LambdaEventSource.RestApi)` por una de las siguientes opciones:
+ `(LambdaEventSource.HttpAPi)`
+ `(LambdaEventSource.ApplicationLoadBalancer)`
Para implementar su API mínima en Lambda, ejecute los siguientes comandos para navegar al directorio que contiene el archivo de código fuente e implementar la función mediante CloudFormation.
```
cd MinimalApiOnLambda/src/MinimalApiOnLambda
dotnet lambda deploy-serverless
```