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. # Stellen Sie langlebige Lambda-Funktionen bereit und rufen Sie sie auf mit dem AWS CLI Verwenden Sie die AWS CLI , um dauerhafte Lambda-Funktionen mit imperativen Befehlen zu erstellen und bereitzustellen. Mit diesem Ansatz haben Sie die direkte Kontrolle über jeden Schritt des Bereitstellungsprozesses. ## Voraussetzungen + Installieren und Konfigurieren der AWS CLI. Anweisungen finden Sie unter [Installation von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). + Erstellen Sie ein Bereitstellungspaket mit Ihrem Funktionscode und dem Durable Execution SDK. + Erstellen Sie eine IAM-Ausführungsrolle mit Checkpoint-Berechtigungen. ## Erstellen der Ausführungsrolle Erstellen Sie eine IAM-Rolle mit Berechtigungen für grundlegende Lambda-Ausführungs- und Checkpoint-Operationen. **So erstellen Sie eine Ausführungsrolle** 1. Erstellen Sie ein Dokument mit Vertrauensrichtlinien, das es Lambda ermöglicht, die Rolle zu übernehmen. Speichern Sie das unter: `trust-policy.json` ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` 1. Erstellen Sie die Rolle: ``` aws iam create-role \ --role-name {{durable-function-role}} \ --assume-role-policy-document file://trust-policy.json ``` 1. Fügen Sie die dauerhafte Ausführungsrichtlinie für Checkpoint-Operationen und die grundlegende Ausführung bei: ``` aws iam attach-role-policy \ --role-name {{durable-function-role}} \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy ``` Die `AWSLambdaBasicDurableExecutionRolePolicy` verwaltete Richtlinie umfasst die erforderlichen Berechtigungen für Checkpoint-Operationen (`lambda:CheckpointDurableExecution`und`lambda:GetDurableExecutionState`) und die grundlegende Lambda-Ausführung. ## Erstellen Sie die dauerhafte Funktion Erstellen Sie Ihre dauerhafte Funktion mit dem `--durable-config` Parameter. **Um eine dauerhafte Funktion zu erstellen** 1. Packen Sie Ihren Funktionscode mit Abhängigkeiten in eine ZIP-Datei: ``` zip -r function.zip index.mjs node_modules/ ``` **Anmerkung** Für Java-basierte dauerhafte Funktionen müssen Sie Ihren Funktionscode und die Abhängigkeiten in einer einzigen ZIP-Datei oder Java-Archivdatei (JAR) kompilieren. Weitere Informationen finden Sie unter [Bereitstellen von Java-Lambda-Funktionen mit ZIP- oder JAR-Dateiarchiven](java-package.md). 1. Erstellen Sie die Funktion mit aktivierter dauerhafter Ausführung: ``` aws lambda create-function \ --function-name {{myDurableFunction}} \ --runtime nodejs22.x \ --role {{arn:aws:iam::123456789012:role/durable-function-role}} \ --handler index.handler \ --zip-file fileb://function.zip \ --durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}' ``` **Anmerkung** Sie können die dauerhafte Ausführung nur aktivieren, wenn Sie die Funktion erstellen. Sie können es nicht für bestehende Funktionen aktivieren. ## Veröffentlichen Sie eine Version Dauerhafte Funktionen können zwar mit dem `$LATEST` Versionskennzeichner aufgerufen werden, Sie müssen jedoch immer einen qualifizierten ARN verwenden, der auf eine stabile Version verweist, um eine deterministische Ausführung Ihres Codes sicherzustellen. ``` aws lambda publish-version \ --function-name {{myDurableFunction}} \ --description "Initial version" ``` Der Befehl gibt die Version ARN zurück. Notieren Sie sich die Versionsnummer (z. B.`:1`) am Ende des ARN. Erstellen Sie optional einen Alias, der auf die Version verweist: ``` aws lambda create-alias \ --function-name {{myDurableFunction}} \ --name prod \ --function-version 1 ``` ## Rufen Sie die dauerhafte Funktion auf Rufen Sie Ihre dauerhafte Funktion mit dem qualifizierten ARN (Version oder Alias) auf. **Anmerkung** **Idempotente Aufrufe: Um doppelte Ausführungen bei wiederholten** fehlgeschlagenen Aufrufen zu verhindern, können Sie einen Ausführungsnamen angeben, der die Ausführungssemantik sicherstellt. at-most-once [Einzelheiten finden](durable-execution-idempotency.md) Sie unter Idempotenz. **Synchroner Aufruf** Verwenden Sie für Ausführungen, die innerhalb von 15 Minuten abgeschlossen sind, den synchronen Aufruf: ``` aws lambda invoke \ --function-name {{myDurableFunction:1}} \ --payload '{"orderId": "order-12345"}' \ --cli-binary-format raw-in-base64-out \ response.json ``` Oder mit einem Alias: ``` aws lambda invoke \ --function-name {{myDurableFunction:prod}} \ --payload '{"orderId": "order-12345"}' \ --cli-binary-format raw-in-base64-out \ response.json ``` **Asynchroner Aufruf** Verwenden Sie für lang andauernde Ausführungen den asynchronen Aufruf: ``` aws lambda invoke \ --function-name {{myDurableFunction:prod}} \ --invocation-type Event \ --payload '{"orderId": "order-12345"}' \ --cli-binary-format raw-in-base64-out \ response.json ``` Bei asynchronem Aufruf kehrt Lambda sofort zurück. Die Funktion wird weiterhin im Hintergrund ausgeführt. **Anmerkung** Sie können sie `$LATEST` für Prototyping und Tests in der Konsole verwenden. Verwenden Sie für Produktionsworkloads eine veröffentlichte Version oder einen Alias. ## Verwalten Sie langlebige Ausführungen Verwenden Sie die folgenden Befehle, um die Ausführung dauerhafter Funktionen zu verwalten und zu überwachen. **Ausführungen auflisten** Listet alle Ausführungen für eine dauerhafte Funktion auf: ``` aws lambda list-durable-executions-by-function \ --function-name {{myDurableFunction}} ``` **Details zur Ausführung abrufen** Rufen Sie Details zu einer bestimmten Ausführung ab: ``` aws lambda get-durable-execution \ --durable-execution-arn {{arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id}} ``` **Ausführungshistorie abrufen** Den Checkpoint-Verlauf für eine Ausführung anzeigen: ``` aws lambda get-durable-execution-history \ --durable-execution-arn {{arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id}} ``` **Stoppen Sie eine Ausführung** Stoppen Sie eine laufende dauerhafte Ausführung: ``` aws lambda stop-durable-execution \ --durable-execution-arn {{arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id}} ``` ## Funktionscode aktualisieren Aktualisieren Sie Ihren dauerhaften Funktionscode und veröffentlichen Sie eine neue Version: **Um eine neue Version zu aktualisieren und zu veröffentlichen** 1. Aktualisieren Sie den Funktionscode: ``` aws lambda update-function-code \ --function-name {{myDurableFunction}} \ --zip-file fileb://function.zip ``` 1. Warten Sie, bis das Update abgeschlossen ist: ``` aws lambda wait function-updated \ --function-name {{myDurableFunction}} ``` 1. Veröffentlichen Sie eine neue Version: ``` aws lambda publish-version \ --function-name {{myDurableFunction}} \ --description "Updated order processing logic" ``` 1. Aktualisieren Sie den Alias so, dass er auf die neue Version verweist: ``` aws lambda update-alias \ --function-name {{myDurableFunction}} \ --name prod \ --function-version 2 ``` **Wichtig** Laufende Ausführungen verwenden weiterhin die Version, mit der sie begonnen haben. Neue Aufrufe verwenden die aktualisierte Alias-Version. ## Funktionsprotokolle anzeigen Sehen Sie sich die Logs Ihrer dauerhaften Funktion unter Logs an CloudWatch : ``` aws logs tail /aws/lambda/myDurableFunction --follow ``` Filtern Sie die Protokolle nach einer bestimmten Ausführung: ``` aws logs filter-log-events \ --log-group-name /aws/lambda/myDurableFunction \ --filter-pattern "exec-abc123" ``` ## Bereinigen von Ressourcen Löschen Sie Ihre dauerhafte Funktion und die zugehörigen Ressourcen: ``` # Delete the function aws lambda delete-function --function-name {{myDurableFunction}} # Delete the IAM role policies aws iam detach-role-policy \ --role-name {{durable-function-role}} \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole aws iam detach-role-policy \ --role-name {{durable-function-role}} \ --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy # Delete the role aws iam delete-role --role-name {{durable-function-role}} ``` ## Nächste Schritte Nach der Bereitstellung Ihrer dauerhaften Funktion mit dem AWS CLI: + Überwachen Sie Ausführungen mit den Befehlen `list-durable-executions-by-function` und `get-durable-execution` + Checkpoint-Operationen in AWS CloudTrail Datenereignissen anzeigen + Richten Sie CloudWatch Alarme für Ausführungsfehler oder lang andauernde Ausführungen ein + Automatisieren Sie Bereitstellungen mithilfe von Shell-Skripten oder Pipelines CI/CD Weitere Informationen zu AWS CLI Befehlen für Lambda finden Sie in der [AWS CLI Befehlsreferenz.](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html)