# Creación de funciones duraderas de Lambda Para iniciarte en las funciones duraderas de Lambda, utiliza la consola de Lambda para crear una función duradera. En unos minutos, puede crear e implementar una función duradera que utilice pasos y esperas para demostrar la ejecución basada en puntos de control. A medida que realice el tutorial, aprenderá conceptos fundamentales sobre funciones duraderas, por ejemplo, cómo usar el objeto `DurableContext`, crear puntos de control mediante pasos y pausar la ejecución mediante esperas. También obtendrá información sobre cómo funciona la reproducción cuando la función se reanuda tras una espera. Para simplificar, este tutorial muestra cómo crear su función con el tiempo de ejecución de Python o Node.js. Con estos lenguajes interpretados, puede editar el código de función directamente en el editor de código integrado en la consola. Actualmente, las funciones duraderas en Java (versión preliminar) solo pueden implementarse mediante imágenes de contenedor. Para obtener más información sobre cómo crear funciones duraderas a partir de imágenes de contenedor, consulte [Tiempos de ejecución compatibles para funciones duraderas](durable-supported-runtimes.md) o [Implementar funciones duraderas de Lambda con infraestructura como código](durable-getting-started-iac.md). **nota** Actualmente, las funciones duraderas admiten tiempos de ejecución administrados de Python y Node.js (JavaScript/TypeScript) e imágenes de contenedor (OCI), como Java. Para obtener una lista completa de las versiones de tiempo de ejecución compatibles y las opciones de imágenes de contenedores, consulte [Tiempos de ejecución compatibles para funciones duraderas](durable-supported-runtimes.md). Para obtener más información acerca del uso de imágenes de contenedor con Lambda, consulte [Creación de imágenes de contenedor](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) en la Guía para desarrolladores de Lambda. **sugerencia** Para obtener información sobre cómo crear **soluciones sin servidor**, consulte la [Guía para desarrolladores sin servidor](https://docs.aws.amazon.com/serverless/latest/devguide/). ## Requisitos previos ### Cómo crear una Cuenta de AWS Si no dispone de una Cuenta de AWS, siga estos pasos para crear una. **Cómo registrarse en Cuenta de AWS** 1. Abra [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup). 1. Siga las instrucciones que se le indiquen. Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono. Al registrarse en una Cuenta de AWS, se crea un *Usuario raíz de la cuenta de AWS*. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [Tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS le enviará un correo electrónico de confirmación cuando complete el proceso de registro. Se puede ver la actividad de la cuenta y administrarla en cualquier momento entrando en [https://aws.amazon.com/](https://aws.amazon.com/) y seleccionando **Mi cuenta**. ### Creación de un usuario con acceso administrativo Después de registrarse para obtener una Cuenta de AWS, proteja su Usuario raíz de la cuenta de AWS, habilite AWS IAM Identity Center y cree un usuario administrativo para no usar el usuario raíz en las tareas cotidianas. **Protección de Usuario raíz de la cuenta de AWS** 1. Inicie sesión en [Consola de administración de AWS](https://console.aws.amazon.com/) como propietario de la cuenta; para ello, elija **Usuario raíz** e introduzca el correo electrónico de su Cuenta de AWS. En la siguiente página, escriba su contraseña. Para obtener ayuda para iniciar sesión con el usuario raíz, consulte [Iniciar sesión como usuario raíz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) en la *Guía del usuario de AWS Sign-In*. 1. Active la autenticación multifactor (MFA) para el usuario raíz. Para obtener instrucciones, consulte [Habilitación de un dispositivo MFA virtual para su usuario raíz de la Cuenta de AWS (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) en la *Guía del usuario de IAM*. **Creación de un usuario con acceso administrativo** 1. Activar IAM Identity Center. Consulte las instrucciones en [Activar AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) en la *Guía del usuario de AWS IAM Identity Center*. 1. En IAM Identity Center, conceda acceso administrativo a un usuario. Para ver un tutorial sobre cómo usar Directorio de IAM Identity Center como origen de identidad, consulte [Configuración del acceso de los usuarios con el Directorio de IAM Identity Center predeterminado](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) en la *Guía del usuario de AWS IAM Identity Center*. **Inicio de sesión como usuario con acceso de administrador** + Para iniciar sesión con el usuario de IAM Identity Center, use la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center. Para obtener ayuda para iniciar sesión con un usuario de IAM Identity Center, consulte [Inicio de sesión en el portal de acceso de AWS](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) en la *Guía del usuario de AWS Sign-In*. **Concesión de acceso a usuarios adicionales** 1. En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos. Para conocer las instrucciones, consulte [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) en la *Guía del usuario de AWS IAM Identity Center*. 1. Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo. Para conocer las instrucciones, consulte [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) en la *Guía del usuario de AWS IAM Identity Center*. ## Creación de una función duradera de Lambda con la consola En este ejemplo, la función duradera procesa un pedido en varios pasos con creación automática de puntos de control. La función toma un objeto de JSON que contiene un identificador de pedido, lo valida, procesa el pago y lo confirma. Cada paso atraviesa automáticamente por un punto de control, por lo que, si la función se interrumpe, se reanudará desde el último paso completado. La función también muestra una operación de espera, en la que se pausa la ejecución durante un breve período para simular la espera de una confirmación externa. **Cómo crear una función duradera con la consola** 1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda. 1. Seleccione **Creación de función**. 1. Seleccione **Crear desde cero**. 1. En el panel de **Información básica**, ingrese `myDurableFunction` para el **Nombre de la función**. 1. En **Tiempo de ejecución**, elija **Node.js 24** o **Python 3.14**. 1. Seleccione **Habilitar la ejecución duradera**. Lambda crea la función duradera con un [rol de ejecución](lambda-intro-execution-role.md) que incluye permisos para las operaciones de puntos de control (`lambda:CheckpointDurableExecutions` y `lambda:GetDurableExecutionState`). **nota** Los tiempos de ejecución de Lambda incluyen el SDK de ejecución duradera, por lo que puede probar funciones duraderas sin empaquetar dependencias. Sin embargo, le recomendamos incluir el SDK en su paquete de implementación para producción. Esto garantiza la coherencia de las versiones y evita posibles actualizaciones del tiempo de ejecución que podrían afectar su función. Para añadir el código de la función duradera, utilice el editor de código integrado en la consola. ------ #### [ Node.js ] **Modificación del código en la consola** 1. Elija la pestaña **Código**. En el editor de código integrado de la consola, debería ver el código de función que creó Lambda. Si no ve la pestaña **index.mjs** en el editor de código, seleccione **index.mjs** en el explorador de archivos, como se muestra en el siguiente diagrama. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/durable-nodejs.png) 1. Pegue el siguiente código en la pestaña **index.mjs**, que reemplaza el código que creó Lambda. ``` import { DurableContext, withDurableExecution, } from "@aws/durable-execution-sdk-js"; export const handler = withDurableExecution( async (event, context) => { const orderId = event.orderId; // Step 1: Validate order const validationResult = await context.step(async (stepContext) => { stepContext.logger.info(`Validating order ${orderId}`); return { orderId, status: "validated" }; }); // Step 2: Process payment const paymentResult = await context.step(async (stepContext) => { stepContext.logger.info(`Processing payment for order ${orderId}`); return { orderId, status: "paid", amount: 99.99 }; }); // Wait for 10 seconds to simulate external confirmation await context.wait({ seconds: 10 }); // Step 3: Confirm order const confirmationResult = await context.step(async (stepContext) => { stepContext.logger.info(`Confirming order ${orderId}`); return { orderId, status: "confirmed" }; }); return { orderId: orderId, status: "completed", steps: [validationResult, paymentResult, confirmationResult] }; } ); ``` 1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) **Descripción del código de función duradera** Antes de avanzar al siguiente paso, observemos el código de función y comprendamos algunos conceptos clave de las funciones duraderas. + El encapsulador de `withDurableExecution`: La función duradera se encapsula con `withDurableExecution`. Este encapsulador permite una ejecución duradera al proporcionar el objeto `DurableContext` y gestionar las operaciones de los puntos de control. + El objeto `DurableContext`: En lugar del contexto estándar de Lambda, la función recibe un `DurableContext`. Este objeto proporciona métodos para operaciones duraderas, como `step()` y `wait()`, que crearán puntos de control. + Pasos y puntos de control: Cada llamada a `context.step()` crea un punto de control antes y después de la ejecución. Si la función se interrumpe, se reanudará desde el último punto de control completado. La función no vuelve a ejecutar los pasos completados. En su lugar, utiliza los resultados almacenados. + Operaciones de espera: La llamada a `context.wait()` detiene la ejecución sin consumir recursos de cómputo. Cuando finaliza la espera, Lambda vuelve a invocar la función y reproduce el registro de puntos de control; de esta manera, sustituye los valores almacenados de los pasos completados. + Mecanismo de reproducción: Cuando la función se reanuda tras una espera o una interrupción, Lambda ejecuta el código desde el principio. Sin embargo, los pasos completados no se vuelven a ejecutar. Lambda reproduce sus resultados del registro de puntos de control. Por eso su código debe ser determinista. ------ #### [ Python ] **Modificación del código en la consola** 1. Elija la pestaña **Código**. En el editor de código integrado de la consola, debería ver el código de función que creó Lambda. Si no ve la pestaña **lambda\$1function.py** en el editor de código, seleccione **lambda\$1function.py** en el explorador de archivos, como se muestra en el siguiente diagrama. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/durable-python.png) 1. Pegue el siguiente código en la pestaña **lambda\$1function.py**, que reemplaza el código que creó Lambda. ``` from aws_durable_execution_sdk_python import ( DurableContext, durable_execution, durable_step, ) from aws_durable_execution_sdk_python.config import Duration @durable_step def validate_order(step_context, order_id): step_context.logger.info(f"Validating order {order_id}") return {"orderId": order_id, "status": "validated"} @durable_step def process_payment(step_context, order_id): step_context.logger.info(f"Processing payment for order {order_id}") return {"orderId": order_id, "status": "paid", "amount": 99.99} @durable_step def confirm_order(step_context, order_id): step_context.logger.info(f"Confirming order {order_id}") return {"orderId": order_id, "status": "confirmed"} @durable_execution def lambda_handler(event, context: DurableContext): order_id = event['orderId'] # Step 1: Validate order validation_result = context.step(validate_order(order_id)) # Step 2: Process payment payment_result = context.step(process_payment(order_id)) # Wait for 10 seconds to simulate external confirmation context.wait(Duration.from_seconds(10)) # Step 3: Confirm order confirmation_result = context.step(confirm_order(order_id)) return { "orderId": order_id, "status": "completed", "steps": [validation_result, payment_result, confirmation_result] } ``` 1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) **Descripción del código de función duradera** Antes de avanzar al siguiente paso, observemos el código de función y comprendamos algunos conceptos clave de las funciones duraderas. + El decorador `@durable_execution`: Su función de controlador está decorada con `@durable_execution`. Este decorador permite una ejecución duradera porque proporciona el objeto `DurableContext` y administra las operaciones de los puntos de control. + El decorador `@durable_step`: Cada función escalonada está decorada con `@durable_step`. Este decorador marca la función como un paso duradero que crea puntos de control. + El objeto `DurableContext`: En lugar del contexto estándar de Lambda, la función recibe un `DurableContext`. Este objeto proporciona métodos para operaciones duraderas, como `step()` y `wait()`, que crearán puntos de control. + Pasos y puntos de control: Cada llamada a `context.step()` crea un punto de control antes y después de la ejecución. Si la función se interrumpe, se reanudará desde el último punto de control completado. La función no vuelve a ejecutar los pasos completados. En su lugar, utiliza los resultados almacenados. + Operaciones de espera: La llamada a `context.wait()` detiene la ejecución sin consumir recursos de cómputo. Cuando finaliza la espera, Lambda vuelve a invocar la función y reproduce el registro de puntos de control; de esta manera, sustituye los valores almacenados de los pasos completados. + El SDK para Python es sincrónico: Tenga en cuenta que el SDK para Python no utiliza `await`. Todas las operaciones duraderas son llamadas a métodos sincrónicas. ------ ## Invocación de la función de Lambda mediante la consola de editor de código Cuando no se especifica (o publica) ninguna versión explícita, la consola invoca la función duradera mediante el calificador de versión `$LATEST`. Sin embargo, para la ejecución determinista del código, siempre debe utilizar un ARN calificado que apunte a una versión estable. **Cómo publicar una versión de la función:** 1. Elija la pestaña **Versiones**. 1. Elija **Publicar nueva versión**. 1. En **Descripción de la versión**, introduzca **Initial version** (opcional). 1. Elija **Publicar**. 1. Lambda crea la versión 1 de la función. Tenga en cuenta que el ARN de la función ahora incluye `:1` al final, lo que indica que se trata de la versión 1. Ahora cree un evento de prueba a fin de enviarlo a su función. El evento es un documento con formato JSON que contiene un identificador de pedido. **Para crear el evento de prueba, realice lo siguiente:** 1. En la sección **EVENTOS DE PRUEBA** del editor de código de la consola, elija **Crear evento de prueba**. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/test-event.png) 1. Para **Event name (Nombre de evento)**, escriba **myTestEvent**. 1. En la sección **Evento JSON**, sustituya el JSON predeterminado por el siguiente: ``` { "orderId": "order-12345" } ``` 1. Seleccione **Save**. **Cómo probar la función duradera y ver la ejecución** En la sección **EVENTOS DE PRUEBA** del editor de código de la consola, seleccione el ícono de ejecución junto a su evento de prueba: ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png) Su función duradera comienza a ejecutarse. Dado que incluye una espera de 10 segundos, la invocación inicial se completa rápidamente, y la función se reanuda tras el período de espera. Puede ver el progreso de la ejecución en la pestaña **Ejecuciones duraderas**. **Cómo ver la ejecución de función duradera** 1. Seleccione la pestaña **Ejecuciones duraderas**. 1. Busque la ejecución en la lista. La ejecución muestra el estado actual (En ejecución, satisfactoria o fallida). 1. Seleccione el identificador de ejecución para ver los detalles, entre otros los siguientes: + El cronograma de ejecución que muestra cuándo se completó cada paso. + El historial de los puntos de control. + Los períodos de espera. + Los resultados de la prueba. También puede ver los registros de la función en Registros de CloudWatch para ver el resultado de la consola de cada paso. **Visualización de los registros de invocación de la función en Registros de CloudWatch** 1. En la consola de CloudWatch, abra la página [Log groups (grupos de registro)](https://console.aws.amazon.com/cloudwatch/home#logs:). 1. Elija el grupo de registro para la función (`/aws/lambda/myDurableFunction`). 1. Desplácese hacia abajo y seleccione el **flujo de registro** para las invocaciones de la función que desee consultar. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/log-stream.png) Debería ver las entradas de registro de cada invocación de la función, incluidas la ejecución inicial y la reproducción tras la espera. **nota** Cuando se utiliza el registrador de `DurableContext` (por ejemplo, `context.logger` o `stepContext.logger`), los registros también aparecen en las vistas de ejecución duradera y paso a paso de la consola de Lambda. Es posible que estos registros tarden un momento en cargarse. ## Limpieza Cuando haya terminado de trabajar con la función duradera de ejemplo, elimínela. También puede eliminar el [rol de ejecución](lambda-intro-execution-role.md) creado por la consola y el grupo de registro que almacena los registros de la función. **Cómo eliminar la función de Lambda** 1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Seleccione la función que ha creado. 1. Elija **Acciones**, **Eliminar**. 1. Escriba **confirm** en el campo de entrada de texto y elija **Delete**(Eliminar). **Para eliminar el grupo de registros** 1. En la consola de CloudWatch, abra la página [Log groups (Grupos de registro)](https://console.aws.amazon.com/cloudwatch/home#logs:). 1. Seleccione el grupo de registros de la función (`/aws/lambda/myDurableFunction`). 1. Elija **Acciones**, **Eliminar grupo(s) de registro(s)**. 1. En el cuadro de diálogo **Eliminar grupos de registros**, elija **Eliminar**. **Cómo eliminar el rol de ejecución** 1. Abra la página de [Roles](https://console.aws.amazon.com/iam/home?#/roles) de la consola de AWS Identity and Access Management (IAM). 1. Seleccione el rol de ejecución de la función, por ejemplo, ., `myDurableFunction-role-31exxmpl`). 1. Elija **Eliminar**. 1. En el cuadro de diálogo **Eliminar rol**, escriba el nombre del rol y, a continuación, elija **Eliminar**. ## Recursos adicionales y próximos pasos Ahora que ha creado y probado una función duradera simple de Lambda con la consola, siga los pasos a continuación: + Obtenga información sobre los casos de uso más comunes de las funciones duraderas, como las transacciones distribuidas, el procesamiento de pedidos y los flujos de trabajo de revisión humana. Consulte [Ejemplos](durable-examples.md). + Descubra cómo supervisar las ejecuciones de funciones duraderas con las métricas y el historial de ejecución de CloudWatch. Consulte [Supervisión y depuración](durable-monitoring.md). + Obtenga información sobre cómo invocar funciones duraderas de forma sincrónica y asíncrona y cómo administrar las ejecuciones de larga duración. Consulte [Invocación de funciones duraderas](durable-invoking.md). + Siga las prácticas recomendadas para escribir código determinista, administrar el tamaño de los puntos de control y optimizar los costos. Consulte [Prácticas recomendadas](durable-best-practices.md). + Obtenga información sobre cómo probar las funciones duraderas a nivel local y en la nube. Consulte [Prueba de funciones duraderas](durable-testing.md). + Compare las funciones duraderas con Step Functions para comprender cuándo cada enfoque es más eficaz. Consulte [Funciones duraderas o Step Functions](durable-step-functions.md). # Implementación e invocación de funciones duraderas de Lambda con la AWS CLI Utilice la AWS CLI para crear e implementar funciones duraderas de Lambda con comandos imperativos. Este enfoque le brinda un control directo sobre cada paso del proceso de implementación. ## Requisitos previos + Instale y configure la AWS CLI. Para obtener instrucciones, consulte [Instalación de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). + Cree un paquete de implementación con el código de la función y el SDK de ejecución duradera. + Cree un rol de ejecución de IAM con permisos de puntos de control. ## Creación del rol de ejecución Cree un rol de IAM con permisos para las operaciones básicas de ejecución de Lambda y puntos de control. **Para crear el rol de ejecución** 1. Cree un documento de política de confianza que permita que Lambda asuma el rol. Guarde esto como `trust-policy.json`: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` 1. Cree el rol: ``` aws iam create-role \ --role-name durable-function-role \ --assume-role-policy-document file://trust-policy.json ``` 1. Adjunte la política de ejecución duradera para las operaciones de puntos de control y la ejecución básica: ``` aws iam attach-role-policy \ --role-name durable-function-role \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy ``` La política administrada `AWSLambdaBasicDurableExecutionRolePolicy` incluye los permisos necesarios para las operaciones de puntos de control (`lambda:CheckpointDurableExecutions` y `lambda:GetDurableExecutionState`) y la ejecución básica de Lambda. ## Creación de la función duradera Cree la función duradera con el parámetro `--durable-config`. **Cómo crear una función duradera** 1. Empaque el código de función con las dependencias en un archivo.zip: ``` zip -r function.zip index.mjs node_modules/ ``` 1. Cree la función con la ejecución duradera habilitada: ``` aws lambda create-function \ --function-name myDurableFunction \ --runtime nodejs22.x \ --role arn:aws:iam::123456789012:role/durable-function-role \ --handler index.handler \ --zip-file fileb://function.zip \ --durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}' ``` **nota** Solo puede habilitar la ejecución duradera cuando crea la función. No puede habilitarla en las funciones existentes. **nota** Actualmente, las funciones duraderas en Java (versión preliminar) solo pueden crearse mediante imágenes de contenedor. Para obtener más información sobre cómo crear funciones duraderas a partir de imágenes de contenedor, consulte [Tiempos de ejecución compatibles para funciones duraderas.](durable-supported-runtimes.md) ## Publicación de una versión Si bien las funciones duraderas se pueden invocar con el calificador de versión `$LATEST`, siempre debe utilizar un ARN calificado que apunte a una versión estable para garantizar la ejecución determinista del código. ``` aws lambda publish-version \ --function-name myDurableFunction \ --description "Initial version" ``` El comando devuelve el ARN de la versión. Anote el número de versión (por ejemplo, `:1`) al final del ARN. De manera opcional, cree un alias que apunte a la versión: ``` aws lambda create-alias \ --function-name myDurableFunction \ --name prod \ --function-version 1 ``` ## Invocación de la función duradera Invoque la función duradera mediante el ARN calificado (versión o alias). **nota** **Invocaciones idempotentes:** para evitar ejecuciones duplicadas al volver a intentar invocaciones fallidas, puede proporcionar un nombre de ejecución que garantice una semántica de ejecución como máximo una vez. Consulte [Idempotencia](durable-execution-idempotency.md) para obtener más información. **Invocación sincrónica** Para las ejecuciones que se completen en 15 minutos, utilice la invocación sincrónica: ``` aws lambda invoke \ --function-name myDurableFunction:1 \ --payload '{"orderId": "order-12345"}' \ --cli-binary-format raw-in-base64-out \ response.json ``` O use un alias: ``` aws lambda invoke \ --function-name myDurableFunction:prod \ --payload '{"orderId": "order-12345"}' \ --cli-binary-format raw-in-base64-out \ response.json ``` **Invocación asíncrona** Para ejecuciones de larga duración, utilice la invocación asíncrona: ``` aws lambda invoke \ --function-name myDurableFunction:prod \ --invocation-type Event \ --payload '{"orderId": "order-12345"}' \ --cli-binary-format raw-in-base64-out \ response.json ``` Con la invocación asíncrona, Lambda regresa inmediatamente. La función continúa ejecutándose en segundo plano. **nota** Puede utilizar `$LATEST` para crear prototipos y realizar pruebas en la consola. Para las cargas de trabajo de producción, utilice una versión publicada o un alias. ## Administración de ejecuciones duraderas Utilice los siguientes comandos para administrar y supervisar ejecuciones de funciones duraderas. **Enumeración de ejecuciones** Enumere todas las ejecuciones de una función duradera: ``` aws lambda list-durable-executions-by-function \ --function-name myDurableFunction ``` **Detalles de ejecución** Obtenga los detalles sobre una ejecución específica: ``` aws lambda get-durable-execution \ --durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id ``` **Obtención del historial de ejecuciones** Consulte el historial de puntos de control de una ejecución: ``` aws lambda get-durable-execution-history \ --durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id ``` **Detención de una ejecución** Detenga una ejecución duradera en ejecución: ``` aws lambda stop-durable-execution \ --durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id ``` ## Actualizar el código de la función Actualice su código de función duradera y publique una nueva versión: **Cómo actualizar y publicar una nueva versión** 1. Actualice el código de la función: ``` aws lambda update-function-code \ --function-name myDurableFunction \ --zip-file fileb://function.zip ``` 1. Espere a que se complete la actualización: ``` aws lambda wait function-updated \ --function-name myDurableFunction ``` 1. Publique una nueva versión: ``` aws lambda publish-version \ --function-name myDurableFunction \ --description "Updated order processing logic" ``` 1. A continuación, actualice el alias para que apunte a la nueva versión. ``` aws lambda update-alias \ --function-name myDurableFunction \ --name prod \ --function-version 2 ``` **importante** Las ejecuciones en ejecución siguen utilizando la versión con la que empezaron. Las nuevas invocaciones utilizan la versión del alias actualizada. ## Visualización de registros de funciones Consulte los registros de funciones duraderas en Registros de CloudWatch: ``` aws logs tail /aws/lambda/myDurableFunction --follow ``` Filtre los registros para una ejecución específica: ``` aws logs filter-log-events \ --log-group-name /aws/lambda/myDurableFunction \ --filter-pattern "exec-abc123" ``` ## Eliminar recursos Elimine la función duradera y los recursos asociados: ``` # Delete the function aws lambda delete-function --function-name myDurableFunction # Delete the IAM role policies aws iam detach-role-policy \ --role-name durable-function-role \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole aws iam detach-role-policy \ --role-name durable-function-role \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy # Delete the role aws iam delete-role --role-name durable-function-role ``` ## Siguientes pasos Tras implementar la función duradera con la AWS CLI: + Supervise las ejecuciones mediante los comandos `list-durable-executions` y `get-durable-execution`. + Vea las operaciones de los puntos de control en los eventos de datos de AWS CloudTrail. + Configure las alarmas de CloudWatch para los errores de ejecución o las ejecuciones de larga duración. + Automatice las implementaciones mediante scripts de intérprete de comandos o canalizaciones de CI/CD. Para obtener más información sobre los comandos de la AWS CLI en Lambda, consulte la [Referencia de comandos de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html). # Implementación de funciones duraderas de Lambda con la infraestructura como código Puede implementar funciones duraderas de Lambda mediante herramientas de Infraestructura como código (IaC) como AWS CloudFormation, AWS CDK, AWS Serverless Application Model o Terraform. Estas herramientas le permiten definir la función, el rol de ejecución y los permisos en el código, lo que permite que las implementaciones sean repetibles y estén controladas por versiones. Las tres herramientas requieren que haga lo siguiente: + Permita una ejecución duradera de la función. + Conceda permiso para pasar el rol de ejecución. + Publique una versión o cree un alias (las funciones duraderas requieren ARN calificados). ## Funciones duraderas desde un archivo ZIP ### AWS CloudFormation Utilice CloudFormation para definir la función duradera en una plantilla. En el siguiente ejemplo, se crea una función duradera con los permisos necesarios. ``` AWSTemplateFormatVersion: '2010-09-09' Description: Lambda durable function example Resources: DurableFunctionRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Version: '2012-10-17' Statement: - Effect: Allow Principal: Service: lambda.amazonaws.com Action: sts:AssumeRole ManagedPolicyArns: - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy DurableFunction: Type: AWS::Lambda::Function Properties: FunctionName: myDurableFunction Runtime: nodejs22.x Handler: index.handler Role: !GetAtt DurableFunctionRole.Arn Code: ZipFile: | // Your durable function code here export const handler = async (event, context) => { return { statusCode: 200 }; }; DurableConfig: ExecutionTimeout: 3600 RetentionPeriodInDays: 7 DurableFunctionVersion: Type: AWS::Lambda::Version Properties: FunctionName: !Ref DurableFunction Description: Initial version DurableFunctionAlias: Type: AWS::Lambda::Alias Properties: FunctionName: !Ref DurableFunction FunctionVersion: !GetAtt DurableFunctionVersion.Version Name: prod Outputs: FunctionArn: Description: Durable function ARN Value: !GetAtt DurableFunction.Arn AliasArn: Description: Function alias ARN (use this for invocations) Value: !Ref DurableFunctionAlias ``` **Para implementar la plantilla** ``` aws cloudformation deploy \ --template-file template.yaml \ --stack-name my-durable-function-stack \ --capabilities CAPABILITY_IAM ``` ### AWS CDK AWS CDK permite definir la infraestructura mediante lenguajes de programación. En los siguientes ejemplos, se muestra cómo crear una función duradera con TypeScript y Python. ------ #### [ TypeScript ] ``` import * as cdk from 'aws-cdk-lib'; import * as lambda from 'aws-cdk-lib/aws-lambda'; import * as iam from 'aws-cdk-lib/aws-iam'; import { Construct } from 'constructs'; export class DurableFunctionStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // Create the durable function const durableFunction = new lambda.Function(this, 'DurableFunction', { runtime: lambda.Runtime.NODEJS_22_X, handler: 'index.handler', code: lambda.Code.fromAsset('lambda'), functionName: 'myDurableFunction', durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) }, }); // Create version and alias const version = durableFunction.currentVersion; const alias = new lambda.Alias(this, 'ProdAlias', { aliasName: 'prod', version: version, }); // Output the alias ARN new cdk.CfnOutput(this, 'FunctionAliasArn', { value: alias.functionArn, description: 'Use this ARN to invoke the durable function', }); } } ``` ------ #### [ Python ] ``` from aws_cdk import ( Stack, aws_lambda as lambda_, aws_iam as iam, CfnOutput, ) from constructs import Construct class DurableFunctionStack(Stack): def __init__(self, scope: Construct, id: str, **kwargs): super().__init__(scope, id, **kwargs) # Create the durable function durable_function = lambda_.Function( self, 'DurableFunction', runtime=lambda_.Runtime.NODEJS_22_X, handler='index.handler', code=lambda_.Code.from_asset('lambda'), function_name='myDurableFunction', durable_execution={execution_timeout: Duration.hours(1), retention_period: Duration.days(30)} ) # Add durable execution managed policy for checkpoint permissions durable_function.role.add_managed_policy( iam.ManagedPolicy.from_aws_managed_policy_name('service-role/AWSLambdaBasicDurableExecutionRolePolicy') ) # Create version and alias version = durable_function.current_version alias = lambda_.Alias( self, 'ProdAlias', alias_name='prod', version=version ) # Output the alias ARN CfnOutput( self, 'FunctionAliasArn', value=alias.function_arn, description='Use this ARN to invoke the durable function' ) ``` ------ **Cómo implementar la pila de CDK** ``` cdk deploy ``` ### AWS Serverless Application Model AWS SAM simplifica las plantillas de CloudFormation para aplicaciones sin servidor. La siguiente plantilla crea una función duradera con AWS SAM. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: Lambda durable function with SAM Resources: DurableFunction: Type: AWS::Serverless::Function Properties: FunctionName: myDurableFunction Runtime: nodejs22.x Handler: index.handler CodeUri: ./src DurableConfig: ExecutionTimeout: 3600 RetentionPeriodInDays: 7 Policies: - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy AutoPublishAlias: prod Outputs: FunctionArn: Description: Durable function ARN Value: !GetAtt DurableFunction.Arn AliasArn: Description: Function alias ARN (use this for invocations) Value: !Ref DurableFunction.Alias ``` **Cómo implementar la plantilla de SAM** ``` sam build sam deploy --guided ``` ### Terraform Terraform es una popular herramienta de IaC de código abierto que admite recursos de AWS. En el siguiente ejemplo, se crea una función duradera con Terraform mediante la versión 6.25.0 o posterior del proveedor de AWS. ``` terraform { required_version = ">= 1.0" required_providers { aws = { source = "hashicorp/aws" version = ">= 6.25.0" } } } provider "aws" { region = "us-east-2" } # IAM Role for Lambda Function resource "aws_iam_role" "lambda_role" { name = "durable-function-role" assume_role_policy = jsonencode({ Version = "2012-10-17" Statement = [{ Action = "sts:AssumeRole" Effect = "Allow" Principal = { Service = "lambda.amazonaws.com" } }] }) } # Attach durable execution policy for checkpoint operations resource "aws_iam_role_policy_attachment" "lambda_durable" { policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy" role = aws_iam_role.lambda_role.name } # Lambda Function with Durable Execution enabled resource "aws_lambda_function" "durable_function" { filename = "function.zip" function_name = "myDurableFunction" role = aws_iam_role.lambda_role.arn handler = "index.handler" runtime = "nodejs22.x" timeout = 30 memory_size = 512 durable_config { execution_timeout = 900 retention_period = 7 } } # Publish a version resource "aws_lambda_alias" "prod" { name = "prod" function_name = aws_lambda_function.durable_function.function_name function_version = aws_lambda_function.durable_function.version } output "function_arn" { description = "ARN of the Lambda function" value = aws_lambda_function.durable_function.arn } output "alias_arn" { description = "ARN of the function alias (use this for invocations)" value = aws_lambda_alias.prod.arn } ``` **Cómo implementar con Terraform** ``` terraform init terraform plan terraform apply ``` **nota** El soporte de Terraform para las funciones duraderas de Lambda requiere la versión 6.25.0 o posterior del proveedor de AWS. Actualice la versión de su proveedor si está usando una versión antigua. ## Funciones duraderas desde una imagen de contenedor OCI También puede crear funciones duraderas a partir de imágenes de contenedor. Para obtener instrucciones sobre cómo crear una imagen de contenedor, consulte [Tiempos de ejecución compatibles para funciones duraderas.](durable-supported-runtimes.md) ### AWS CDK AWS CDK permite definir la infraestructura mediante lenguajes de programación. En los siguientes ejemplos, se muestra cómo crear una función duradera con TypeScript a partir de una imagen de contenedor. ``` import * as cdk from 'aws-cdk-lib'; import * as lambda from 'aws-cdk-lib/aws-lambda'; import * as iam from 'aws-cdk-lib/aws-iam'; import { Construct } from 'constructs'; export class DurableFunctionStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); // Create the durable function const durableFunction = new lambda.DockerImageFunction(this, 'DurableFunction', { code: lambda.DockerImageCode.fromImageAsset('./lambda', { platform: cdk.aws_ecr_assets.Platform.LINUX_AMD64, }), functionName: 'myDurableFunction', memorySize: 512, timeout: cdk.Duration.seconds(30), durableConfig: { executionTimeout: cdk.Duration.hours(1), retentionPeriod: cdk.Duration.days(30) }, }); // Create version and alias const version = durableFunction.currentVersion; const alias = new lambda.Alias(this, 'ProdAlias', { aliasName: 'prod', version: version, }); // Output the alias ARN new cdk.CfnOutput(this, 'FunctionAliasArn', { value: alias.functionArn, description: 'Use this ARN to invoke the durable function', }); } } ``` **Cómo implementar la pila de CDK** ``` cdk deploy ``` ### AWS Serverless Application Model AWS SAM simplifica las plantillas de CloudFormation para aplicaciones sin servidor. La siguiente plantilla crea una función duradera con AWS SAM. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: Lambda durable function with SAM Resources: DurableFunction: Type: AWS::Serverless::Function Properties: FunctionName: myDurableFunction PackageType: Image ImageUri: ./src DurableConfig: ExecutionTimeout: 3600 RetentionPeriodInDays: 7 Policies: - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy AutoPublishAlias: prod Metadata: DockerTag: latest DockerContext: ./src Dockerfile: Dockerfile Outputs: FunctionArn: Description: Durable function ARN Value: !GetAtt DurableFunction.Arn AliasArn: Description: Function alias ARN (use this for invocations) Value: !Ref DurableFunction.Alias ``` **Cómo implementar la plantilla de SAM** ``` sam build sam deploy --guided ``` ## Patrones de configuración frecuentes Independientemente de la herramienta de IaC que utilice, siga estos patrones para ejecutar funciones duraderas: **Habilitación de la ejecución duradera** Defina la propiedad `DurableConfig` en la función para habilitar una ejecución duradera. Esta propiedad solo está disponible cuando se crea la función. No puede habilitar la ejecución duradera en las funciones existentes. **Concesión de permisos de puntos de control** Adjunte la política administrada de `AWSLambdaBasicDurableExecutionRolePolicy` a su rol de ejecución. Esta política incluye los permisos `lambda:CheckpointDurableExecutions` y `lambda:GetDurableExecutionState` necesarios. **Uso de ARN calificados** Cree una versión o un alias para la función. Las funciones duraderas requieren ARN calificados (con versión o alias) para su invocación. Utilice `AutoPublishAlias` en AWS SAM o cree versiones explícitas en CloudFormation, AWS CDK y Terraform. **Dependencias del paquete** Incluya el SDK de ejecución duradera en su paquete de implementación. En el caso de Node.js, instale `@aws/durable-execution-sdk-js`. En el caso de Python, instale `aws-durable-execution-sdk-python`. ## Siguientes pasos Tras implementar la función duradera: + Pruebe su función con el ARN calificado (versión o alias). + Supervise el progreso de la ejecución en la consola de Lambda en la pestaña Ejecuciones duraderas. + Vea las operaciones de los puntos de control en los eventos de datos de AWS CloudTrail. + Revise Registros de CloudWatch para ver el rendimiento de las funciones y el comportamiento de reproducción. Para obtener más información acerca de cómo implementar funciones de Lambda con herramientas de IaC, consulte: + [CloudFormation Referencia de AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) + [AWS CDK Documentación del módulo de Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) + [AWS SAM Guía para desarrolladores de](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)