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. # Dauerhafte Lambda-Funktionen aufrufen Dauerhafte Lambda-Funktionen unterstützen dieselben Aufrufmethoden wie Standard-Lambda-Funktionen. Sie können langlebige Funktionen synchron, asynchron oder über Zuordnungen von Ereignisquellen aufrufen. Der Aufrufvorgang ist identisch mit Standardfunktionen, langlebige Funktionen bieten jedoch zusätzliche Funktionen für Ausführungen mit langer Laufzeit und automatische Statusverwaltung. ## Aufrufmethoden **Synchroner Aufruf:** Rufen Sie eine dauerhafte Funktion auf und warten Sie auf die Antwort. Synchrone Aufrufe werden vom Lambda auf 15 Minuten (oder weniger, abhängig von der konfigurierten Funktion und dem Ausführungstimeout) begrenzt. Verwenden Sie synchrone Aufrufe, wenn Sie sofortige Ergebnisse benötigen oder wenn Sie Dienste integrieren, die eine Antwort erwarten. APIs Sie können Wait-Operationen für effiziente Berechnungen verwenden, ohne den Aufrufer zu unterbrechen — der Aufruf wartet, bis die gesamte Durable-Ausführung abgeschlossen ist. [Verwenden Sie für idempotente Ausführungsstarts den Parameter für den Ausführungsnamen, wie unter Idempotenz beschrieben.](durable-execution-idempotency.md) ``` aws lambda invoke \ --function-name my-durable-function:1 \ --cli-binary-format raw-in-base64-out \ --payload '{"orderId": "12345"}' \ response.json ``` **Asynchroner Aufruf:** Ein Ereignis zur Verarbeitung in eine Warteschlange stellen, ohne auf eine Antwort zu warten. Lambda stellt das Ereignis in eine Warteschlange und kehrt sofort zurück. Asynchrone Aufrufe unterstützen Ausführungsdauern von bis zu einem Jahr. Verwenden Sie den asynchronen Aufruf für fire-and-forget Szenarien oder wenn die Verarbeitung im Hintergrund erfolgen kann. [Verwenden Sie für idempotente Ausführungsstarts den Parameter für den Ausführungsnamen, wie unter Idempotenz beschrieben.](durable-execution-idempotency.md) ``` aws lambda invoke \ --function-name my-durable-function:1 \ --invocation-type Event \ --cli-binary-format raw-in-base64-out \ --payload '{"orderId": "12345"}' \ response.json ``` **Zuordnungen von Ereignisquellen:** Konfigurieren Sie Lambda so, dass Ihre dauerhafte Funktion automatisch aufgerufen wird, wenn Datensätze von stream- oder warteschlangenbasierten Diensten wie Amazon SQS, Kinesis oder DynamoDB verfügbar sind. Zuordnungen von Ereignisquellen fragen die Ereignisquelle ab und rufen Ihre Funktion mit Datensatzstapeln auf. Einzelheiten zur Verwendung von Ereignisquellenzuordnungen mit dauerhaften Funktionen, einschließlich Beschränkungen für die Ausführungsdauer, finden Sie unter Zuordnungen von [Ereignisquellen](durable-invoking-esm.md) mit dauerhaften Funktionen. [Vollständige Informationen zu den einzelnen Aufrufmethoden finden Sie unter [synchroner](invocation-sync.md) Aufruf und asynchroner Aufruf.](invocation-async.md) **Anmerkung** Dauerhafte Funktionen unterstützen Dead-Letter-Warteschlangen (DLQs) für die Fehlerbehandlung, unterstützen jedoch keine Lambda-Ziele. Konfigurieren Sie eine DLQ, um Datensätze von fehlgeschlagenen Aufrufen zu erfassen. ## Qualifizierte Anforderung ARNs Dauerhafte Funktionen benötigen qualifizierte Bezeichner für den Aufruf. Sie müssen dauerhafte Funktionen mit einer Versionsnummer, einem Alias oder aufrufen. `$LATEST` Sie können entweder einen vollqualifizierten ARN oder einen Funktionsnamen mit version/alias Suffix verwenden. Sie können keinen unqualifizierten Bezeichner (ohne Versions- oder Aliassuffix) verwenden. **Gültige Aufrufe:** ``` # Using full ARN with version number arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1 # Using full ARN with alias arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:prod # Using full ARN with $LATEST arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:$LATEST # Using function name with version number my-durable-function:1 # Using function name with alias my-durable-function:prod ``` **Ungültige Aufrufe:** ``` # Unqualified ARN (not allowed) arn:aws:lambda:us-east-1:123456789012:function:my-durable-function # Unqualified function name (not allowed) my-durable-function ``` Diese Anforderung stellt sicher, dass langlebige Ausführungen während ihres gesamten Lebenszyklus konsistent bleiben. Wenn eine dauerhafte Ausführung gestartet wird, wird sie an die spezifische Funktionsversion gebunden. Wenn Ihre Funktion Stunden oder Tage später unterbrochen und wieder aufgenommen wird, ruft Lambda dieselbe Version auf, mit der die Ausführung gestartet wurde, wodurch die Codekonsistenz im gesamten Workflow gewährleistet wird. **Bewährte Methode** Verwenden Sie nummerierte Versionen oder Aliase eher für langlebige Produktionsfunktionen als. `$LATEST` Nummerierte Versionen sind unveränderlich und unterstützen die deterministische Wiedergabe. Optional bieten Aliase eine stabile Referenz, die Sie aktualisieren können, um auf neue Versionen zu verweisen, ohne den Aufrufcode zu ändern. Wenn Sie einen Alias aktualisieren, verwenden neue Ausführungen die neue Version, während laufende Ausführungen mit ihrer ursprünglichen Version fortgesetzt werden. Sie können sie `$LATEST` für die Prototypenerstellung oder zur Verkürzung der Bereitstellungszeiten während der Entwicklung verwenden, da Sie wissen, dass Ausführungen möglicherweise nicht korrekt wiedergegeben werden (oder sogar fehlschlagen), wenn sich der zugrunde liegende Code während laufender Ausführungen ändert. ## Den Ausführungslebenszyklus verstehen Wenn Sie eine dauerhafte Funktion aufrufen, erstellt Lambda eine dauerhafte Ausführung, die mehrere Funktionsaufrufe umfassen kann: 1. **Erster Aufruf:** Ihre Aufrufanforderung erstellt eine neue dauerhafte Ausführung. Lambda weist eine eindeutige Ausführungs-ID zu und beginnt mit der Verarbeitung. 1. **Ausführung und Checkpointing:** Während Ihre Funktion dauerhafte Operationen ausführt, erstellt das SDK Checkpoints, die den Fortschritt verfolgen. 1. **Aussetzung (falls erforderlich):** Wenn Ihre Funktion dauerhafte Wartezeiten wie `wait` oder oder oder `waitForCallback` automatische Schrittwiederholungen verwendet, unterbricht Lambda die Ausführung und beendet die Berechnung der Rechenzeit. 1. **Wiederaufnahme:** Wenn es Zeit ist, fortzufahren (auch nach erneuten Versuchen), ruft Lambda Ihre Funktion erneut auf. Das SDK spielt das Checkpoint-Protokoll erneut ab und setzt dort fort, wo die Ausführung unterbrochen wurde. 1. **Abschluss:** Wenn Ihre Funktion ein Endergebnis zurückgibt oder einen unbehandelten Fehler ausgibt, wird die dauerhafte Ausführung abgeschlossen. Bei synchronen Aufrufen wartet der Aufrufer, bis die gesamte dauerhafte Ausführung abgeschlossen ist, einschließlich aller Warteoperationen. Wenn die Ausführung das Aufruf-Zeitlimit (15 Minuten oder weniger) überschreitet, wird das Timeout für den Aufruf überschritten. Bei asynchronen Aufrufen kehrt Lambda sofort zurück und die Ausführung wird unabhängig fortgesetzt. Verwenden Sie die dauerhafte Ausführung, um den Ausführungsstatus APIs zu verfolgen und die Endergebnisse abzurufen. ## Aus dem Anwendungscode aufrufen Verwenden Sie die AWS SDKs , um dauerhafte Funktionen aus Ihrem Anwendungscode aufzurufen. Der Aufrufvorgang ist identisch mit den Standardfunktionen: ------ #### [ TypeScript ] ``` import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda'; const client = new LambdaClient({}); // Synchronous invocation const response = await client.send(new InvokeCommand({ FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1', Payload: JSON.stringify({ orderId: '12345' }) })); const result = JSON.parse(Buffer.from(response.Payload!).toString()); // Asynchronous invocation await client.send(new InvokeCommand({ FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1', InvocationType: 'Event', Payload: JSON.stringify({ orderId: '12345' }) })); ``` ------ #### [ Python ] ``` import boto3 import json client = boto3.client('lambda') # Synchronous invocation response = client.invoke( FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1', Payload=json.dumps({'orderId': '12345'}) ) result = json.loads(response['Payload'].read()) # Asynchronous invocation client.invoke( FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1', InvocationType='Event', Payload=json.dumps({'orderId': '12345'}) ) ``` ------ ## Verkettete Aufrufe Dauerhafte Funktionen können mithilfe der Operation von andere dauerhafte und nicht dauerhafte Funktionen aufrufen. `invoke` `DurableContext` Dadurch entsteht ein verketteter Aufruf, bei dem die aufrufende Funktion wartet (unterbricht), bis die aufgerufene Funktion abgeschlossen ist: ------ #### [ TypeScript ] ``` export const handler = withDurableExecution( async (event: any, context: DurableContext) => { // Invoke another durable function and wait for result const result = await context.invoke( 'process-order', 'arn:aws:lambda:us-east-1:123456789012:function:order-processor:1', { orderId: event.orderId } ); return { statusCode: 200, body: JSON.stringify(result) }; } ); ``` ------ #### [ Python ] ``` @durable_execution def handler(event, context: DurableContext): # Invoke another durable function and wait for result result = context.invoke( 'arn:aws:lambda:us-east-1:123456789012:function:order-processor:1', {'orderId': event['orderId']}, name='process-order' ) return {'statusCode': 200, 'body': json.dumps(result)} ``` ------ Verkettete Aufrufe erzeugen einen Checkpoint in der aufrufenden Funktion. Wenn die aufrufende Funktion unterbrochen wird, wird sie vom Checkpoint aus mit dem Ergebnis der aufgerufenen Funktion fortgesetzt, ohne die Funktion erneut aufzurufen. **Anmerkung** Kontenübergreifende, verkettete Aufrufe werden nicht unterstützt. Die aufgerufene Funktion muss sich in demselben AWS Konto wie die aufrufende Funktion befinden.