Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Eventquellen-Mappings mit dauerhaften Funktionen

Dauerhafte Funktionen funktionieren mit allen Lambda-Ereignisquellenzuordnungen. Konfigurieren Sie Ereignisquellenzuordnungen für dauerhafte Funktionen auf dieselbe Weise, wie Sie sie für Standardfunktionen konfigurieren. Eventquellen-Mappings fragen automatisch Eventquellen wie Amazon SQS, Kinesis und DynamoDB Streams ab und rufen Ihre Funktion mit Batches von Datensätzen auf.

Zuordnungen von Ereignisquellen eignen sich für langlebige Funktionen, die Streams oder Warteschlangen mit komplexen, mehrstufigen Workflows verarbeiten. Sie können beispielsweise eine dauerhafte Funktion erstellen, die Amazon SQS-Nachrichten mit Wiederholungsversuchen, externen API-Aufrufen und menschlichen Genehmigungen verarbeitet.

Wie Zuordnungen von Ereignisquellen dauerhafte Funktionen aufrufen

Ereignisquellenzuordnungen rufen synchron dauerhafte Funktionen auf und warten, bis die vollständige dauerhafte Ausführung abgeschlossen ist, bevor der nächste Batch verarbeitet oder Datensätze als verarbeitet markiert werden. Wenn die gesamte dauerhafte Ausführungszeit 15 Minuten überschreitet, wird das Zeitlimit überschritten und die Ausführung schlägt fehl. Die Ereignisquellenzuordnung erhält eine Timeout-Ausnahme und behandelt sie entsprechend ihrer Wiederholungskonfiguration.

Ausführungslimit von 15 Minuten

Wenn dauerhafte Funktionen durch Zuordnungen von Ereignisquellen aufgerufen werden, darf die Gesamtdauer der dauerhaften Ausführung 15 Minuten nicht überschreiten. Dieses Limit gilt für die gesamte dauerhafte Ausführung von Anfang bis Ende, nicht nur für einzelne Funktionsaufrufen.

Dieses 15-Minuten-Limit ist unabhängig vom Timeout der Lambda-Funktion (ebenfalls maximal 15 Minuten). Das Funktions-Timeout steuert, wie lange jeder einzelne Aufruf ausgeführt werden kann, während das dauerhafte Ausführungs-Timeout die gesamte verstrichene Zeit vom Beginn bis zum Abschluss der Ausführung steuert.

Beispielszenarien:

Konfiguration der Zuordnungen von Ereignisquellen

Konfigurieren Sie Ereignisquellenzuordnungen für dauerhafte Funktionen mithilfe der Lambda-Konsole oder der SDKs. AWS CLI AWS Alle Standardeigenschaften für die Zuordnung von Ereignisquellen gelten für dauerhafte Funktionen:

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
    

Denken Sie daran, einen qualifizierten ARN (mit Versionsnummer oder Alias) zu verwenden, wenn Sie Ereignisquellenzuordnungen für langlebige Funktionen konfigurieren.

Fehlerbehandlung bei Zuordnungen von Ereignisquellen

Ereignisquellenzuordnungen bieten eine integrierte Fehlerbehandlung, die mit dauerhaften Funktionen funktioniert:

Vollständige Informationen zur Fehlerbehandlung bei der Zuordnung von Ereignisquellen finden Sie unter Zuordnungen von Ereignisquellen.

Verwendung einer Zwischenfunktion für Workflows mit langer Laufzeit

Wenn Ihr Workflow mehr als 15 Minuten benötigt, verwenden Sie eine Lambda-Standardfunktion als Zwischenfunktion zwischen der Ereignisquellenzuordnung und Ihrer dauerhaften Funktion. Die Zwischenfunktion empfängt Ereignisse aus dem Eventquell-Mapping und ruft die dauerhafte Funktion asynchron auf, wodurch das Ausführungslimit von 15 Minuten aufgehoben wird.

Dieses Muster entkoppelt das synchrone Aufrufmodell des Eventquellen-Mappings vom langlebigen Ausführungsmodell der dauerhaften Funktion. Das Eventquellen-Mapping ruft die Zwischenfunktion auf, die nach dem Start der dauerhaften Ausführung schnell wieder zurückkehrt. Die dauerhafte Funktion wird dann so lange wie nötig unabhängig ausgeführt (bis zu 1 Jahr).

Architektur

Das Zwischenfunktionsmuster besteht aus drei Komponenten:

Implementierung

Die Zwischenfunktion empfängt das gesamte Ereignis aus der Ereignisquellenzuordnung und ruft die dauerhafte Funktion asynchron auf. Verwenden Sie den Parameter für den Ausführungsnamen, um sicherzustellen, dass die idempotente Ausführung beginnt, und verhindern Sie so eine doppelte Verarbeitung, wenn die Ereignisquellenzuordnung einen erneuten Versuch unternimmt:

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}
            

Um die Idempotenz in der Zwischenfunktion selbst zu erreichen, verwenden Sie Powertools für, um doppelte Aufrufe der dauerhaften Funktion AWS Lambda zu verhindern, falls das Eventquellen-Mapping die Zwischenfunktion erneut versucht.

Die langlebige Funktion empfängt die Nutzlast mit dem Ausführungsnamen und verarbeitet alle Datensätze mit einer Logik, die lange läuft:

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
    }
            

Wesentliche Überlegungen

Dieses Muster entfernt das 15-Minuten-Ausführungslimit, indem es die Zuordnung der Ereignisquelle von der dauerhaften Ausführung entkoppelt. Die Zwischenfunktion kehrt sofort nach dem Start der dauerhaften Ausführung zurück, sodass das Eventquellen-Mapping die Verarbeitung fortsetzen kann. Die dauerhafte Funktion wird dann so lange wie nötig unabhängig ausgeführt.

Die Zwischenfunktion ist erfolgreich, wenn sie die dauerhafte Funktion aufruft, nicht, wenn die dauerhafte Ausführung abgeschlossen ist. Schlägt die dauerhafte Ausführung später fehl, versucht die Ereignisquellenzuordnung den Vorgang nicht erneut, da der Batch bereits erfolgreich verarbeitet wurde. Implementieren Sie die Fehlerbehandlung in der Durable-Funktion und konfigurieren Sie Warteschlangen, in denen keine Nachrichten mehr angezeigt werden, für fehlgeschlagene Ausführungen.

Verwenden Sie den Parameter für den Ausführungsnamen, um sicherzustellen, dass die idempotente Ausführung beginnt. Wenn die Ereignisquellenzuordnung die Zwischenfunktion erneut versucht, startet die Durable-Funktion keine doppelte Ausführung, da der Ausführungsname bereits vorhanden ist.

Unterstützte Ereignisquellen

Dauerhafte Funktionen unterstützen alle Lambda-Ereignisquellen, die Ereignisquellenzuordnungen verwenden:

Für alle Arten von Ereignisquellen gilt beim Aufrufen dauerhafter Funktionen eine maximale Ausführungsdauer von 15 Minuten.