Cree aplicaciones de varios pasos y flujos de trabajo de IA con funciones duraderas de AWS Lambda | Servicios web de Amazon

Las aplicaciones modernas requieren cada vez más una coordinación compleja y de larga duración entre servicios, como el procesamiento de pagos en varios pasos, la orquestación de agentes de IA o procesos de aprobación en espera de decisiones humanas. Construirlos tradicionalmente requería un esfuerzo significativo para implementar la gestión estatal, manejar fallas e integrar múltiples servicios de infraestructura.

A partir de hoy, puede utilizar las funciones duraderas de AWS Lambda para crear aplicaciones confiables de varios pasos directamente dentro de la experiencia familiar de AWS Lambda. Las funciones duraderas son funciones Lambda normales con el mismo controlador de eventos e integraciones que ya conoce. Usted escribe código secuencial en su lenguaje de programación preferido y las funciones duraderas rastrean el progreso, reintentan automáticamente las fallas y suspenden la ejecución por hasta un año en puntos definidos, sin pagar por el cómputo inactivo durante las esperas.

Las funciones duraderas de AWS Lambda utilizan un mecanismo de punto de control y reproducción, conocido como ejecución duradera, para ofrecer estas capacidades. Después de habilitar una función para ejecución duradera, agrega el nuevo SDK de ejecución duradera de código abierto a su código de función. Luego, utiliza primitivas del SDK como «pasos» para agregar puntos de control automáticos y reintentos a su lógica de negocios y «esperas» para suspender la ejecución de manera eficiente sin cargos de cómputo. Cuando la ejecución finaliza inesperadamente, Lambda se reanuda desde el último punto de control, reproduciendo el controlador de eventos desde el principio y omitiendo las operaciones completadas.

Introducción a las funciones duraderas de AWS Lambda

Déjame explicarte cómo utilizar funciones duraderas.

Primero, creo una nueva función Lambda en la consola y selecciono Autor desde cero. En el Ejecución duradera sección, selecciono Permitir. Tenga en cuenta que la configuración de función duradera solo se puede establecer durante la creación de la función y actualmente no se puede modificar para funciones Lambda existentes.

Después de crear mi función duradera de Lambda, puedo comenzar con el código proporcionado.

Las funciones duraderas de Lambda presentan dos primitivas centrales que manejan la gestión y la recuperación del estado:

• Pasos-El context.step() El método agrega reintentos automáticos y puntos de control a su lógica empresarial. Una vez completado un paso, se omitirá durante la repetición.
• Esperar-El context.wait() El método pausa la ejecución durante un período específico, finaliza la función, suspende y reanuda la ejecución sin cargos de cálculo.

Además, las funciones duraderas de Lambda proporcionan otras operaciones para patrones más complejos: create_callback() crea una devolución de llamada que puede usar para esperar resultados de eventos externos como respuestas API o aprobaciones humanas, wait_for_condition() se detiene hasta que se cumple una condición específica, como sondear una API REST para completar el proceso, y parallel() o map() operaciones para casos de uso de concurrencia avanzada.

Creación de un flujo de trabajo de procesamiento de pedidos listo para producción

Ahora ampliemos el ejemplo predeterminado para crear un flujo de trabajo de procesamiento de pedidos listo para producción. Esto demuestra cómo utilizar devoluciones de llamada para aprobaciones externas, manejar errores correctamente y configurar estrategias de reintento. Mantengo el código intencionalmente conciso para centrarme en estos conceptos centrales. En una implementación completa, podría mejorar el paso de validación con Amazon Bedrock para agregar análisis de pedidos impulsado por IA.

Así es como funciona el flujo de trabajo de procesamiento de pedidos:

• Primero, validate_order() comprueba los datos del pedido para garantizar que todos los campos obligatorios estén presentes.
• Próximo, send_for_approval() envía la orden para la aprobación humana externa y espera una respuesta de devolución de llamada, suspendiendo la ejecución sin cargos informáticos.
• Entonces, process_order() completa el procesamiento del pedido.
• A lo largo del flujo de trabajo, el manejo de errores try-catch distingue entre errores de terminal que detienen la ejecución inmediatamente y errores recuperables dentro de los pasos que activan reintentos automáticos.

