Asignaciones de orígenes de eventos con funciones duraderas

Las funciones duraderas funcionan con todas las asignaciones de orígenes de eventos de Lambda. Configure las asignaciones de orígenes de eventos para funciones duraderas del mismo modo que las configura para funciones estándar. Las asignaciones de orígenes de eventos sondean automáticamente los orígenes de eventos, como Amazon SQS, Kinesis y DynamoDB Streams, e invocan su función con lotes de registros.

Las asignaciones de orígenes de eventos son útiles para funciones duraderas que procesan flujos o colas con flujos de trabajo complejos de varios pasos. Por ejemplo, puede crear una función duradera que procese los mensajes de Amazon SQS con reintentos, llamadas a la API externas y aprobaciones humanas.

Cómo invocar asignaciones de orígenes de eventos con funciones duraderas

Las asignaciones de orígenes de eventos invocan funciones duraderas de forma sincrónica; por ello, esperan a que finalice la ejecución duradera completa antes de procesar el siguiente lote o marcar los registros como procesados. Si el tiempo total de la ejecución duradera supera los 15 minutos, se agota el tiempo de espera de la ejecución y se produce un error. La asignación de orígenes de eventos recibe una excepción de tiempo de espera y la gestiona de acuerdo con su configuración de reintentos.

Límite de ejecución de 15 minutos

Cuando las asignaciones de orígenes de eventos invocan funciones duraderas, la duración total de la ejecución duradera no puede superar los 15 minutos. Este límite se aplica a toda la ejecución duradera, desde el principio hasta la finalización, no solo a las invocaciones de funciones individuales.

Este límite de 15 minutos es independiente del tiempo de espera de la función de Lambda (también 15 minutos como máximo). El tiempo de espera de la función controla cuánto tiempo puede ejecutarse cada invocación individual, mientras que el tiempo de espera de la ejecución duradera controla el tiempo total transcurrido desde el inicio de la ejecución hasta su finalización.

Ejemplos de escenarios:

Configuración de asignaciones de orígenes de eventos

Configure las asignaciones de orígenes de eventos para funciones duraderas mediante la consola Lambda, la AWS CLI, o los AWS SDK. Todas las propiedades de la asignación de orígenes de eventos estándar se aplican a las funciones duraderas:

aws lambda create-event-source-mapping \
  --function-name arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1 \
  --event-source-arn arn:aws:sqs:us-east-1:123456789012:my-queue \
  --batch-size 10 \
  --maximum-batching-window-in-seconds 5
    

Recuerde utilizar un ARN calificado (con número de versión o alias) cuando configure las asignaciones de orígenes de eventos para funciones duraderas.

Gestión de errores con asignaciones de orígenes de eventos

Las asignaciones de orígenes de eventos proporcionan una gestión de errores integrada compatible con funciones duraderas:

Para obtener información completa sobre la gestión de errores en la asignación de orígenes de eventos, consulte la asignación de orígenes de eventos.

Uso de una función intermedia para flujos de trabajo de larga duración

Si el flujo de trabajo requiere más de 15 minutos para completarse, utilice una función estándar intermedia de Lambda entre la asignación de orígenes de eventos y su función duradera. La función intermedia recibe los eventos de la asignación de orígenes de eventos e invoca la función duradera de forma asíncrona, lo que elimina el límite de ejecución de 15 minutos.

Este patrón desacopla el modelo de invocación sincrónica de la asignación de orígenes de eventos del modelo de ejecución de larga duración de la función duradera. La asignación de orígenes de eventos invoca la función intermedia, que regresa rápidamente después de iniciar la ejecución duradera. A continuación, la función duradera se ejecuta de forma independiente durante el tiempo que sea necesario (hasta 1 año).

Arquitectura

El patrón de funciones intermedias utiliza tres componentes:

Implementación

La función intermedia recibe el evento completo de la asignación de orígenes de eventos e invoca la función duradera de forma asíncrona. Utilice el parámetro del nombre de la ejecución para garantizar que se inicie una ejecución idempotente, lo que evitará que se duplique el procesamiento si la asignación de orígenes de eventos hace un reintento:

TypeScript

