# Uso de Lambda con la infraestructura como código (IaC)
Las funciones de Lambda rara vez se ejecutan de forma aislada. En cambio, a menudo forman parte de una aplicación sin servidor con otros recursos, como bases de datos, colas y almacenamiento. Con la [infraestructura como código (IaC)](https://aws.amazon.com/what-is/iac/), puede automatizar sus procesos de implementación para implementar y actualizar de forma rápida y repetible aplicaciones sin servidor completas que requieren muchos recursos de AWS independientes. Este enfoque acelera el ciclo de desarrollo, facilita la administración de la configuración y garantiza que sus recursos se implementen siempre de la misma manera.
## Herramientas de IaC para Lambda
**CloudFormation**
CloudFormation es el servicio de IaC fundamental de AWS. Puede usar [plantillas YAML o JSON](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) para modelar y aprovisionar toda su infraestructura de AWS, incluidas las funciones de Lambda. CloudFormation gestiona las complejidades de crear, actualizar y eliminar sus recursos de AWS.
**AWS Serverless Application Model (AWS SAM)**
AWS SAM es un marco de código abierto creado sobre CloudFormation. Proporciona una sintaxis simplificada para definir aplicaciones sin servidor. Utilice [plantillas de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html) para aprovisionar rápidamente funciones de Lambda, API, bases de datos y orígenes de eventos con solo unas pocas líneas de YAML.
**AWS Cloud Development Kit (AWS CDK)**
El CDK es un enfoque de la IaC que prioriza el código. Puede definir su arquitectura basada en Lambda mediante TypeScript, JavaScript, Python, Java, C\$1/.Net o Go. Elija el lenguaje que prefiera y utilice elementos de programación como parámetros, condicionales, bucles, composición y herencia para definir el resultado deseado de su infraestructura. A continuación, la CDK genera las plantillas de CloudFormation subyacentes para su implementación. Si desea ver un ejemplo de cómo usar Lambda con el CDK, consulte [Implementación de funciones de Lambda con AWS CDK](lambda-cdk-tutorial.md).
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/IaC_tools.png)
AWS también ofrece un servicio llamado AWS Infrastructure Composer para desarrollar plantillas de IaC mediante una interfaz gráfica sencilla. Con Infrastructure Composer, puede arrastrar, agrupar y conectar los Servicios de AWS en un lienzo visual para diseñar una arquitectura de aplicaciones. A continuación, Infrastructure Composer crea una plantilla de AWS SAM o una plantilla de CloudFormation a partir de su diseño que puede usar para implementar la aplicación.
En la siguiente sección, [Uso de funciones de Lambda en AWS SAM y en Infrastructure Composer](foundation-iac-getting-started.md), utilizará Infrastructure Composer para desarrollar una plantilla para una aplicación sin servidor basada en una función de Lambda existente.
# Uso de funciones de Lambda en AWS SAM y en Infrastructure Composer
En este tutorial, puede empezar a utilizar IaC con Lambda al crear una plantilla de AWS SAM a partir de una función de Lambda existente y, a continuación, crear una aplicación sin servidor en Infrastructure Composer al agregar otros recursos de AWS.
A medida que realice este tutorial, aprenderá algunos conceptos fundamentales, como la forma en que se especifican los recursos de AWS en AWS SAM. También aprenderá a usar Infrastructure Composer para crear una aplicación sin servidor que pueda implementar mediante AWS SAM o CloudFormation.
Para completar este tutorial, debe llevar a cabo los siguientes pasos:
+ Crear un ejemplo de función de Lambda
+ Utilizar la consola de Lambda para obtener la plantilla de AWS SAM de la función
+ Exportar la configuración de la función a AWS Infrastructure Composer y diseñar una aplicación sin servidor sencilla que se base en la configuración de la función
+ Guardar una plantilla de AWS SAM actualizada que pueda utilizar como base para implementar su aplicación sin servidor
## Requisitos previos
En este tutorial, utilizará la característica de [sincronización local](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html) de Infrastructure Composer para guardar la plantilla y los archivos de código en su máquina de compilación local. Para utilizar esta característica, necesita un navegador compatible con la API de acceso al sistema de archivos, que permite a las aplicaciones web leer, escribir y guardar archivos en su sistema de archivos local. Recomendamos utilizar Google Chrome o Microsoft Edge. Para obtener más información sobre la API de acceso al sistema de archivos, consulte [¿Qué es la API de acceso al sistema de archivos?](https://docs.aws.amazon.com/application-composer/latest/dg/reference-fsa.html#reference-fsa-api)
## Creación de una función de Lambda
En este primer paso, creará una función de Lambda que podrá utilizar para completar el resto del tutorial. Para simplificar las tareas, utiliza la consola de Lambda para crear una función básica “Hola, mundo” con el tiempo de ejecución Python 3.11.
**Para crear una función de Lambda “Hola, mundo” con la consola**
1. Abra la [consola de Lambda](https://console.aws.amazon.com/lambda).
1. Seleccione **Creación de función**.
1. Deje seleccionada la opción **Crear desde cero** y, en **Información básica**, ingrese **LambdaIaCDemo** en **Nombre de la función**.
1. En **Tiempo de ejecución**, elija **Python 3.11**.
1. Seleccione **Creación de función**.
## Visualización de la plantilla de AWS SAM para su función
Antes de exportar la configuración de la función a Infrastructure Composer, utilice la consola de Lambda para ver la configuración actual de la función como una plantilla de AWS SAM. Si sigue los pasos de esta sección, aprenderá sobre la anatomía de una plantilla de AWS SAM y cómo definir recursos, como las funciones de Lambda, para empezar a especificar una aplicación sin servidor.
**Visualización de la plantilla de AWS SAM para su función**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija la función que acaba de crear (`LambdaIaCDemo`).
1. En el panel **Información general de la función**, elija **Plantilla**.
En lugar del diagrama que representa la configuración de la función, verá una plantilla de AWS SAM para la función. La plantilla debe tener el siguiente aspecto.
```
# This AWS SAM template has been generated from your function's
# configuration. If your function has one or more triggers, note
# that the AWS resources associated with these triggers aren't fully
# specified in this template and include placeholder values.Open this template
# in AWS Application Composer or your favorite IDE and modify
# it to specify a serverless application with other AWS resources.
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Specification template describing your function.
Resources:
LambdaIaCDemo:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 3
Handler: lambda_function.lambda_handler
Runtime: python3.11
Architectures:
- x86_64
EventInvokeConfig:
MaximumEventAgeInSeconds: 21600
MaximumRetryAttempts: 2
EphemeralStorage:
Size: 512
RuntimeManagementConfig:
UpdateRuntimeOn: Auto
SnapStart:
ApplyOn: None
PackageType: Zip
Policies:
Statement:
- Effect: Allow
Action:
- logs:CreateLogGroup
Resource: arn:aws:logs:us-east-1:123456789012:*
- Effect: Allow
Action:
- logs:CreateLogStream
- logs:PutLogEvents
Resource:
- >-
arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/LambdaIaCDemo:*
```
Dediquemos un momento a analizar la plantilla YAML de su función y comprender algunos conceptos clave.
La plantilla comienza con la declaración `Transform: AWS::Serverless-2016-10-31`. Esta declaración es obligatoria porque, en segundo plano, las plantillas de AWS SAM se implementan con CloudFormation. Usar la instrucción `Transform` identifica la plantilla como un archivo de plantilla de AWS SAM.
Después de la declaración `Transform`, viene la sección `Resources`. Aquí es donde se definen los recursos de AWS que desea implementar con su plantilla de AWS SAM. Las plantillas de AWS SAM pueden contener una combinación de recursos de AWS SAM y CloudFormation. Esto se debe a que, durante la implementación, las plantillas de AWS SAM se expanden para volverlas plantillas de CloudFormation, por lo que se puede agregar cualquier sintaxis de CloudFormation válida a una plantilla de AWS SAM.
Por el momento, solo hay un recurso definido en la sección `Resources` de la plantilla, la función de Lambda `LambdaIaCDemo`. Para agregar una función de Lambda a una plantilla de AWS SAM, utilice el tipo de recurso `AWS::Serverless::Function`. Las `Properties` de una función de Lambda definen el tiempo de ejecución de la función, su controlador y otras opciones de configuración. La ruta al código fuente de la función que AWS SAM debe usar para implementarla también se define aquí. Para obtener más información sobre los recursos de funciones de Lambda en AWS SAM, consulte [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) en la *Guía para desarrolladores de AWS SAM*.
Además de las propiedades y las configuraciones de la función, la plantilla también especifica una política de AWS Identity and Access Management (IAM) para su función. Esta política otorga permiso a su función para escribir registros en Registros de Amazon CloudWatch. Al crear una función en la consola de Lambda, dicho servicio adjunta esta política a la función automáticamente. Para obtener más información sobre cómo especificar una política de IAM para una función en una plantilla de AWS SAM, consulte la propiedad `policies` en la página [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) de la *Guía para desarrolladores de AWS SAM*.
Para obtener más información sobre la estructura de plantillas de AWS SAM, consulte [AWS SAM template anatomy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-template-anatomy.html).
## Uso de AWS Infrastructure Composer para diseñar una aplicación sin servidor
Para empezar a crear una aplicación sin servidor sencilla con la plantilla de AWS SAM de la función como punto de partida, exporte la configuración de la función a Infrastructure Composer y active el modo de sincronización local de Infrastructure Composer. La sincronización local guarda automáticamente el código de la función y la plantilla de AWS SAM en la máquina de compilación local y mantiene la plantilla guardada sincronizada a medida que agrega otros recursos de AWS a Infrastructure Composer.
**Exportación de la función a Infrastructure Composer**
1. En el panel **Información general de la función**, elija **Exportar a Application Composer**.
Para exportar la configuración y el código de la función a Infrastructure Composer, Lambda crea un bucket de Amazon S3 en su cuenta para almacenar estos datos temporalmente.
1. En el cuadro de diálogo, seleccione **Confirmar y crear el proyecto** para aceptar el nombre predeterminado de este bucket y exportar la configuración y el código de la función a Infrastructure Composer.
1. (Opcional) Para elegir otro nombre para el bucket de Amazon S3 que Lambda crea, introduzca un nombre nuevo y elija **Confirmar y crear proyecto**. Los nombres de los buckets de Amazon S3 no pueden repetirse en ningún lado y deben seguir las [reglas de nomenclatura de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).
Al seleccionar **Confirmar y crear el proyecto**, se abre la consola de Infrastructure Composer. En el *lienzo*, verá su función de Lambda.
1. En el **menú** desplegable, seleccione **Activar la sincronización local**.
1. En el cuadro de diálogo que se abre, elija **Seleccionar carpeta** y, luego, seleccione una carpeta de su máquina de compilación local.
1. Seleccione **Activar** para activar la sincronización local.
A fin de exportar su función a Infrastructure Composer, necesita permiso para usar ciertas acciones de la API. Si no puede exportar la función, compruebe [Permisos necesarios](services-appcomposer.md#services-appcomposer-permissions) y asegúrese de tener los permisos que necesita.
**nota**
Para el bucket que Lambda crea, se aplican los [precios de Amazon S3](https://aws.amazon.com/s3/pricing) estándar al exportar una función a Infrastructure Composer. Los objetos que Lambda coloca en el bucket se eliminan automáticamente después de 10 días, pero Lambda no elimina el bucket en sí.
Para evitar que se agreguen más cargos a su Cuenta de AWS, siga las instrucciones que se indican en [Eliminar un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) después de haber exportado la función a Infrastructure Composer. Para obtener más información acerca del bucket de Amazon S3 que Lambda crea, consulte [Uso de AWS Lambda con AWS Infrastructure Composer](services-appcomposer.md).
**Diseño de su aplicación sin servidor en Infrastructure Composer**
Después de activar la sincronización local, los cambios que haga en Infrastructure Composer se reflejarán en la plantilla de AWS SAM guardada en su máquina de compilación local. Ahora puede arrastrar y soltar recursos de AWS adicionales en el lienzo de Infrastructure Composer para crear su aplicación. En este ejemplo, agrega una cola simple de Amazon SQS como desencadenador de la función de Lambda y una tabla de DynamoDB en la que la función escribe datos.
1. Para agregar un desencadenador de Amazon SQS a su función de Lambda, haga lo siguiente:
1. En el campo de búsqueda de la paleta **Recursos**, ingrese **SQS**.
1. Arrastre el recurso **Cola de SQS** al lienzo y colóquelo a la izquierda de la función de Lambda.
1. Elija **Detalles** y, en **ID lógico**, ingrese **LambdaIaCQueue**.
1. Seleccione **Save**.
1. Conecte sus recursos de Amazon SQS y Lambda haciendo clic en el puerto **Suscripción** de la tarjeta de cola de SQS y arrastrándolo hasta el puerto izquierdo de la tarjeta de función de Lambda. La aparición de una línea entre los dos recursos indica que la conexión se ha realizado correctamente. Infrastructure Composer también muestra un mensaje en la parte inferior del lienzo que indica que los dos recursos se han conectado correctamente.
1. Para agregar una tabla de Amazon DynamoDB en la que la función de Lambda pueda escribir datos, haga lo siguiente:
1. En el campo de búsqueda de la paleta **Recursos**, ingrese **DynamoDB**.
1. Arrastre el recurso **Tabla de DynamoDB** al lienzo y colóquelo a la derecha de la función de Lambda.
1. Elija **Detalles** y, en **ID lógico**, ingrese **LambdaIaCTable**.
1. Seleccione **Save**.
1. Conecte la tabla de DynamoDB a la función de Lambda haciendo clic en el puerto a la derecha de la tarjeta de la función de Lambda y arrastrándolo hasta el puerto a la izquierda de la tarjeta de DynamoDB.
Ahora que ya ha agregado estos recursos adicionales, echemos un vistazo a la plantilla actualizada de AWS SAM que ha creado Infrastructure Composer.
**Visualización de la plantilla de AWS SAM actualizada**
+ En el lienzo de Infrastructure Composer, elija **Plantilla** para cambiar de la vista de lienzo a la vista de plantilla.
Su plantilla de AWS SAM ya debería contener los siguientes recursos y propiedades adicionales:
+ Una cola de Amazon SQS con el identificador `LambdaIaCQueue`
```
LambdaIaCQueue:
Type: AWS::SQS::Queue
Properties:
MessageRetentionPeriod: 345600
```
Al agregar una cola de Amazon SQS mediante Infrastructure Composer, este establece la propiedad `MessageRetentionPeriod`. También puede establecer la propiedad `FifoQueue` seleccionando **Detalles** en la tarjeta de cola de SQS y marcando o desmarcando la **cola FIFO**.
Para establecer otras propiedades de la cola, puede editar la plantilla manualmente para agregarlas. Para obtener más información sobre el recurso `AWS::SQS::Queue` y sus propiedades disponibles, consulte [AWS::SQS::Queue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sqs-queue.html) en la *Guía del usuario de CloudFormation*.
+ Una propiedad `Events` en la definición de la función de Lambda que especifica la cola de Amazon SQS como desencadenador de la función
```
Events:
LambdaIaCQueue:
Type: SQS
Properties:
Queue: !GetAtt LambdaIaCQueue.Arn
BatchSize: 1
```
La propiedad `Events` consta de un tipo de evento y un conjunto de propiedades que dependen del tipo. Para obtener información sobre los distintos Servicios de AWS que puede configurar para activar una función de Lambda y las propiedades que puede establecer, consulte [EventSource](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-eventsource.html) en la *Guía para desarrolladores de AWS SAM*.
+ Una tabla de DynamoDB con el identificador `LambdaIaCTable`
```
LambdaIaCTable:
Type: AWS::DynamoDB::Table
Properties:
AttributeDefinitions:
- AttributeName: id
AttributeType: S
BillingMode: PAY_PER_REQUEST
KeySchema:
- AttributeName: id
KeyType: HASH
StreamSpecification:
StreamViewType: NEW_AND_OLD_IMAGES
```
Al agregar una tabla de DynamoDB mediante Infrastructure Composer, puede seleccionar **Detalles** en la tarjeta de la tabla de DynamoDB y editar los valores de la clave para configurar las claves de la tabla. Infrastructure Composer también establece los valores predeterminados para otras propiedades, incluidas `BillingMode` y `StreamViewType`.
Para obtener más información sobre estas y otras propiedades que puede agregar a la plantilla de AWS SAM, consulte [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html) en la *Guía del usuario de CloudFormation*.
+ Una nueva política de IAM que permite a su función realizar operaciones CRUD en la tabla de DynamoDB que ha agregado
```
Policies:
...
- DynamoDBCrudPolicy:
TableName: !Ref LambdaIaCTable
```
La plantilla final de AWS SAM debería verse similar al siguiente ejemplo.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Specification template describing your function.
Resources:
LambdaIaCDemo:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 3
Handler: lambda_function.lambda_handler
Runtime: python3.11
Architectures:
- x86_64
EventInvokeConfig:
MaximumEventAgeInSeconds: 21600
MaximumRetryAttempts: 2
EphemeralStorage:
Size: 512
RuntimeManagementConfig:
UpdateRuntimeOn: Auto
SnapStart:
ApplyOn: None
PackageType: Zip
Policies:
- Statement:
- Effect: Allow
Action:
- logs:CreateLogGroup
Resource: arn:aws:logs:us-east-1:594035263019:*
- Effect: Allow
Action:
- logs:CreateLogStream
- logs:PutLogEvents
Resource:
- arn:aws:logs:us-east-1:594035263019:log-group:/aws/lambda/LambdaIaCDemo:*
- DynamoDBCrudPolicy:
TableName: !Ref LambdaIaCTable
Events:
LambdaIaCQueue:
Type: SQS
Properties:
Queue: !GetAtt LambdaIaCQueue.Arn
BatchSize: 1
Environment:
Variables:
LAMBDAIACTABLE_TABLE_NAME: !Ref LambdaIaCTable
LAMBDAIACTABLE_TABLE_ARN: !GetAtt LambdaIaCTable.Arn
LambdaIaCQueue:
Type: AWS::SQS::Queue
Properties:
MessageRetentionPeriod: 345600
LambdaIaCTable:
Type: AWS::DynamoDB::Table
Properties:
AttributeDefinitions:
- AttributeName: id
AttributeType: S
BillingMode: PAY_PER_REQUEST
KeySchema:
- AttributeName: id
KeyType: HASH
StreamSpecification:
StreamViewType: NEW_AND_OLD_IMAGES
```
## Implementación de su aplicación sin servidor mediante AWS SAM (opcional)
Si desea utilizar AWS SAM para implementar una aplicación sin servidor con la plantilla que acaba de crear en Infrastructure Composer, primero debe instalar la CLI de AWS SAM. Para ello, siga las instrucciones que se enumeran en [Instalación de la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html).
Antes de implementar la aplicación, también debe actualizar el código de la función que Infrastructure Composer guardó junto con la plantilla. Por el momento, el archivo `lambda_function.py` que guardó Infrastructure Composer contiene solo el código básico “Hola, mundo” que Lambda proporcionó al crear la función.
Para actualizar el código de la función, copie el siguiente código y péguelo en el archivo `lambda_function.py` que Infrastructure Composer guardó en su máquina de compilación local. Cuando activó el modo de sincronización local, especificó el directorio en el que Infrastructure Composer debe guardar este archivo.
Este código acepta un par clave-valor en un mensaje de la cola de Amazon SQS que creó en Infrastructure Composer. Si tanto la clave como el valor son cadenas, el código las utiliza para escribir un elemento en la tabla de DynamoDB definida en la plantilla.
### Código de la función Python actualizado
```
import boto3
import os
import json
# define the DynamoDB table that Lambda will connect to
tablename = os.environ['LAMBDAIACTABLE_TABLE_NAME']
# create the DynamoDB resource
dynamo = boto3.client('dynamodb')
def lambda_handler(event, context):
# get the message out of the SQS event
message = event['Records'][0]['body']
data = json.loads(message)
# write event data to DDB table
if check_message_format(data):
key = next(iter(data))
value = data[key]
dynamo.put_item(
TableName=tablename,
Item={
'id': {'S': key},
'Value': {'S': value}
}
)
else:
raise ValueError("Input data not in the correct format")
# check that the event object contains a single key value
# pair that can be written to the database
def check_message_format(message):
if len(message) != 1:
return False
key, value = next(iter(message.items()))
if not (isinstance(key, str) and isinstance(value, str)):
return False
else:
return True
```
**Implementación de la aplicación sin servidor**
Para implementar su aplicación con la AWS SAM CLI, lleve a cabo los siguientes pasos. Para que su función se compile e implemente correctamente, su máquina de compilación y su `PATH` deben tener instalada la versión 3.11 de Python.
1. Ejecute el siguiente comando desde el directorio en el que Infrastructure Composer guardó sus archivos `template.yaml` y `lambda_function.py`.
```
sam build
```
Este comando recopila los artefactos de compilación de la aplicación y los coloca en el formato y la ubicación adecuados para implementarlos.
1. Para implementar la aplicación y crear los recursos de Lambda, Amazon SQS y DynamoDB especificados en la plantilla de AWS SAM, ejecute el siguiente comando.
```
sam deploy --guided
```
El uso de la marca `--guided` significa que AWS SAM le mostrará instrucciones para guiarlo a lo largo del proceso de implementación. Para esta implementación, acepte las opciones predeterminadas pulsando Intro.
Durante el proceso de implementación, AWS SAM crea los siguientes recursos en su Cuenta de AWS:
+ Una [pila](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-whatis-concepts.html#cfn-concepts-stacks) de CloudFormation llamada `sam-app`
+ Una función de Lambda con el formato de nombre `sam-app-LambdaIaCDemo-99VXPpYQVv1M`
+ Una cola de Amazon SQS con el formato de nombre `sam-app-LambdaIaCQueue-xL87VeKsGiIo`
+ Una tabla de DynamoDB con el formato de nombre `sam-app-LambdaIaCTable-CN0S66C0VLNV`
AWS SAM también crea las políticas y los roles de IAM necesarios para que su función de Lambda pueda leer los mensajes de la cola de Amazon SQS y realizar operaciones CRUD en la tabla de DynamoDB.
## Puesta a prueba de la aplicación implementada (opcional)
Para confirmar que la aplicación sin servidor se ha implementado correctamente, envíe un mensaje a la cola de Amazon SQS que contenga un par clave-valor y compruebe que Lambda escribe un elemento en la tabla de DynamoDB con estos valores.
**Para probar la aplicación sin servidor**
1. Abra la página [Colas](https://console.aws.amazon.com/sqs/v2/home#/queues) de la consola de Amazon SQS y seleccione la cola que creó AWS SAM en su plantilla. El nombre tiene el formato `sam-app-LambdaIaCQueue-xL87VeKsGiIo`.
1. Elija **Enviar y recibir mensajes** y pegue el siguiente JSON en el **Cuerpo del mensaje** de la sección **Enviar mensaje**.
```
{
"myKey": "myValue"
}
```
1. Elija **Enviar mensaje**.
Al enviar el mensaje a la cola, Lambda invocará la función a través de la asignación de orígenes de eventos definida en la plantilla de AWS SAM. Para confirmar que Lambda haya invocado su función según lo previsto, confirme que se haya agregado un elemento a la tabla de DynamoDB.
1. Abra la página [Tablas](https://console.aws.amazon.com/dynamodbv2#tables) en la consola de DynamoDB y seleccione su tabla. El nombre tiene el formato `sam-app-LambdaIaCTable-CN0S66C0VLNV`.
1. Elija **Explorar elementos de la tabla**. En el panel **Devolución de elementos**, debería ver un elemento con el **id** `myKey` y el **valor** `myValue`.
# Implementación de funciones de Lambda con AWS CDK
AWS Cloud Development Kit (AWS CDK) es un marco de infraestructura como código (IAC) que puede usar para definir la infraestructura en la nube de AWS mediante un lenguaje de programación de su elección. Para definir su propia infraestructura de nube, primero escriba una aplicación (en uno de los lenguajes compatibles con CDK) que contenga una o más pilas. Luego, sintetícela en una plantilla de CloudFormation e implemente sus recursos en suCuenta de AWS. Siga los pasos de este tema para implementar una función de Lambda que devuelva un evento desde un punto de conexión de Amazon API Gateway.
La biblioteca de construcción de AWS, incluida con el CDK, ofrece módulos que puede usar para modelar los recursos proporcionados por Servicios de AWS. Para los servicios más populares, la biblioteca proporciona construcciones seleccionadas con valores predeterminados inteligentes y prácticas recomendadas. Puede usar el módulo [aws\$1lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) para definir su función y los recursos de soporte con solo unas pocas líneas de código.
## Requisitos previos
Antes de empezar este tutorial, instale el AWS CDK; para ello, ejecute el siguiente comando.
```
npm install -g aws-cdk
```
## Paso 1: Configurar el proyecto de AWS CDK
Cree un directorio para la nueva aplicación AWS CDK e inicialice el proyecto.
------
#### [ JavaScript ]
```
mkdir hello-lambda
cd hello-lambda
cdk init --language javascript
```
------
#### [ TypeScript ]
```
mkdir hello-lambda
cd hello-lambda
cdk init --language typescript
```
------
#### [ Python ]
```
mkdir hello-lambda
cd hello-lambda
cdk init --language python
```
Después de inicializar el proyecto, active el entorno virtual del proyecto e instale las dependencias de referencia del AWS CDK.
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
mkdir hello-lambda
cd hello-lambda
cdk init --language java
```
Importe este proyecto de Maven a su entorno de desarrollo integrado (IDE) de Java. Por ejemplo, en Eclipse, elija **Archivo**, **Importar**, **Maven**, **Proyectos de Maven existentes**.
------
#### [ C\$1 ]
```
mkdir hello-lambda
cd hello-lambda
cdk init --language csharp
```
------
**nota**
La plantilla de la aplicación AWS CDK utiliza el nombre del directorio del proyecto para generar nombres para los archivos y las clases fuente. En este ejemplo, el directorio se llama `hello-lambda`. Si usa otro nombre de directorio de proyecto, la aplicación no coincidirá con estas instrucciones.
AWS CDK v2 incluye construcciones estables para todos los Servicios de AWS en un solo paquete denominado `aws-cdk-lib`. Este paquete se instala como dependencia cuando inicializa el proyecto. Al trabajar con ciertos lenguajes de programación, el paquete se instala al crear el proyecto por primera vez.
## Paso 2: definición de la pila de AWS CDK
Una *pila* de CDK es una colección de una o más construcciones que definen los recursos de AWS. Cada pila de CDK representa una pila de CloudFormation en la aplicación del CDK.
Para definir su CDK, siga las instrucciones de su lenguaje de programación preferido. En esta pila se define lo siguiente:
+ Nombre lógico de la función: `MyFunction`
+ La ubicación del código de la función, especificada en la propiedad `code`. Para obtener más información, consulte [Código del controlador](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html#handler-code) en la *Referencia de la API de AWS Cloud Development Kit (AWS CDK)*.
+ Nombre lógico de la API de REST: `HelloApi`
+ Nombre lógico del punto de conexión de API Gateway: `ApiGwEndpoint`
Tenga en cuenta que todas las pilas de CDK de este tutorial utilizan el [tiempo de ejecución](lambda-runtimes.md) de Node.js para la función de Lambda. Puede usar diferentes lenguajes de programación para la pila de CDK y la función de Lambda para aprovechar las ventajas de cada lenguaje. Por ejemplo, puede usar TypeScript para la pila de CDK para aprovechar las ventajas de la escritura estática en el código de su infraestructura. Puede utilizar JavaScript para la función de Lambda para aprovechar la flexibilidad y el rápido desarrollo de un lenguaje de tipificación dinámica.
------
#### [ JavaScript ]
Reemplace el contenido del archivo `lib/hello-lambda-stack.js` por lo siguiente.
```
const { Stack } = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const apigw = require('aws-cdk-lib/aws-apigateway');
class HelloLambdaStack extends Stack {
/**
*
* @param {Construct} scope
* @param {string} id
* @param {StackProps=} props
*/
constructor(scope, id, props) {
super(scope, id, props);
const fn = new lambda.Function(this, 'MyFunction', {
code: lambda.Code.fromAsset('lib/lambda-handler'),
runtime: lambda.Runtime.NODEJS_LATEST,
handler: 'index.handler'
});
const endpoint = new apigw.LambdaRestApi(this, 'MyEndpoint', {
handler: fn,
restApiName: "HelloApi"
});
}
}
module.exports = { HelloLambdaStack }
```
------
#### [ TypeScript ]
Reemplace el contenido del archivo `lib/hello-lambda-stack.ts` por lo siguiente.
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as apigw from "aws-cdk-lib/aws-apigateway";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as path from 'node:path';
export class HelloLambdaStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps){
super(scope, id, props)
const fn = new lambda.Function(this, 'MyFunction', {
runtime: lambda.Runtime.NODEJS_LATEST,
handler: 'index.handler',
code: lambda.Code.fromAsset(path.join(__dirname, 'lambda-handler')),
});
const endpoint = new apigw.LambdaRestApi(this, `ApiGwEndpoint`, {
handler: fn,
restApiName: `HelloApi`,
});
}
}
```
------
#### [ Python ]
Reemplace el contenido del archivo `/hello-lambda/hello_lambda/hello_lambda_stack.py` por lo siguiente.
```
from aws_cdk import (
Stack,
aws_apigateway as apigw,
aws_lambda as _lambda
)
from constructs import Construct
class HelloLambdaStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
fn = _lambda.Function(
self,
"MyFunction",
runtime=_lambda.Runtime.NODEJS_LATEST,
handler="index.handler",
code=_lambda.Code.from_asset("lib/lambda-handler")
)
endpoint = apigw.LambdaRestApi(
self,
"ApiGwEndpoint",
handler=fn,
rest_api_name="HelloApi"
)
```
------
#### [ Java ]
Reemplace el contenido del archivo `/hello-lambda/src/main/java/com/myorg/HelloLambdaStack.java` por lo siguiente.
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.apigateway.LambdaRestApi;
import software.amazon.awscdk.services.lambda.Function;
public class HelloLambdaStack extends Stack {
public HelloLambdaStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloLambdaStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
Function hello = Function.Builder.create(this, "MyFunction")
.runtime(software.amazon.awscdk.services.lambda.Runtime.NODEJS_LATEST)
.code(software.amazon.awscdk.services.lambda.Code.fromAsset("lib/lambda-handler"))
.handler("index.handler")
.build();
LambdaRestApi api = LambdaRestApi.Builder.create(this, "ApiGwEndpoint")
.restApiName("HelloApi")
.handler(hello)
.build();
}
}
```
------
#### [ C\$1 ]
Reemplace el contenido del archivo `src/HelloLambda/HelloLambdaStack.cs` por lo siguiente.
```
using Amazon.CDK;
using Amazon.CDK.AWS.APIGateway;
using Amazon.CDK.AWS.Lambda;
using Constructs;
namespace HelloLambda
{
public class HelloLambdaStack : Stack
{
internal HelloLambdaStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var fn = new Function(this, "MyFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_LATEST,
Code = Code.FromAsset("lib/lambda-handler"),
Handler = "index.handler"
});
var api = new LambdaRestApi(this, "ApiGwEndpoint", new LambdaRestApiProps
{
Handler = fn
});
}
}
}
```
------
## Paso 3: creación del código de la función de Lambda
1. Desde la raíz del proyecto (`hello-lambda`), cree el directorio `/lib/lambda-handler` para el código de la función de Lambda. Este directorio se especifica en la propiedad `code` de la pila de AWS CDK.
1. En el directorio `index.js`, cree un archivo con el nombre `/lib/lambda-handler`. Pegue el código siguiente en el archivo. La función extrae propiedades específicas de la solicitud de API y las devuelve como una respuesta JSON.
```
exports.handler = async (event) => {
// Extract specific properties from the event object
const { resource, path, httpMethod, headers, queryStringParameters, body } = event;
const response = {
resource,
path,
httpMethod,
headers,
queryStringParameters,
body,
};
return {
body: JSON.stringify(response, null, 2),
statusCode: 200,
};
};
```
## Paso 4: implementación de la pila de AWS CDK
1. Desde la raíz del proyecto, ejecute el comando [cdk synth](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-synth.html):
```
cdk synth
```
Este comando sintetiza una plantilla AWS CloudFormation de la pila de CDK. La plantilla es un archivo YAML de aproximadamente 400 líneas, similar al siguiente.
**nota**
Si aparece el siguiente error, asegúrese de que está en la raíz del directorio del proyecto.
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
**Example CloudFormationPlantilla de**
```
Resources:
MyFunctionServiceRole3C357FF2:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action: sts:AssumeRole
Effect: Allow
Principal:
Service: lambda.amazonaws.com
Version: "2012-10-17"
ManagedPolicyArns:
- Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Metadata:
aws:cdk:path: HelloLambdaStack/MyFunction/ServiceRole/Resource
MyFunction1BAA52E7:
Type: AWS::Lambda::Function
Properties:
Code:
S3Bucket:
Fn::Sub: cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}
S3Key: ab1111111cd32708dc4b83e81a21c296d607ff2cdef00f1d7f48338782f92l3901.zip
Handler: index.handler
Role:
Fn::GetAtt:
- MyFunctionServiceRole3C357FF2
- Arn
Runtime: nodejs24.x
...
```
1. Ejecute el comando [cdk deploy](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-deploy.html):
```
cdk deploy
```
Espere a que se creen sus recursos. El resultado final incluye la URL de su punto de conexión de API Gateway. Ejemplo:
```
Outputs:
HelloLambdaStack.ApiGwEndpoint77F417B1 = https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/
```
## Paso 5: prueba de la función
Para invocar la función de Lambda, copie el punto de conexión de API Gateway y péguelo en un navegador web o ejecute un comando `curl`:
```
curl -s https://abcd1234.execute-api.us-east-1.amazonaws.com/prod/
```
La respuesta es una representación en JSON de las propiedades seleccionadas del objeto de evento original, que contiene información sobre la solicitud hecha al punto de conexión de API Gateway. Ejemplo:
```
{
"resource": "/",
"path": "/",
"httpMethod": "GET",
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
"Accept-Encoding": "gzip, deflate, br, zstd",
"Accept-Language": "en-US,en;q=0.9",
"CloudFront-Forwarded-Proto": "https",
"CloudFront-Is-Desktop-Viewer": "true",
"CloudFront-Is-Mobile-Viewer": "false",
"CloudFront-Is-SmartTV-Viewer": "false",
"CloudFront-Is-Tablet-Viewer": "false",
"CloudFront-Viewer-ASN": "16509",
"CloudFront-Viewer-Country": "US",
"Host": "abcd1234.execute-api.us-east-1.amazonaws.com",
...
```
## Paso 6: Eliminar los recursos
El punto de conexión de API Gateway es de acceso público. Para evitar cargos inesperados, ejecute el comando [cdk destroy](https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-destroy.html) para eliminar la pila y todos los recursos asociados.
```
cdk destroy
```
## Siguientes pasos
Para obtener información sobre cómo escribir aplicaciones de AWS CDK en el lenguaje de su elección, consulte:
------
#### [ TypeScript ]
[Utilización del AWS CDK en TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html)
------
#### [ JavaScript ]
[Utilización del AWS CDK en JavaScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html)
------
#### [ Python ]
[Utilización del AWS CDK en Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
------
#### [ Java ]
[Utilización del AWS CDK en Java](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html)
------
#### [ C\$1 ]
[Utilización del AWS CDK en C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
------
#### [ Go ]
[Uso del AWS CDK en Go](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-go.html)
------