Mapeamentos da origem do evento com funções duráveis

As funções duráveis funcionam com todos os mapeamentos da origem do evento do Lambda Configure mapeamentos da origem do evento para funções duráveis da mesma forma que você os configura para funções padrão. Os mapeamentos da origem do evento sondam automaticamente fontes de eventos como o Amazon SQS, o Kinesis e o DynamoDB Streams e invocam sua função com lotes de registros.

Os mapeamentos da origem do evento são úteis para funções duráveis que processem fluxos ou filas com fluxos de trabalho complexos de várias etapas. Por exemplo, é possível criar uma função durável que processe mensagens do Amazon SQS com novas tentativas, chamadas de API externas e aprovações humanas.

Como os mapeamentos da origem do evento invocam as funções duráveis

Os mapeamentos da origem do evento invocam as funções duráveis de forma síncrona, aguardando a conclusão da execução durável completa antes de processar o próximo lote ou marcar os registros como processados. Se o tempo total de execução da função duradoura exceder o limite de tempo de espera aplicável (15 minutos por padrão, ou até 90 minutos para funções executadas em Lambda Managed Instances), a execução será interrompida por tempo de espera e falhará. O mapeamento da origem do evento recebe uma exceção de tempo limite e a trata de acordo com sua configuração de nova tentativa.

Limite de duração da execução

Quando funções duráveis são invocadas por mapeamentos de fontes de eventos, a duração total da execução durável não pode exceder o tempo limite máximo da função: 15 minutos para funções executadas no modo de capacidade padrão (sob demanda) ou até 90 minutos para funções executadas em Lambda Managed Instances (exceto mapeamentos de fontes de eventos do Amazon MQ e do Amazon DocumentDB, que permanecem limitados a 15 minutos). Esse limite se aplica a toda a execução durável, do início à conclusão, e não apenas às invocações de funções individuais.

Esse limite é distinto do tempo limite por invocação da função do Lambda, embora ambos compartilhem o mesmo valor máximo (15 minutos por padrão, ou até 90 minutos em Lambda Managed Instances para invocações assíncronas e de mapeamento de fonte de eventos). O tempo limite da função controla por quanto tempo cada invocação individual pode ser executada, enquanto o tempo limite de execução durável controla o tempo total decorrido do início à conclusão da execução.

Cenários de exemplo:

Configuração de mapeamentos da origem do evento

Configure mapeamentos da origem do evento para funções duráveis usando o console do Lambda, a AWS CLI ou SDKs da AWS. Todas as propriedades padrão do mapeamento da origem do evento se aplicam às funções duráveis:

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
    

Lembre-se de usar um ARN qualificado (com número de versão ou alias) ao configurar mapeamentos da origem do evento para funções duráveis.

Tratamento de erros com o mapeamento da origem do evento

Os mapeamentos da origem do evento fornecem tratamento de erros integrado que funciona com funções duráveis:

Para obter informações completas sobre o tratamento de erros de mapeamento da origem do evento, consulte mapeamentos da origem do evento.

Uso de uma função intermediária para fluxos de trabalho de longa duração

Se o seu fluxo de trabalho exigir um tempo superior ao limite aplicável para o mapeamento da fonte de eventos (15 minutos por padrão, ou 90 minutos em Lambda Managed Instances), utilize uma função do Lambda padrão intermediária entre o mapeamento da fonte de eventos e sua função durável. A função intermediária recebe eventos do mapeamento da origem do evento e invoca a função durável de forma assíncrona, eliminando o limite de duração da execução.

Esse padrão separa o modelo de invocação síncrona do mapeamento da origem do evento do modelo de execução de longa duração da função durável. O mapeamento da origem do evento invoca a função intermediária, que retornará rapidamente após iniciar a execução durável. A função durável então funcionará de forma independente pelo tempo necessário (até 1 ano).

Arquitetura

O padrão da função intermediária usa três componentes:

Implementação

A função intermediária receberá o evento inteiro do mapeamento da origem do evento e invocará a função durável de forma assíncrona. Use o parâmetro do nome da execução para garantir que a execução com idempotência seja iniciada, evitando o processamento duplicado se o mapeamento da origem do evento tentar novamente:

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}
            

Para obter idempotência na própria função intermediária, use o Powertools para AWS Lambda para evitar invocações duplicadas da função durável se o mapeamento da origem do evento tentar novamente a função intermediária.

A função durável receberá a carga com o nome da execução e processará todos os registros com uma lógica de longa duração:

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
from aws_durable_execution_sdk_python.config import Duration, WaitForCallbackConfig
from collections.abc import Sequence
import json

def validate_order(order_data: dict) -> dict:
    """Validate order data - always passes."""
    return order_data

def request_approval(callback_id: str, validated_order: dict) -> None:
    """Request approval for the order - always passes."""
    pass

def complete_order(validated_order: dict, approval_result: str) -> dict:
    """Complete the order processing - always passes."""
    return validated_order

@durable_execution
def lambda_handler(payload, context: DurableContext):
    sqs_event = payload['event']

    def process_record(
        ctx: DurableContext, 
        record: dict, 
        index: int, 
        items: Sequence[dict]
    ) -> dict:
        validated = ctx.step(
            lambda _: validate_order(json.loads(record['body'])),
            name=f'validate-{index}'
        )

        approval = ctx.wait_for_callback(
            submitter=lambda callback_id, wait_ctx: request_approval(callback_id, validated),
            name=f'approval-{index}',
            config=WaitForCallbackConfig(timeout=Duration.from_seconds(172800))
        )

        return ctx.step(
            lambda _: complete_order(validated, approval),
            name=f'complete-{index}'
        )

    results = context.map(
        inputs=sqs_event['Records'],
        func=process_record,
        name='process-records'
    )

    return {
        'statusCode': 200, 
        'started': results.started_count,
        'completed': results.success_count,
        'failed': results.failure_count,
        'total': results.total_count
    }
            

Considerações importantes

Esse padrão elimina o limite de duração da execução do mapeamento da origem do evento, ao dissociar o mapeamento da origem do evento da execução duradoura. A função intermediária retornará imediatamente após iniciar a execução durável, permitindo que o mapeamento da origem do evento continue sendo processado. A função durável então funcionará de forma independente pelo tempo necessário.

A função intermediária terá êxito quando invocar a função durável, não quando a execução durável for concluída. Se a execução durável falhar posteriormente, o mapeamento da origem do evento não será repetido porque ele já processou o lote com êxito. Implemente o tratamento de erros na função durável e configure filas de mensagens não entregues para execuções com falha.

Use o parâmetro do nome da execução para garantir o início da execução com idempotência. Se o mapeamento da origem do evento tentar novamente a função intermediária, a função durável não iniciará uma execução duplicada porque o nome da execução já existe.

Origens de eventos com suporte

As funções duráveis oferecem suporte a todas as origens de eventos do Lambda que usem mapeamentos da origem do evento:

Todos os tipos de fonte de evento estão sujeitos ao limite de execução duradoura descrito anteriormente (15 minutos por padrão) ao invocar funções duradouras. No Lambda Managed Instances, o limite aumenta para 90 minutos para essas fontes de eventos, exceto o Amazon MQ e o Amazon DocumentDB, que continuam limitados a 15 minutos.