import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
import { SQSEvent } from 'aws-lambda';
import { createHash } from 'crypto';

const lambda = new LambdaClient({});

export const handler = async (event: SQSEvent) => {
  // Invoke durable function asynchronously with execution name
  await lambda.send(new InvokeCommand({
    FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
    InvocationType: 'Event',
    Payload: JSON.stringify({
      executionName: event.Name,
      event: event
    })
  }));
  
  return { statusCode: 200 };
};
            

Python

import boto3
import json
import hashlib

lambda_client = boto3.client('lambda')

def handler(event, context):  
    # Invoke durable function asynchronously with execution name
    lambda_client.invoke(
        FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
        InvocationType='Event',
        Payload=json.dumps({
            'executionName': execution_name,
            'event': event["name"]
        })
    )
    
    return {'statusCode': 200}
            

En el caso de la idempotencia en la propia función intermedia, utilice Powertools para AWS Lambda para evitar que se dupliquen las invocaciones de la función duradera si la asignación de orígenes de eventos reintenta la función intermedia.

La función duradera recibe la carga útil con el nombre de la ejecución y procesa todos los registros con una lógica de larga duración:

TypeScript

import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';

export const handler = withDurableExecution(
  async (payload: any, context: DurableContext) => {
    const sqsEvent = payload.event;
    
    // Process each record with complex, multi-step logic
    const results = await context.map(
      sqsEvent.Records,
      async (ctx, record) => {
        const validated = await ctx.step('validate', async () => {
          return validateOrder(JSON.parse(record.body));
        });
        
        // Wait for external approval (could take hours or days)
        const approval = await ctx.waitForCallback(
          'approval',
          async (callbackId) => {
            await requestApproval(callbackId, validated);
          },
          { timeout: { hours: 48 } }
        );
        
        // Complete processing
        return await ctx.step('complete', async () => {
          return completeOrder(validated, approval);
        });
      }
    );
    
    return { statusCode: 200, processed: results.getResults().length };
  }
);
            

Python

from aws_durable_execution_sdk_python import durable_execution, DurableContext
import json

@durable_execution
def handler(payload, context: DurableContext):
    sqs_event = payload['event']
    
    # Process each record with complex, multi-step logic
    def process_record(ctx, record):
        validated = ctx.step(
            lambda _: validate_order(json.loads(record['body'])),
            name='validate'
        )
        
        # Wait for external approval (could take hours or days)
        approval = ctx.wait_for_callback(
            lambda callback_id: request_approval(callback_id, validated),
            name='approval',
            config=WaitForCallbackConfig(timeout_seconds=172800)  # 48 hours
        )
        
        # Complete processing
        return ctx.step(
            lambda _: complete_order(validated, approval),
            name='complete'
        )
    
    results = context.map(sqs_event['Records'], process_record)
    
    return {'statusCode': 200, 'processed': len(results.get_results())}
            

Consideraciones clave

Este patrón elimina el límite de ejecución de 15 minutos al desvincular la asignación de orígenes de eventos de la ejecución duradera. La función intermedia regresa inmediatamente después de iniciar la ejecución duradera, lo que permite que la asignación de orígenes de eventos continúe procesándose. A continuación, la función duradera se ejecuta de forma independiente durante el tiempo que sea necesario.

La función intermedia tiene éxito cuando invoca la función duradera, no cuando se completa la ejecución duradera. Si la ejecución duradera falla más adelante, la asignación de orígenes de eventos no hará un reintento porque ya procesó el lote correctamente. Implemente la gestión de errores en la función duradera y configure las colas de mensajes fallidos para las ejecuciones fallidas.

Utilice el parámetro del nombre de la ejecución para garantizar que se inicie una ejecución idempotente. Si la asignación de orígenes de eventos reintenta la función intermedia, la función duradera no iniciará una ejecución duplicada porque el nombre de la ejecución ya existe.

Orígenes de eventos compatibles

Las funciones duraderas admiten todos los orígenes de eventos de Lambda que utilizan asignaciones de orígenes de eventos:

Todos los tipos de orígenes de eventos están sujetos al límite de ejecución duradera de 15 minutos cuando se invocan funciones duraderas.