Aquí está el flujo de trabajo completo de procesamiento de pedidos con definiciones de pasos y el controlador principal:

import random
from aws_durable_execution_sdk_python import (
    DurableContext,
    StepContext,
    durable_execution,
    durable_step,
)
from aws_durable_execution_sdk_python.config import (
    Duration,
    StepConfig,
    CallbackConfig,
)
from aws_durable_execution_sdk_python.retries import (
    RetryStrategyConfig,
    create_retry_strategy,
)


@durable_step
def validate_order(step_context: StepContext, order_id: str) -> dict:
    """Validates order data using AI."""
    step_context.logger.info(f"Validating order: {order_id}")
    # In production: calls Amazon Bedrock to validate order completeness and accuracy
    return {"order_id": order_id, "status": "validated"}


@durable_step
def send_for_approval(step_context: StepContext, callback_id: str, order_id: str) -> dict:
    """Sends order for approval using the provided callback token."""
    step_context.logger.info(f"Sending order {order_id} for approval with callback_id: {callback_id}")
    
    # In production: send callback_id to external approval system
    # The external system will call Lambda SendDurableExecutionCallbackSuccess or
    # SendDurableExecutionCallbackFailure APIs with this callback_id when approval is complete
    
    return {
        "order_id": order_id,
        "callback_id": callback_id,
        "status": "sent_for_approval"
    }


@durable_step
def process_order(step_context: StepContext, order_id: str) -> dict:
    """Processes the order with retry logic for transient failures."""
    step_context.logger.info(f"Processing order: {order_id}")
    # Simulate flaky API that sometimes fails
    if random.random() > 0.4:
        step_context.logger.info("Processing failed, will retry")
        raise Exception("Processing failed")
    return {
        "order_id": order_id,
        "status": "processed",
        "timestamp": "2025-11-27T10:00:00Z",
    }


@durable_execution
def lambda_handler(event: dict, context: DurableContext) -> dict:
    try:
        order_id = event.get("order_id")
        
        # Step 1: Validate the order
        validated = context.step(validate_order(order_id))
        if validated["status"] != "validated":
            raise Exception("Validation failed")  # Terminal error - stops execution
        context.logger.info(f"Order validated: {validated}")
        
        # Step 2: Create callback
        callback = context.create_callback(
            name="awaiting-approval",
            config=CallbackConfig(timeout=Duration.from_minutes(3))
        )
        context.logger.info(f"Created callback with id: {callback.callback_id}")
        
        # Step 3: Send for approval with the callback_id
        approval_request = context.step(send_for_approval(callback.callback_id, order_id))
        context.logger.info(f"Approval request sent: {approval_request}")
        
        # Step 4: Wait for the callback result
        # This blocks until external system calls SendDurableExecutionCallbackSuccess or SendDurableExecutionCallbackFailure
        approval_result = callback.result()
        context.logger.info(f"Approval received: {approval_result}")
        
        # Step 5: Process the order with custom retry strategy
        retry_config = RetryStrategyConfig(max_attempts=3, backoff_rate=2.0)
        processed = context.step(
            process_order(order_id),
            config=StepConfig(retry_strategy=create_retry_strategy(retry_config)),
        )
        if processed["status"] != "processed":
            raise Exception("Processing failed")  # Terminal error
        
        context.logger.info(f"Order successfully processed: {processed}")
        return processed
        
    except Exception as error:
        context.logger.error(f"Error processing order: {error}")
        raise error  # Re-raise to fail the execution

Este código demuestra varios conceptos importantes:

• Manejo de errores—El bloque try-catch maneja errores de terminal. Cuando se genera una excepción no controlada fuera de un paso (como la verificación de validación), la ejecución finaliza inmediatamente. Esto es útil cuando no tiene sentido volver a intentarlo, como en el caso de datos de pedido no válidos.
• Reintentos de paso—Dentro del process_order paso, las excepciones activan reintentos automáticos basados ​​en el valor predeterminado (paso 1) o configurado RetryStrategy (paso 5). Esto maneja fallas transitorias como la falta de disponibilidad temporal de API.
• Explotación florestal—Yo uso context.logger para el manejador principal y step_context.logger pasos interiores. El registrador de contexto suprime los registros duplicados durante la reproducción.

