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 erstellen
Um mit dauerhaften Lambda-Funktionen zu beginnen, verwenden Sie die Lambda-Konsole, um eine dauerhafte Funktion zu erstellen. In wenigen Minuten können Sie eine dauerhafte Funktion erstellen und bereitstellen, die anhand von Schritten und Wartezeiten die Ausführung anhand von Checkpoints demonstriert.
Während der Durchführung des Tutorials lernen Sie grundlegende Konzepte für dauerhafte Funktionen kennen, z. B. wie Sie das `DurableContext` Objekt verwenden, Checkpoints mit Schritten erstellen und die Ausführung mit Wartezeiten unterbrechen. Außerdem erfahren Sie, wie die Wiedergabe funktioniert, wenn Ihre Funktion nach einer Wartezeit wieder aufgenommen wird.
Um die Dinge einfach zu halten, zeigt Ihnen dieses Tutorial, wie Sie Ihre Funktion entweder mit der Python- oder Node.js Runtime erstellen. Mit diesen interpretierten Sprachen können Sie Funktionscode direkt im integrierten Code-Editor der Konsole bearbeiten.
Dauerhafte Funktionen in Java (Preview) können derzeit nur über Container-Images bereitgestellt werden. Weitere Informationen zum Erstellen dauerhafter Funktionen aus Container-Images finden Sie unter [Unterstützte Laufzeiten für dauerhafte Funktionen](durable-supported-runtimes.md) oder [Bereitstellen dauerhafter Lambda-Funktionen mit Infrastructure as Code](durable-getting-started-iac.md).
**Anmerkung**
Dauerhafte Funktionen unterstützen derzeit Python- und Node.js (JavaScript/TypeScript) -Laufzeiten sowie Container-Images (OCI) wie Java. Eine vollständige Liste der unterstützten Laufzeitversionen und Container-Image-Optionen finden Sie unter [Unterstützte Laufzeiten für](durable-supported-runtimes.md) langlebige Funktionen. Weitere Informationen zur Verwendung von Container-Images mit Lambda finden Sie unter [Creating Lambda container images](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) im Lambda Developer Guide.
**Tipp**
Weitere Informationen zum Erstellen von **Serverless-Lösungen** finden Sie im [Serverless-Benutzerhandbuch](https://docs.aws.amazon.com/serverless/latest/devguide/).
## Voraussetzungen
### Melden Sie sich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.
### Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
## Erstellen Sie mit der Konsole eine dauerhafte Lambda-Funktion
In diesem Beispiel verarbeitet Ihre langlebige Funktion eine Bestellung in mehreren Schritten mit automatischem Checkpoint. Die Funktion verwendet ein JSON-Objekt, das eine Bestell-ID enthält, validiert die Bestellung, verarbeitet die Zahlung und bestätigt die Bestellung. Jeder Schritt wird automatisch überprüft. Wenn die Funktion unterbrochen wird, wird sie mit dem letzten abgeschlossenen Schritt fortgesetzt.
Ihre Funktion demonstriert auch eine Warteoperation, bei der die Ausführung für einen kurzen Zeitraum angehalten wird, um das Warten auf eine externe Bestätigung zu simulieren.
**Um eine dauerhafte Funktion mit der Konsole zu erstellen**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie **Funktion erstellen**.
1. Wählen Sie **Verfassen von Grund auf** aus.
1. Geben Sie im Bereich **Grundlegende Informationen** als **Funktionsname** `myDurableFunction` ein.
1. Wählen Sie für **Runtime** entweder **Node.js 24** oder **Python 3.14**.
1. Wählen Sie **Dauerhafte Ausführung aktivieren** aus.
Lambda erstellt Ihre dauerhafte Funktion mit einer [Ausführungsrolle](lambda-intro-execution-role.md), die Berechtigungen für Checkpoint-Operationen (`lambda:CheckpointDurableExecutions`und`lambda:GetDurableExecutionState`) beinhaltet.
**Anmerkung**
Lambda-Laufzeiten enthalten das Durable Execution SDK, sodass Sie langlebige Funktionen ohne Paketierungsabhängigkeiten testen können. Wir empfehlen jedoch, das SDK in Ihr Bereitstellungspaket für die Produktion aufzunehmen. Dadurch wird die Versionskonsistenz gewährleistet und potenzielle Runtime-Updates vermieden, die Ihre Funktion beeinträchtigen könnten.
Verwenden Sie den integrierten Code-Editor der Konsole, um Ihren dauerhaften Funktionscode hinzuzufügen.
------
#### [ Node.js ]
**So ändern Sie den Code in der Konsole**
1. Wählen Sie die Registerkarte **Code**.
Im integrierten Code-Editor der Konsole sollten Sie den von Lambda erstellten Funktionscode sehen. Wenn die Registerkarte **index.mjs** im Code-Editor nicht angezeigt wird, wählen Sie **index.mjs** im Datei-Explorer aus, wie im folgenden Diagramm gezeigt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/durable-nodejs.png)
1. Fügen Sie den folgenden Code in die Registerkarte **index.mjs** ein und ersetzen Sie den von Lambda erstellten Code.
```
import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event, context) => {
const orderId = event.orderId;
// Step 1: Validate order
const validationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Validating order ${orderId}`);
return { orderId, status: "validated" };
});
// Step 2: Process payment
const paymentResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Processing payment for order ${orderId}`);
return { orderId, status: "paid", amount: 99.99 };
});
// Wait for 10 seconds to simulate external confirmation
await context.wait({ seconds: 10 });
// Step 3: Confirm order
const confirmationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Confirming order ${orderId}`);
return { orderId, status: "confirmed" };
});
return {
orderId: orderId,
status: "completed",
steps: [validationResult, paymentResult, confirmationResult]
};
}
);
```
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Verstehen Sie Ihren dauerhaften Funktionscode**
Bevor Sie mit dem nächsten Schritt fortfahren, sollten wir uns den Funktionscode ansehen und die wichtigsten Konzepte für langlebige Funktionen verstehen.
+ Der `withDurableExecution` Wrapper:
Ihre langlebige Funktion ist umhüllt von. `withDurableExecution` Dieser Wrapper ermöglicht eine dauerhafte Ausführung, indem er das `DurableContext` Objekt bereitstellt und Checkpoint-Operationen verwaltet.
+ Das `DurableContext` Objekt:
Anstelle des Standard-Lambda-Kontextes erhält Ihre Funktion eine`DurableContext`. Dieses Objekt bietet Methoden für dauerhafte Operationen wie `step()` und `wait()` die Erstellung von Checkpoints.
+ Schritte und Checkpoints:
Jeder `context.step()` Aufruf erstellt vor und nach der Ausführung einen Checkpoint. Wenn Ihre Funktion unterbrochen wird, wird sie ab dem letzten abgeschlossenen Checkpoint wieder aufgenommen. Die Funktion führt abgeschlossene Schritte nicht erneut aus. Stattdessen werden ihre gespeicherten Ergebnisse verwendet.
+ Warten Sie auf Operationen:
Der `context.wait()` Aufruf unterbricht die Ausführung, ohne Rechenressourcen zu verbrauchen. Wenn das Warten abgeschlossen ist, ruft Lambda Ihre Funktion erneut auf und spielt das Checkpoint-Protokoll erneut ab, wobei abgeschlossene Schritte durch gespeicherte Werte ersetzt werden.
+ Wiedergabemechanismus:
Wenn Ihre Funktion nach einer Wartezeit oder Unterbrechung wieder aufgenommen wird, führt Lambda Ihren Code von Anfang an aus. Abgeschlossene Schritte werden jedoch nicht erneut ausgeführt. Lambda gibt ihre Ergebnisse aus dem Checkpoint-Log wieder. Aus diesem Grund muss Ihr Code deterministisch sein.
------
#### [ Python ]
**So ändern Sie den Code in der Konsole**
1. Wählen Sie die Registerkarte **Code**.
Im integrierten Code-Editor der Konsole sollten Sie den von Lambda erstellten Funktionscode sehen. Wenn die Registerkarte **lambda\$1function.py** im Code-Editor nicht angezeigt wird, wählen Sie **lambda\$1function.py** im Datei-Explorer aus, wie im folgenden Diagramm dargestellt.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/durable-python.png)
1. Fügen Sie den folgenden Code in die Registerkarte **lambda\$1function.py** ein und ersetzen Sie den von Lambda erstellten Code.
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
from aws_durable_execution_sdk_python.config import Duration
@durable_step
def validate_order(step_context, order_id):
step_context.logger.info(f"Validating order {order_id}")
return {"orderId": order_id, "status": "validated"}
@durable_step
def process_payment(step_context, order_id):
step_context.logger.info(f"Processing payment for order {order_id}")
return {"orderId": order_id, "status": "paid", "amount": 99.99}
@durable_step
def confirm_order(step_context, order_id):
step_context.logger.info(f"Confirming order {order_id}")
return {"orderId": order_id, "status": "confirmed"}
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
# Step 1: Validate order
validation_result = context.step(validate_order(order_id))
# Step 2: Process payment
payment_result = context.step(process_payment(order_id))
# Wait for 10 seconds to simulate external confirmation
context.wait(Duration.from_seconds(10))
# Step 3: Confirm order
confirmation_result = context.step(confirm_order(order_id))
return {
"orderId": order_id,
"status": "completed",
"steps": [validation_result, payment_result, confirmation_result]
}
```
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Verstehen Sie Ihren dauerhaften Funktionscode**
Bevor Sie mit dem nächsten Schritt fortfahren, sollten wir uns den Funktionscode ansehen und die wichtigsten Konzepte für langlebige Funktionen verstehen.
+ Der `@durable_execution` Dekorateur:
Ihre Handler-Funktion ist mit `@durable_execution` dekoriert. Dieser Decorator ermöglicht eine dauerhafte Ausführung, indem er das `DurableContext` Objekt bereitstellt und Checkpoint-Operationen verwaltet.
+ Der `@durable_step` Dekorateur:
Jede Schrittfunktion ist mit `@durable_step` dekoriert. Dieser Dekorateur kennzeichnet die Funktion als dauerhaften Schritt, der Checkpoints erzeugt.
+ Das `DurableContext` Objekt:
Anstelle des Standard-Lambda-Kontextes erhält Ihre Funktion eine`DurableContext`. Dieses Objekt bietet Methoden für dauerhafte Operationen wie `step()` und `wait()` die Erstellung von Checkpoints.
+ Schritte und Checkpoints:
Jeder `context.step()` Aufruf erstellt vor und nach der Ausführung einen Checkpoint. Wenn Ihre Funktion unterbrochen wird, wird sie ab dem letzten abgeschlossenen Checkpoint wieder aufgenommen. Die Funktion führt abgeschlossene Schritte nicht erneut aus. Stattdessen werden ihre gespeicherten Ergebnisse verwendet.
+ Warten Sie auf Operationen:
Der `context.wait()` Aufruf unterbricht die Ausführung, ohne Rechenressourcen zu verbrauchen. Wenn das Warten abgeschlossen ist, ruft Lambda Ihre Funktion erneut auf und spielt das Checkpoint-Protokoll erneut ab, wobei abgeschlossene Schritte durch gespeicherte Werte ersetzt werden.
+ Das Python-SDK ist synchron:
Beachten Sie, dass das Python-SDK nicht verwendet`await`. Alle dauerhaften Operationen sind synchrone Methodenaufrufen.
------
## Rufen Sie die dauerhafte Funktion mit dem Code-Editor der Konsole auf
Wenn keine explizite Version angegeben (oder veröffentlicht) ist, ruft die Konsole die dauerhafte Funktion mithilfe des `$LATEST` Versionskennzeichners auf. Für die deterministische Ausführung Ihres Codes müssen Sie jedoch immer einen qualifizierten ARN verwenden, der auf eine stabile Version verweist.
**Um eine Version Ihrer Funktion zu veröffentlichen**
1. Wählen Sie den Tab **Versionen**.
1. Wählen Sie **Publish new version (Neue Version veröffentlichen)** aus.
1. Geben Sie als **Versionsbeschreibung** **Initial version** (optional) ein.
1. Wählen Sie **Publish**.
1. Lambda erstellt Version 1 Ihrer Funktion. Beachten Sie, dass die Funktion ARN jetzt `:1` am Ende steht, was darauf hinweist, dass es sich um Version 1 handelt.
Erstellen Sie nun ein Testereignis, das an Ihre Funktion gesendet werden soll. Das Ereignis ist ein Dokument im JSON-Format, das eine Bestell-ID enthält.
**So erstellen Sie das Testereignis**
1. Wählen Sie im Abschnitt **TESTEREIGNISSE** des Konsolen-Code-Editors die Option **Testereignis erstellen** aus.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
1. Geben Sie als **Event name (Ereignisname)** die Zeichenfolge **myTestEvent** ein.
1. Ersetzen Sie im Abschnitt **Event JSON** das Standard-JSON durch Folgendes:
```
{
"orderId": "order-12345"
}
```
1. Wählen Sie **Speichern**.
**Um Ihre dauerhafte Funktion zu testen und die Ausführung anzusehen**
Wählen Sie im Abschnitt **TESTEREIGNISSE** des Konsolencode-Editors das Ausführungssymbol neben Ihrem Testereignis:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
Ihre dauerhafte Funktion wird ausgeführt. Da sie eine Wartezeit von 10 Sekunden beinhaltet, wird der erste Aufruf schnell abgeschlossen, und die Funktion wird nach Ablauf der Wartezeit wieder aufgenommen. Sie können den Ausführungsfortschritt auf der Registerkarte **Dauerhafte** Ausführungen einsehen.
**Um die Ausführung Ihrer dauerhaften Funktion einzusehen**
1. Wählen Sie die Registerkarte **Dauerhafte Ausführungen**.
1. Suchen Sie in der Liste nach Ihrer Hinrichtung. Die Ausführung zeigt den aktuellen Status an (Wird ausgeführt, Erfolgreich oder Fehlgeschlagen).
1. Wählen Sie die Ausführungs-ID, um Details anzuzeigen, darunter:
+ Ausführungszeitplan, der anzeigt, wann jeder Schritt abgeschlossen wurde
+ Verlauf des Checkpoints
+ Wartezeiten
+ Ergebnisse des Schritts
Sie können die Protokolle Ihrer Funktion auch unter Logs einsehen, um die Konsolenausgabe der einzelnen Schritte zu sehen. CloudWatch
**Um die Aufrufaufzeichnungen Ihrer Funktion in CloudWatch Logs einzusehen**
1. Öffnen Sie die Seite [Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home#logs:) der CloudWatch Konsole.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (`/aws/lambda/myDurableFunction`) aus.
1. Scrollen Sie nach unten und wählen Sie den **Protokollstream** für die Funktionsaufrufen aus, die Sie sich ansehen möchten.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/log-stream.png)
Sie sollten Protokolleinträge für jeden Aufruf Ihrer Funktion sehen, einschließlich der ersten Ausführung und der Wiederholung nach dem Warten.
**Anmerkung**
Wenn Sie den Logger über `DurableContext` (z. B. `context.logger` oder`stepContext.logger`) verwenden, werden Protokolle auch in den dauerhaften Ausführungs- und Schrittansichten der Lambda-Konsole angezeigt. Das Laden dieser Protokolle kann einen Moment dauern.
## Bereinigen
Wenn Sie mit der dauerhaften Beispielfunktion fertig sind, löschen Sie sie. Sie können auch die Protokollgruppe löschen, in der die Protokolle der Funktion gespeichert sind, sowie die von der Konsole erstellte [Ausführungsrolle](lambda-intro-execution-role.md).
**So löschen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus, die Sie erstellt haben.
1. Wählen Sie **Aktionen**, **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie die Protokollgruppe**
1. Öffnen Sie die [Seite Log Groups (Protokollgruppen)](https://console.aws.amazon.com/cloudwatch/home#logs:) der CloudWatch-Konsole.
1. Wählen Sie die Protokollgruppe der Funktion (`/aws/lambda/myDurableFunction`).
1. Wählen Sie **Actions (Aktionen)**, **Delete log group(s) (Protokollgruppe(n) löschen)** aus.
1. Wählen Sie im Dialogfeld **Delete log group(s) (Protokollgruppe(n) löschen)** die Option **Delete (Löschen)** aus.
**So löschen Sie die Ausführungsrolle**
1. Öffnen Sie die [Seite Rollen](https://console.aws.amazon.com/iam/home?#/roles) der AWS Identity and Access Management (IAM-) Konsole.
1. Wählen Sie die Ausführungsrolle der Funktion aus (zum Beispiel `myDurableFunction-role-31exxmpl`).
1. Wählen Sie **Löschen** aus.
1. Geben Sie im Dialogfenster **Delete role** (Rolle löschen) den Namen der Rolle ein und wählen Sie anschließend **Delete** (Löschen) aus.
## Zusätzliche Ressourcen und nächste Schritte
Nachdem Sie mit der Konsole eine einfache, dauerhafte Funktion erstellt und getestet haben, gehen Sie wie folgt vor:
+ Erfahren Sie mehr über gängige Anwendungsfälle für langlebige Funktionen, darunter verteilte Transaktionen, Auftragsabwicklung und Workflows zur Überprüfung durch Mitarbeiter. Sehen Sie sich [Beispiele](durable-examples.md) an.
+ Erfahren Sie, wie Sie die Ausführung dauerhafter Funktionen anhand von CloudWatch Metriken und Ausführungshistorie überwachen können. Weitere Informationen finden Sie unter [Überwachung und Debuggen](durable-monitoring.md).
+ Erfahren Sie, wie Sie langlebige Funktionen synchron und asynchron aufrufen und Ausführungen mit langer Laufzeit verwalten. [Weitere Informationen finden Sie unter Dauerhafte Funktionen aufrufen.](durable-invoking.md)
+ Folgen Sie den bewährten Methoden zum Schreiben von deterministischem Code, zur Verwaltung von Checkpoint-Größen und zur Kostenoptimierung. Siehe [Bewährte](durable-best-practices.md) Methoden.
+ Erfahren Sie, wie Sie langlebige Funktionen lokal und in der Cloud testen können. Weitere Informationen finden Sie unter [Testen langlebiger Funktionen](durable-testing.md).
+ Vergleichen Sie langlebige Funktionen mit Step Functions, um herauszufinden, wann die einzelnen Methoden am effektivsten sind. Siehe [Dauerhafte Funktionen oder Step Functions](durable-step-functions.md).
# 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:CheckpointDurableExecutions`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/
```
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.
**Anmerkung**
Derzeit können dauerhafte Funktionen in Java (Preview) derzeit nur über Container-Images erstellt werden. Weitere Informationen zum Erstellen dauerhafter Funktionen aus Container-Images finden Sie unter [Unterstützte Laufzeiten für langlebige Funktionen](durable-supported-runtimes.md).
## 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` 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)
# Stellen Sie langlebige Lambda-Funktionen mit Infrastructure as Code bereit
Sie können dauerhafte Lambda-Funktionen mithilfe von Infrastructure as Code (IaC) -Tools wie AWS CloudFormation, AWS CDK AWS Serverless Application Model, oder Terraform bereitstellen. Mit diesen Tools können Sie Ihre Funktion, Ausführungsrolle und Berechtigungen im Code definieren, sodass Bereitstellungen wiederholbar und versionskontrolliert werden können.
Für alle drei Tools müssen Sie:
+ Ermöglichen Sie die dauerhafte Ausführung der Funktion
+ Erteilen Sie der Ausführungsrolle Checkpoint-Berechtigungen
+ Veröffentlichen Sie eine Version oder erstellen Sie einen Alias (dauerhafte Funktionen erfordern qualifizierte ARNs Funktionen)
## Dauerhafte Funktionen aus einer ZIP-Datei
### AWS CloudFormation
Verwenden Sie CloudFormation diese Option, um Ihre dauerhafte Funktion in einer Vorlage zu definieren. Im folgenden Beispiel wird eine dauerhafte Funktion mit den erforderlichen Berechtigungen erstellt.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda durable function example
Resources:
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
DurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
Role: !GetAtt DurableFunctionRole.Arn
Code:
ZipFile: |
// Your durable function code here
export const handler = async (event, context) => {
return { statusCode: 200 };
};
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
DurableFunctionVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref DurableFunction
Description: Initial version
DurableFunctionAlias:
Type: AWS::Lambda::Alias
Properties:
FunctionName: !Ref DurableFunction
FunctionVersion: !GetAtt DurableFunctionVersion.Version
Name: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunctionAlias
```
**Um die Vorlage bereitzustellen**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK ermöglicht es Ihnen, die Infrastruktur mithilfe von Programmiersprachen zu definieren. Die folgenden Beispiele zeigen, wie eine dauerhafte Funktion mit TypeScript Python erstellt wird.
------
#### [ TypeScript ]
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.Function(this, 'DurableFunction', {
runtime: lambda.Runtime.NODEJS_22_X,
handler: 'index.handler',
code: lambda.Code.fromAsset('lambda'),
functionName: 'myDurableFunction',
durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
------
#### [ Python ]
```
from aws_cdk import (
Stack,
aws_lambda as lambda_,
aws_iam as iam,
CfnOutput,
)
from constructs import Construct
class DurableFunctionStack(Stack):
def __init__(self, scope: Construct, id: str, **kwargs):
super().__init__(scope, id, **kwargs)
# Create the durable function
durable_function = lambda_.Function(
self, 'DurableFunction',
runtime=lambda_.Runtime.NODEJS_22_X,
handler='index.handler',
code=lambda_.Code.from_asset('lambda'),
function_name='myDurableFunction',
durable_execution={execution_timeout: Duration.hours(1), retention_period: Duration.days(30)}
)
# Add durable execution managed policy for checkpoint permissions
durable_function.role.add_managed_policy(
iam.ManagedPolicy.from_aws_managed_policy_name('service-role/AWSLambdaBasicDurableExecutionRolePolicy')
)
# Create version and alias
version = durable_function.current_version
alias = lambda_.Alias(
self, 'ProdAlias',
alias_name='prod',
version=version
)
# Output the alias ARN
CfnOutput(
self, 'FunctionAliasArn',
value=alias.function_arn,
description='Use this ARN to invoke the durable function'
)
```
------
**Um den CDK-Stack bereitzustellen**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM vereinfacht CloudFormation Vorlagen für serverlose Anwendungen. Die folgende Vorlage erstellt eine dauerhafte Funktion mit AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
CodeUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Um die SAM-Vorlage bereitzustellen**
```
sam build
sam deploy --guided
```
### Terraform
Terraform ist ein beliebtes Open-Source-IaC-Tool, das Ressourcen unterstützt. AWS Das folgende Beispiel erstellt eine dauerhafte Funktion mit Terraform unter Verwendung der Provider-Version 6.25.0 oder höher. AWS
```
terraform {
required_version = ">= 1.0"
required_providers {
aws = {
source = "hashicorp/aws"
version = ">= 6.25.0"
}
}
}
provider "aws" {
region = "us-east-2"
}
# IAM Role for Lambda Function
resource "aws_iam_role" "lambda_role" {
name = "durable-function-role"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Action = "sts:AssumeRole"
Effect = "Allow"
Principal = {
Service = "lambda.amazonaws.com"
}
}]
})
}
# Attach durable execution policy for checkpoint operations
resource "aws_iam_role_policy_attachment" "lambda_durable" {
policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy"
role = aws_iam_role.lambda_role.name
}
# Lambda Function with Durable Execution enabled
resource "aws_lambda_function" "durable_function" {
filename = "function.zip"
function_name = "myDurableFunction"
role = aws_iam_role.lambda_role.arn
handler = "index.handler"
runtime = "nodejs22.x"
timeout = 30
memory_size = 512
durable_config {
execution_timeout = 900
retention_period = 7
}
}
# Publish a version
resource "aws_lambda_alias" "prod" {
name = "prod"
function_name = aws_lambda_function.durable_function.function_name
function_version = aws_lambda_function.durable_function.version
}
output "function_arn" {
description = "ARN of the Lambda function"
value = aws_lambda_function.durable_function.arn
}
output "alias_arn" {
description = "ARN of the function alias (use this for invocations)"
value = aws_lambda_alias.prod.arn
}
```
**Zur Bereitstellung mit Terraform**
```
terraform init
terraform plan
terraform apply
```
**Anmerkung**
Die Terraform-Unterstützung für langlebige Lambda-Funktionen erfordert die AWS Provider-Version 6.25.0 oder höher. Aktualisieren Sie Ihre Provider-Version, wenn Sie eine ältere Version verwenden.
## Dauerhafte Funktionen aus einem OCI-Container-Image
Sie können auch langlebige Funktionen auf der Grundlage von Container-Images erstellen. Anweisungen zum Erstellen eines Container-Images finden Sie unter [Unterstützte Laufzeiten für langlebige Funktionen](durable-supported-runtimes.md).
### AWS CDK
AWS CDK ermöglicht es Ihnen, die Infrastruktur mithilfe von Programmiersprachen zu definieren. Die folgenden Beispiele zeigen, wie Sie mithilfe TypeScript eines Container-Images eine dauerhafte Funktion erstellen.
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.DockerImageFunction(this, 'DurableFunction', {
code: lambda.DockerImageCode.fromImageAsset('./lambda', {
platform: cdk.aws_ecr_assets.Platform.LINUX_AMD64,
}),
functionName: 'myDurableFunction',
memorySize: 512,
timeout: cdk.Duration.seconds(30),
durableConfig: { executionTimeout: cdk.Duration.hours(1), retentionPeriod: cdk.Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
**Um den CDK-Stack bereitzustellen**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM vereinfacht CloudFormation Vorlagen für serverlose Anwendungen. Die folgende Vorlage erstellt eine dauerhafte Funktion mit AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
PackageType: Image
ImageUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Metadata:
DockerTag: latest
DockerContext: ./src
Dockerfile: Dockerfile
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Um die SAM-Vorlage bereitzustellen**
```
sam build
sam deploy --guided
```
## Gängige Konfigurationsmuster
Unabhängig davon, welches IaC-Tool Sie verwenden, folgen Sie diesen Mustern für dauerhafte Funktionen:
**Dauerhafte Ausführung aktivieren**
Stellen Sie die `DurableConfig` Eigenschaft Ihrer Funktion ein, um eine dauerhafte Ausführung zu ermöglichen. Diese Eigenschaft ist nur verfügbar, wenn die Funktion erstellt wird. Sie können die dauerhafte Ausführung vorhandener Funktionen nicht aktivieren.
**Erteilen Sie Checkpoint-Berechtigungen**
Ordnen Sie die `AWSLambdaBasicDurableExecutionRolePolicy` verwaltete Richtlinie der Ausführungsrolle zu. Diese Richtlinie umfasst die erforderlichen `lambda:CheckpointDurableExecutions` und erforderlichen `lambda:GetDurableExecutionState` Berechtigungen.
**Qualifiziert verwenden ARNs**
Erstellen Sie eine Version oder einen Alias für Ihre Funktion. Dauerhafte Funktionen erfordern qualifizierte Funktionen ARNs (mit Version oder Alias) für den Aufruf. Verwenden Sie `AutoPublishAlias` in, und Terraform AWS SAM oder erstellen Sie explizite Versionen in CloudFormation AWS CDK, und Terraform.
**Abhängigkeiten von Paketen**
Nehmen Sie das Durable Execution SDK in Ihr Bereitstellungspaket auf. Installieren Sie Node.js`@aws/durable-execution-sdk-js`. Installieren Sie Python`aws-durable-execution-sdk-python`.
## Nächste Schritte
Nach der Bereitstellung Ihrer dauerhaften Funktion:
+ Testen Sie Ihre Funktion mit dem qualifizierten ARN (Version oder Alias)
+ Überwachen Sie den Ausführungsfortschritt in der Lambda-Konsole auf der Registerkarte Dauerhafte Ausführungen
+ Zeigen Sie Checkpoint-Operationen in Datenereignissen an AWS CloudTrail
+ Überprüfen Sie die CloudWatch Protokolle auf Funktionsausgabe und Wiedergabeverhalten
Weitere Informationen zur Bereitstellung von Lambda-Funktionen mit IaC-Tools finden Sie unter:
+ [CloudFormation AWS::Lambda::Function Referenz](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Dokumentation zum Lambda-Modul](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Entwicklerhandbuch](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)