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. Ereignisquellenzuordnungen fragen automatisch Ereignisquellen wie Amazon SQS, Kinesis und DynamoDB Streams ab und rufen Ihre Funktion mit Datensatzstapeln auf.

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

Wie Zuordnungen von Ereignisquellen dauerhafte Funktionen aufrufen

Bei Zuordnungen von Ereignisquellen werden dauerhafte Funktionen synchron aufgerufen. Sie warten, bis die vollständige Ausführung abgeschlossen ist, bevor der nächste Stapel verarbeitet oder Datensätze als verarbeitet markiert werden. Wenn die gesamte Dauer der dauerhaften Ausführung 15 Minuten überschreitet, wird das Zeitlimit überschritten und die Ausführung schlägt fehl. Die Ereignisquellenzuordnung empfängt 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. Diese Grenze 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 Lambda-Funktions-Timeout (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 Start bis zum Abschluss der Ausführung bestimmt.

Beispielszenarien:

Zuordnungen von Ereignisquellen konfigurieren

Konfigurieren Sie Ereignisquellenzuordnungen für dauerhafte Funktionen mithilfe der Lambda-Konsole,, AWS CLI oder. AWS SDKs 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, bei der Konfiguration von Ereignisquellenzuordnungen für dauerhafte Funktionen einen qualifizierten ARN (mit Versionsnummer oder Alias) zu verwenden.

Fehlerbehandlung bei Zuordnungen von Ereignisquellen

Zuordnungen von Ereignisquellen 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 in Anspruch nimmt, verwenden Sie eine Standard-Lambda-Zwischenfunktion zwischen der Zuordnung der Ereignisquelle und Ihrer dauerhaften Funktion. Die Zwischenfunktion empfängt Ereignisse aus der Ereignisquellenzuordnung und ruft die dauerhafte Funktion asynchron auf, wodurch das Ausführungslimit von 15 Minuten aufgehoben wird.

Dieses Muster entkoppelt das synchrone Aufrufmodell der Ereignisquellenzuordnung vom Modell der dauerhaften Funktion mit langer Laufzeit. Bei der Zuordnung der Ereignisquellen wird die Zwischenfunktion aufgerufen, die nach dem Start der dauerhaften Ausführung schnell zurückkehrt. Die dauerhafte Funktion wird dann so lange wie nötig unabhängig ausgeführt (bis zu 1 Jahr).

Architektur

Das Muster der zwischengeschalteten Funktionen 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 gestartet wird, und verhindern Sie so eine doppelte Verarbeitung, falls 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}
            

Verwenden Sie Powertools für Idempotenz in der Zwischenfunktion selbst, um doppelte Aufrufe der dauerhaften Funktion AWS Lambda zu verhindern, falls die Zuordnung der Ereignisquelle die Zwischenfunktion erneut versucht.

Die dauerhafte Funktion empfängt die Nutzdaten mit dem Namen der Ausführung und verarbeitet alle Datensätze mit lang andauernder Logik:

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

Wesentliche Überlegungen

Mit diesem Muster wird das Ausführungslimit von 15 Minuten aufgehoben, indem die Zuordnung der Ereignisquelle von der dauerhaften Ausführung entkoppelt wird. Die Zwischenfunktion kehrt unmittelbar nach dem Start der dauerhaften Ausführung zurück, sodass die Verarbeitung der Ereignisquellenzuordnung 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. Wenn die dauerhafte Ausführung später fehlschlägt, versucht die Zuordnung der Ereignisquelle nicht erneut, da der Stapel bereits erfolgreich verarbeitet wurde. Implementieren Sie die Fehlerbehandlung in der dauerhaften Funktion und konfigurieren Sie Warteschlangen für fehlerhafte Ausführungen.

Verwenden Sie den Parameter für den Ausführungsnamen, um sicherzustellen, dass die idempotente Ausführung gestartet wird. Wenn die Zuordnung der Ereignisquelle erneut versucht, die Zwischenfunktion zu verwenden, startet die dauerhafte 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.