Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Mappature delle sorgenti degli eventi con funzioni durevoli

Le funzioni durevoli funzionano con tutte le mappature delle sorgenti degli eventi Lambda. Configura le mappature delle sorgenti degli eventi per funzioni durevoli nello stesso modo in cui le configuri per le funzioni standard. Le mappature delle sorgenti degli eventi analizzano automaticamente sorgenti di eventi come Amazon SQS, Kinesis e DynamoDB Streams e richiamano la tua funzione con batch di record.

Le mappature delle sorgenti degli eventi sono utili per funzioni durevoli che elaborano flussi o code con flussi di lavoro complessi e in più fasi. Ad esempio, puoi creare una funzione durevole che elabora i messaggi Amazon SQS con nuovi tentativi, chiamate API esterne e approvazioni umane.

In che modo le mappature delle sorgenti degli eventi richiamano funzioni durevoli

Le mappature delle sorgenti degli eventi richiamano funzioni durevoli in modo sincrono, in attesa del completamento dell'esecuzione duratura completa prima di elaborare il batch successivo o di contrassegnare i record come elaborati. Se il tempo di esecuzione duraturo totale supera i 15 minuti, l'esecuzione scade e fallisce. La mappatura dell'origine degli eventi riceve un'eccezione di timeout e la gestisce in base alla configurazione dei nuovi tentativi.

Limite di esecuzione di 15 minuti

Quando le funzioni durevoli vengono richiamate dalle mappature delle sorgenti degli eventi, la durata totale dell'esecuzione durevole non può superare i 15 minuti. Questo limite si applica all'intera esecuzione durevole dall'inizio al completamento, non solo alle chiamate di singole funzioni.

Questo limite di 15 minuti è separato dal timeout della funzione Lambda (anch'esso massimo 15 minuti). Il timeout della funzione controlla per quanto tempo può essere eseguita ogni singola chiamata, mentre il timeout di esecuzione duraturo controlla il tempo totale trascorso dall'inizio dell'esecuzione al completamento.

Scenari di esempio:

Configurazione delle mappature delle sorgenti degli eventi

Configura le mappature delle sorgenti degli eventi per funzioni durevoli utilizzando la console Lambda, oppure. AWS CLI AWS SDKs Tutte le proprietà standard di mappatura delle sorgenti degli eventi si applicano alle funzioni durevoli:

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
    

Ricordarsi di utilizzare un ARN qualificato (con numero di versione o alias) quando si configurano le mappature delle sorgenti degli eventi per funzioni durevoli.

Gestione degli errori con le mappature delle sorgenti degli eventi

Le mappature delle sorgenti degli eventi forniscono una gestione degli errori integrata che funziona con funzioni durevoli:

Per informazioni complete sulla gestione degli errori di mappatura delle sorgenti degli eventi, consulta la sezione Mappature delle sorgenti degli eventi.

Utilizzo di una funzione intermedia per flussi di lavoro di lunga durata

Se il completamento del flusso di lavoro richiede più di 15 minuti, utilizzate una funzione Lambda standard intermedia tra la mappatura della sorgente dell'evento e la funzione duratura. La funzione intermediaria riceve gli eventi dalla mappatura delle sorgenti degli eventi e richiama la funzione duratura in modo asincrono, rimuovendo il limite di esecuzione di 15 minuti.

Questo modello disaccoppia il modello di invocazione sincrona della mappatura della sorgente degli eventi dal modello di esecuzione a lunga durata della funzione duratura. La mappatura delle sorgenti degli eventi richiama la funzione intermedia, che ritorna rapidamente dopo l'avvio dell'esecuzione duratura. La funzione durable viene quindi eseguita in modo indipendente per tutto il tempo necessario (fino a 1 anno).

Architecture

Il modello di funzione intermedia utilizza tre componenti:

Implementazione

La funzione intermediaria riceve l'intero evento dalla mappatura della sorgente dell'evento e richiama la funzione durevole in modo asincrono. Utilizzate il parametro del nome di esecuzione per garantire l'avvio di un'esecuzione idempotente, evitando l'elaborazione duplicata se la mappatura dell'origine dell'evento riprova:

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}
            

Per l'idempotenza nella funzione intermedia stessa, usate Powertools per evitare invocazioni duplicate della funzione durable se la AWS Lambda mappatura della sorgente dell'evento riprova la funzione intermediaria.

La funzione durable riceve il payload con il nome di esecuzione ed elabora tutti i record con una logica di lunga durata:

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())}
            

Considerazioni chiave

Questo modello rimuove il limite di esecuzione di 15 minuti disaccoppiando la mappatura della sorgente dell'evento dall'esecuzione durevole. La funzione intermedia ritorna immediatamente dopo l'avvio dell'esecuzione duratura, consentendo alla mappatura della fonte dell'evento di continuare l'elaborazione. La funzione durable viene quindi eseguita in modo indipendente per tutto il tempo necessario.

La funzione intermedia ha successo quando richiama la funzione durable, non quando l'esecuzione duratura viene completata. Se l'esecuzione duratura fallisce in un secondo momento, la mappatura della fonte dell'evento non riproverà perché il batch è già stato elaborato correttamente. Implementa la gestione degli errori nella funzione durable e configura le code di lettere morte per le esecuzioni non riuscite.

Utilizzate il parametro del nome di esecuzione per garantire l'avvio di un'esecuzione idempotente. Se la mappatura dell'origine dell'evento riprova la funzione intermedia, la funzione durable non avvierà un'esecuzione duplicata perché il nome dell'esecuzione esiste già.

Fonti di eventi supportate

Le funzioni durevoli supportano tutte le sorgenti di eventi Lambda che utilizzano le mappature delle sorgenti degli eventi:

Tutti i tipi di sorgenti di eventi sono soggetti al limite di esecuzione durevole di 15 minuti quando si richiamano funzioni durevoli.