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.

Zuordnungen von Ereignisquellen mit dauerhaften Funktionen

Dauerhafte Funktionen funktionieren mit allen Lambda-Ereignisquellenzuordnungen. Konfigurieren Sie Ereignisquellenzuordnungen für dauerhafte Funktionen auf die gleiche 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 das geltende Timeout-Limit überschreitet (standardmäßig 15 Minuten oder bis zu 90 Minuten für Funktionen, die auf Lambda Managed Instances ausgeführt werden), wird das Zeitlimit überschritten und die Ausführung schlägt fehl. Die Ereignisquellenzuordnung erhält eine Timeout-Ausnahme und behandelt sie entsprechend ihrer Wiederholungskonfiguration.

Begrenzung der Ausführungsdauer

Wenn dauerhafte Funktionen durch Zuordnungen von Ereignisquellen aufgerufen werden, darf die gesamte dauerhafte Ausführungsdauer das maximale Funktions-Timeout nicht überschreiten: 15 Minuten für Funktionen, die im Standardkapazitätsmodus (bei Bedarf) ausgeführt werden, oder bis zu 90 Minuten für Funktionen, die auf Lambda Managed Instances ausgeführt werden (mit Ausnahme von Amazon MQ- und Amazon DocumentDB-Ereignisquellenzuordnungen, die auf 15 Minuten begrenzt bleiben). Diese Grenze gilt für die gesamte dauerhafte Ausführung von Anfang bis Ende, nicht nur für einzelne Funktionsaufrufen.

Dieses Limit ist unabhängig vom Timeout der Lambda-Funktion pro Aufruf, obwohl beide das gleiche Maximum haben (standardmäßig 15 Minuten oder bis zu 90 Minuten auf Lambda Managed Instances für asynchrone Aufrufe und Aufrufe der Ereignisquellenzuordnung). 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 das geltende Limit für die Zuordnung von Ereignisquellen erfordert (standardmäßig 15 Minuten oder 90 Minuten bei Lambda Managed Instances), 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 Limit für die Ausführungsdauer aufgehoben wird.

Dieses Muster entkoppelt das synchrone Aufrufmodell der Ereignisquellenzuordnung vom langfristigen 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 erneut versucht:

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 Limit für die Ausführungsdauer des Eventquellen-Mappings, indem es das Eventquellen-Mapping von der dauerhaften Ausführung entkoppelt. Die Zwischenfunktion kehrt sofort nach dem Start der dauerhaften Ausführung zurück, sodass die Verarbeitung des Ereignisquellen-Mappings fortgesetzt werden 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:

Alle Arten von Ereignisquellen unterliegen der zuvor beschriebenen dauerhaften Ausführungsbeschränkung (standardmäßig 15 Minuten) beim Aufrufen dauerhafter Funktionen. Bei Lambda Managed Instances erhöht sich das Limit für diese Ereignisquellen auf 90 Minuten, mit Ausnahme von Amazon MQ und Amazon DocumentDB, die weiterhin auf 15 Minuten begrenzt sind.