Ahora creo un evento de prueba con order_id e invocar la función de forma asincrónica para iniciar el flujo de trabajo del pedido. navego hasta el Prueba y complete el campo opcional Nombre de ejecución duradero para identificar esta ejecución. Tenga en cuenta que las funciones duraderas proporcionan idempotencia incorporada. Si invoco la función dos veces con el mismo nombre de ejecución, la segunda invocación devuelve el resultado de la ejecución existente en lugar de crear un duplicado.

Puedo monitorear la ejecución navegando a la Ejecuciones duraderas pestaña en la consola Lambda:

Aquí puedo ver el estado y el tiempo de cada paso. La ejecución muestra CallbackStarted seguido por InvocationCompletedque indica que la función ha finalizado y la ejecución se suspende para evitar cargos inactivos mientras se espera la devolución de llamada de aprobación.

Ahora puedo completar la devolución de llamada directamente desde la consola eligiendo Enviar éxito o Enviar erroro mediante programación utilizando la API Lambda.

yo elijo Enviar éxito.

Una vez completada la devolución de llamada, la ejecución se reanuda y procesa la orden. si el process_order El paso falla debido a la API inestable simulada, lo reintenta automáticamente según la estrategia configurada. Una vez que todos los reintentos tienen éxito, la ejecución se completa exitosamente.

Monitoreo de ejecuciones con Amazon EventBridge

También puede monitorear ejecuciones de funciones duraderas mediante Amazon EventBridge. Lambda envía automáticamente eventos de cambio de estado de ejecución al bus de eventos predeterminado, lo que le permite crear flujos de trabajo posteriores, enviar notificaciones o integrarse con otros servicios de AWS.

Para recibir estos eventos, cree una regla EventBridge en el bus de eventos predeterminado con este patrón:

{
  "source": ["aws.lambda"],
  "detail-type": ["Durable Execution Status Change"]
}

Cosas que debes saber

Aquí hay puntos clave a tener en cuenta:

• Disponibilidad—Las funciones duraderas de Lambda ahora están disponibles en la región AWS de EE. UU. Este (Ohio). Para conocer la disponibilidad más reciente de la región, visite el Capacidades de AWS por región página.
• Soporte de lenguaje de programación—En el lanzamiento, las funciones duraderas de AWS Lambda son compatibles con JavaScript/TypeScript (Node.js 22/24) y Python (3.13/3.14). Recomendamos empaquetar el SDK de ejecución duradera con su código de función utilizando su administrador de paquetes preferido. Los SDK cambian rápidamente, por lo que puede actualizar fácilmente las dependencias a medida que haya nuevas funciones disponibles.
• Usando versiones Lambda—Al implementar funciones duraderas en producción, utilice versiones Lambda para garantizar que la reproducción siempre se realice en la misma versión del código. Si actualiza el código de su función mientras una ejecución está suspendida, la reproducción utilizará la versión que inició la ejecución, evitando inconsistencias por cambios de código durante flujos de trabajo de larga duración.
• Probando sus funciones duraderas—Puede probar funciones duraderas localmente sin credenciales de AWS utilizando el SDK de prueba independiente con integración de pytest y la interfaz de línea de comandos (CLI) del modelo de aplicación sin servidor de AWS (AWS SAM) para pruebas de integración más complejas.
• SDK de código abierto—Los SDK de ejecución duradera son de código abierto para JavaScript/Mecanografiado y Pitón. Puede revisar el código fuente, contribuir con mejoras y mantenerse actualizado con las últimas funciones.
• Precios—Para obtener más información sobre los precios de las funciones duraderas de AWS Lambda, consulte la página de precios de AWS Lambda.

Comience con las funciones duraderas de AWS Lambda visitando la consola de AWS Lambda. Para obtener más información, consulte la página de documentación de funciones duraderas de AWS Lambda.

¡Feliz edificio!

— donnie