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.
# Langlebige Lambda-Funktionen
Mit den dauerhaften Lambda-Funktionen können Sie belastbare mehrstufige Anwendungen und KI-Workflows erstellen, die bis zu einem Jahr lang ausgeführt werden können und gleichzeitig trotz Unterbrechungen einen zuverlässigen Fortschritt gewährleisten. Wenn eine dauerhafte Funktion ausgeführt wird, wird dieser gesamte Lebenszyklus als dauerhafte Ausführung bezeichnet. Dabei werden anhand von Prüfpunkten der Fortschritt verfolgt und bei Ausfällen automatisch die Wiederherstellung durch Wiederholung wiederhergestellt, wobei von Anfang an erneut ausgeführt wird, während abgeschlossene Arbeiten übersprungen werden.
In jeder Funktion verwenden Sie dauerhafte Betriebsabläufe als grundlegende Bausteine. Schritte führen Geschäftslogik mit integrierten Wiederholungsversuchen und Fortschrittsverfolgung aus, während Wartezeiten die Ausführung unterbrechen, ohne dass Rechenkosten anfallen. Dadurch eignen sie sich ideal für lang andauernde Prozesse wie human-in-the-loop Workflows oder das Abfragen externer Abhängigkeiten. Ganz gleich, ob Sie Bestellungen bearbeiten, Microservices koordinieren oder agentische KI-Anwendungen orchestrieren — langlebige Funktionen behalten den Status automatisch bei und stellen sie nach Ausfällen wieder her, während Sie Code in vertrauten Programmiersprachen schreiben.
## Wichtigste Vorteile
**Schreiben Sie auf natürliche Weise belastbaren Code:** Mit vertrauten Programmierkonstrukten schreiben Sie Code, der Fehler automatisch behandelt. Integriertes Checkpointing, transparente Wiederholungsversuche und automatische Wiederherstellung sorgen dafür, dass Ihre Geschäftslogik sauber und zielgerichtet bleibt.
**Zahlen Sie nur für das, was Sie tatsächlich nutzen:** Während Wartezeiten wird Ihre Funktion unterbrochen, ohne dass Rechenkosten anfallen. Bei Workflows mit langer Laufzeit, die Stunden oder Tage warten, zahlen Sie nur für die tatsächliche Bearbeitungszeit, nicht für ungenutzte Wartezeiten.
**Einfache Bedienung:** Mit dem serverlosen Modell von Lambda erhalten Sie automatische Skalierung scale-to-zero, auch ohne die Infrastruktur zu verwalten. Zuverlässige Funktionen kümmern sich automatisch um die Statusverwaltung, die Wiederholungslogik und die Wiederherstellung nach einem Ausfall, wodurch der Betriebsaufwand reduziert wird.
## Wann sollten langlebige Funktionen verwendet werden
**Kurzlebige Koordination:** Koordinieren Sie Zahlungen, Inventar und Versand für mehrere Dienste mit automatischem Rollback bei Ausfällen. Bearbeiten Sie Bestellungen durch Validierung, Zahlungsautorisierung, Inventarzuweisung und Erfüllung mit garantierter Fertigstellung.
**Zuverlässige Zahlungsabwicklung:** Sorgen Sie für stabile Zahlungsabläufe, die den Transaktionsstatus auch bei Ausfällen aufrechterhalten und Wiederholungsversuche automatisch abwickeln. Koordinieren Sie mehrstufige Autorisierung, Betrugskontrollen und Abrechnung zwischen den Zahlungsanbietern mit vollständiger Überprüfbarkeit aller Schritte.
**Erstellen Sie zuverlässige KI-Workflows:** Erstellen Sie mehrstufige KI-Workflows, die Modellanrufe verketten, menschliches Feedback einbeziehen und bei Ausfällen lang andauernde Aufgaben deterministisch abwickeln. Fahren Sie nach einer Unterbrechung automatisch fort und zahlen Sie nur für die aktive Ausführungszeit.
**Orchestrieren Sie die komplexe Auftragsabwicklung:** Koordinieren Sie die Auftragsabwicklung in allen Bestands-, Zahlungs-, Versand- und Benachrichtigungssystemen mit integrierter Ausfallsicherheit. Behandeln Sie Teilausfälle automatisch, behalten Sie den Auftragsstatus trotz Unterbrechungen bei und warten Sie effizient auf externe Ereignisse, ohne Rechenressourcen zu verbrauchen.
**Automatisieren Sie mehrstufige Geschäftsabläufe:** Erstellen Sie zuverlässige Workflows für das Onboarding von Mitarbeitern, die Genehmigung von Krediten und die Einhaltung gesetzlicher Vorschriften, die sich über Tage oder Wochen erstrecken. Behalten Sie den Workflow-Status bei Genehmigungen durch Mitarbeiter, Systemintegrationen und geplanten Aufgaben bei und sorgen Sie gleichzeitig für einen vollständigen Überblick über den Prozessstatus und die Historie.
### Wie langlebige Funktionen im Vergleich zu Step Functions abschneiden
Sowohl langlebige Funktionen als auch Step Functions bieten Workflow-Orchestrierung mit automatischem Statusmanagement. Die wichtigsten Unterschiede bestehen darin, wo sie ausgeführt werden und wie Sie Workflows definieren:
+ **Dauerhafte Funktionen:** Ausführung in Lambda, Verwendung von Standardprogrammiersprachen, Verwaltung in der Lambda-Umgebung
+ **Step Functions:** Eigenständiger Service, grafisches DSL oder visueller Designer, vollständig verwaltet und wartungsfrei
Dauerhafte Funktionen eignen sich ideal für die Anwendungsentwicklung in Lambda, wo Workflows eng mit der Geschäftslogik verknüpft sind. Step Functions zeichnet sich durch die AWS dienstübergreifende Workflow-Orchestrierung aus, bei der Sie visuelles Design, native Integrationen für mehr als 220 Dienste und eine wartungsfreie Infrastruktur benötigen.
Einen ausführlichen Vergleich finden Sie unter [Durable-Funktionen oder Step Functions](durable-step-functions.md).
## Funktionsweise
Unter der Haube sind langlebige Funktionen reguläre Lambda-Funktionen, die einen checkpoint/replay Mechanismus verwenden, um den Fortschritt zu verfolgen und lang andauernde Operationen über benutzerdefinierte Aufhängungspunkte zu unterstützen, die allgemein als langlebige Ausführung bezeichnet werden. Nachdem Ihre Funktion nach einer Pause oder Unterbrechung wieder aufgenommen wurde, führt das System eine Wiederholung durch. Während der Wiedergabe wird Ihr Code von Anfang an ausgeführt, überspringt jedoch abgeschlossene Prüfpunkte und verwendet gespeicherte Ergebnisse, anstatt abgeschlossene Operationen erneut auszuführen. Dieser Wiedergabemechanismus gewährleistet Konsistenz und ermöglicht gleichzeitig Ausführungen mit langer Laufzeit.
Um diesen checkpoint-and-replay Mechanismus in Ihren Anwendungen zu nutzen, bietet Lambda ein langlebiges Ausführungs-SDK. Das SDK reduziert die Komplexität der Verwaltung von Checkpoints und der Wiedergabe und macht einfache Primitive verfügbar, die als dauerhafte Operationen bezeichnet werden und die Sie in Ihrem Code verwenden. Das SDK ist für JavaScript, TypeScript, Python und Java (Preview) verfügbar und lässt sich nahtlos in Ihren bestehenden Lambda-Entwicklungsworkflow integrieren.
Mit dem SDK umschließen Sie Ihren Lambda-Event-Handler, der dann DurableContext neben Ihrem Event einen bereitstellt. Dieser Kontext ermöglicht Ihnen den Zugriff auf dauerhafte Operationen wie Steps und Waits. Sie schreiben Ihre Funktionslogik als normalen sequentiellen Code, aber anstatt Dienste direkt aufzurufen, unterteilen Sie diese Aufrufe in Schritte, um automatische Checkpoints und Wiederholungen zu ermöglichen. Wenn Sie die Ausführung unterbrechen müssen, fügen Sie Wartezeiten hinzu, die Ihre Funktion unterbrechen, ohne dass Gebühren anfallen. Das SDK kümmert sich um die gesamte Komplexität der Statusverwaltung und Wiedergabe hinter den Kulissen, sodass Ihr Code sauber und lesbar bleibt.
![\[Filter for Amazon Inspector results related to Lambda functions\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/how_durable_works.png)
## Nächste Schritte
+ [Beginnen Sie mit langlebigen Funktionen](durable-getting-started.md)
+ [Erkunden Sie das Durable Execution SDK](durable-execution-sdk.md)
+ [Dauerhafte Funktionen oder Step Functions](durable-step-functions.md)
+ [Überwachen und debuggen Sie langlebige Funktionen](durable-monitoring.md)
+ [Überprüfen Sie die Sicherheit und die Berechtigungen](durable-security.md)
+ [Folgen Sie den bewährten Methoden](durable-best-practices.md)
# Grundkonzepte
Lambda bietet eine dauerhafte Ausführung SDKs für JavaScript TypeScript, und Python. Diese SDKs bilden die Grundlage für die Erstellung dauerhafter Funktionen und bieten die Grundelemente, die Sie benötigen, um den Fortschritt zu überprüfen, Wiederholungsversuche zu verarbeiten und den Ausführungsablauf zu verwalten. Eine vollständige SDK-Dokumentation und Beispiele finden Sie unter [JavaScript/TypeScript SDK](https://github.com/aws/aws-durable-execution-sdk-js) und [Python SDK](https://github.com/aws/aws-durable-execution-sdk-python) unter GitHub.
## Dauerhafte Ausführung
Eine **dauerhafte Ausführung** stellt den gesamten Lebenszyklus einer dauerhaften Lambda-Funktion dar und verwendet einen Checkpoint- und Replay-Mechanismus, um den Fortschritt der Geschäftslogik zu verfolgen, die Ausführung zu unterbrechen und die Wiederherstellung nach Ausfällen zu gewährleisten. Wenn Funktionen nach einer Unterbrechung oder Unterbrechung wieder aufgenommen werden, werden zuvor abgeschlossene Checkpoints erneut abgespielt und die Ausführung der Funktion wird fortgesetzt.
Der Lebenszyklus kann mehrere Aufrufe einer Lambda-Funktion beinhalten, um die Ausführung abzuschließen, insbesondere nach Unterbrechungen oder nach einer Wiederherstellung nach einem Ausfall. Dieser Ansatz ermöglicht es, dass Ihre Funktion über längere Zeiträume (bis zu einem Jahr) ausgeführt wird und gleichzeitig trotz Unterbrechungen ein zuverlässiger Fortschritt gewährleistet wird.
**Wie funktioniert Replay**
Lambda führt ein laufendes Protokoll aller dauerhaften Operationen (Schritte, Wartezeiten und andere Operationen), während Ihre Funktion ausgeführt wird. Wenn Ihre Funktion angehalten werden muss oder auf eine Unterbrechung stößt, speichert Lambda dieses Checkpoint-Log und stoppt die Ausführung. Wenn es Zeit ist, fortzufahren, ruft Lambda Ihre Funktion erneut von Anfang an auf und spielt das Checkpoint-Protokoll ab, wobei abgeschlossene Operationen durch gespeicherte Werte ersetzt werden. Das bedeutet, dass Ihr Code erneut ausgeführt wird, aber zuvor abgeschlossene Schritte werden nicht erneut ausgeführt. Ihre gespeicherten Ergebnisse werden stattdessen verwendet.
Dieser Wiedergabemechanismus ist für das Verständnis langlebiger Funktionen von grundlegender Bedeutung. Ihr Code muss während der Wiedergabe deterministisch sein, was bedeutet, dass er bei denselben Eingaben dieselben Ergebnisse liefert. Vermeiden Sie Operationen mit Nebeneffekten (wie das Generieren von Zufallszahlen oder das Abrufen der aktuellen Uhrzeit) außerhalb von Schritten, da diese bei der Wiedergabe unterschiedliche Werte erzeugen und zu nicht deterministischem Verhalten führen können.
## DurableContext
**DurableContext**ist das Kontextobjekt, das Ihre dauerhafte Funktion empfängt. Es bietet Methoden für dauerhafte Operationen wie Steps und Waits, mit denen Checkpoints erstellt und der Ausführungsablauf gesteuert wird.
Ihre dauerhafte Funktion erhält `DurableContext` anstelle des Standard-Lambda-Kontextes einen:
------
#### [ TypeScript ]
```
import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const result = await context.step(async () => {
return "step completed";
});
return result;
},
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
@durable_step
def my_step(step_context, data):
# Your business logic
return result
@durable_execution
def handler(event, context: DurableContext):
result = context.step(my_step(event["data"]))
return result
```
------
Das Python-SDK für dauerhafte Funktionen verwendet synchrone Methoden und unterstützt `await` diese nicht. Das TypeScript SDK verwendet`async/await`.
## Schritte
**Steps** führt Geschäftslogik mit integrierten Wiederholungsversuchen und automatischem Checkpointing aus. Jeder Schritt speichert sein Ergebnis, sodass Ihre Funktion nach Unterbrechungen mit jedem abgeschlossenen Schritt wieder aufgenommen werden kann.
------
#### [ TypeScript ]
```
// Each step is automatically checkpointed
const order = await context.step(async () => processOrder(event));
const payment = await context.step(async () => processPayment(order));
const result = await context.step(async () => completeOrder(payment));
```
------
#### [ Python ]
```
# Each step is automatically checkpointed
order = context.step(lambda: process_order(event))
payment = context.step(lambda: process_payment(order))
result = context.step(lambda: complete_order(payment))
```
------
## Warte, Staaten
**Wartezustände** sind geplante Pausen, in denen Ihre Funktion nicht mehr läuft (und den Ladevorgang beendet), bis es Zeit ist, fortzufahren. Verwenden Sie sie, um auf Zeiträume, externe Rückrufe oder bestimmte Bedingungen zu warten.
------
#### [ TypeScript ]
```
// Wait for 1 hour without consuming resources
await context.wait({ seconds:3600 });
// Wait for external callback
const approval = await context.waitForCallback(
async (callbackId) => sendApprovalRequest(callbackId)
);
```
------
#### [ Python ]
```
# Wait for 1 hour without consuming resources
context.wait(3600)
# Wait for external callback
approval = context.wait_for_callback(
lambda callback_id: send_approval_request(callback_id)
)
```
------
Wenn Ihre Funktion auf eine Wartezeit stößt oder angehalten werden muss, speichert Lambda das Checkpoint-Log und stoppt die Ausführung. Wenn es Zeit ist, fortzufahren, ruft Lambda Ihre Funktion erneut auf und spielt das Checkpoint-Protokoll erneut ab, wobei abgeschlossene Operationen durch gespeicherte Werte ersetzt werden.
Für komplexere Workflows verfügen langlebige Lambda-Funktionen auch über erweiterte Operationen wie `parallel()` die gleichzeitige Ausführung, die Verarbeitung von Arrays, `map()` für verschachtelte Operationen und `runInChildContext()` für Abfragen. `waitForCondition()` In den [Beispielen](durable-examples.md) finden Sie ausführliche Beispiele und Anleitungen zur Verwendung der einzelnen Operationen.
## Andere Funktionen aufrufen
**Invoke** ermöglicht es einer dauerhaften Funktion, andere Lambda-Funktionen aufzurufen und auf deren Ergebnisse zu warten. Die aufrufende Funktion wird angehalten, während die aufgerufene Funktion ausgeführt wird, wodurch ein Checkpoint erstellt wird, der das Ergebnis beibehält. Auf diese Weise können Sie modulare Workflows erstellen, in denen spezielle Funktionen bestimmte Aufgaben erledigen.
Wird verwendet`context.invoke()`, um andere Funktionen aus Ihrer dauerhaften Funktion heraus aufzurufen. Der Aufruf hat einen Checkpoint. Wenn Ihre Funktion also unterbrochen wird, nachdem die aufgerufene Funktion abgeschlossen ist, wird sie mit dem gespeicherten Ergebnis fortgesetzt, ohne die Funktion erneut aufzurufen.
------
#### [ TypeScript ]
```
// Invoke another function and wait for result
const customerData = await context.invoke(
'validate-customer',
'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
{ customerId: event.customerId }
);
// Use the result in subsequent steps
const order = await context.step(async () => {
return processOrder(customerData);
});
```
------
#### [ Python ]
```
# Invoke another function and wait for result
customer_data = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
{'customerId': event['customerId']},
name='validate-customer'
)
# Use the result in subsequent steps
order = context.step(
lambda: process_order(customer_data),
name='process-order'
)
```
------
Die aufgerufene Funktion kann entweder eine dauerhafte oder eine Standard-Lambda-Funktion sein. Wenn Sie eine dauerhafte Funktion aufrufen, wartet die aufrufende Funktion, bis die vollständige Ausführung der dauerhaften Funktion abgeschlossen ist. Dieses Muster ist in Microservices-Architekturen üblich, bei denen jede Funktion eine bestimmte Domäne verwaltet, sodass Sie komplexe Workflows aus speziellen, wiederverwendbaren Funktionen zusammenstellen können.
**Anmerkung**
Kontoübergreifende Aufrufe werden nicht unterstützt. Die aufgerufene Funktion muss sich in demselben AWS Konto wie die aufrufende Funktion befinden.
## Dauerhafte Funktionskonfiguration
Dauerhafte Funktionen verfügen über spezifische Konfigurationseinstellungen, die das Ausführungsverhalten und die Datenspeicherung steuern. Diese Einstellungen unterscheiden sich von der standardmäßigen Lambda-Funktionskonfiguration und gelten für den gesamten Durable Execution-Lebenszyklus.
Das **DurableConfig**Objekt definiert die Konfiguration für dauerhafte Funktionen:
```
{
"ExecutionTimeout": Integer,
"RetentionPeriodInDays": Integer
}
```
### Ausführungstimeout
Das **Ausführungs-Timeout** steuert, wie lange eine dauerhafte Ausführung von Anfang bis Ende laufen kann. Dies unterscheidet sich vom Lambda-Funktions-Timeout, das steuert, wie lange ein einzelner Funktionsaufruf ausgeführt werden kann.
Eine dauerhafte Ausführung kann mehrere Lambda-Funktionsaufrufen umfassen, während sie Checkpoints, Wartezeiten und Wiederholungen durchläuft. Das Ausführungs-Timeout gilt für die gesamte verstrichene Zeit der dauerhaften Ausführung, nicht für einzelne Funktionsaufrufen.
**Den Unterschied verstehen**
Das Timeout der Lambda-Funktion (maximal 15 Minuten) begrenzt jeden einzelnen Aufruf Ihrer Funktion. Das dauerhafte Ausführungstimeout (maximal 1 Jahr) begrenzt die Gesamtzeit vom Start der Ausführung bis zum Abschluss, zum Fehlschlagen oder zum Timeout. Während dieses Zeitraums kann Ihre Funktion mehrmals aufgerufen werden, da sie Schritte verarbeitet, wartet und nach Ausfällen wieder hergestellt wird.
Wenn Sie beispielsweise ein dauerhaftes Ausführungstimeout von 24 Stunden und ein Lambda-Funktions-Timeout von 5 Minuten festlegen:
+ Jeder Funktionsaufruf muss innerhalb von 5 Minuten abgeschlossen sein
+ Die gesamte dauerhafte Ausführung kann bis zu 24 Stunden dauern
+ Ihre Funktion kann während dieser 24 Stunden viele Male aufgerufen werden
+ Wartevorgänge werden nicht auf den Timeout der Lambda-Funktion angerechnet, sondern auf den Ausführungs-Timeout.
Sie können das Ausführungstimeout konfigurieren, wenn Sie eine dauerhafte Funktion mit der Lambda-Konsole erstellen, AWS CLI, oder. AWS SAM Wählen Sie in der Lambda-Konsole Ihre Funktion und dann Konfiguration, Dauerhafte Ausführung aus. Legen Sie den Wert für das Ausführungs-Timeout in Sekunden fest (Standard: 86400 Sekunden/24 Stunden, Minimum: 60 Sekunden, Maximum: 31536000 Sekunden/1 Jahr).
**Anmerkung**
Das Ausführungs-Timeout und das Lambda-Funktions-Timeout sind unterschiedliche Einstellungen. Das Timeout der Lambda-Funktion steuert, wie lange jeder einzelne Aufruf ausgeführt werden kann (maximal 15 Minuten). Das Ausführungs-Timeout steuert die gesamte verstrichene Zeit für die gesamte dauerhafte Ausführung (maximal 1 Jahr).
### Aufbewahrungszeitraum
Die **Aufbewahrungsfrist** steuert, wie lange Lambda den Ausführungsverlauf und die Checkpoint-Daten nach Abschluss einer dauerhaften Ausführung aufbewahrt. Zu diesen Daten gehören die Schrittergebnisse, der Ausführungsstatus und das vollständige Checkpoint-Protokoll.
Nach Ablauf der Aufbewahrungsfrist löscht Lambda den Ausführungsverlauf und die Checkpoint-Daten. Sie können keine Ausführungsdetails mehr abrufen oder die Ausführung erneut abspielen. Die Aufbewahrungsfrist beginnt, wenn die Ausführung einen Terminalstatus erreicht hat (SUCCEED, FAILED, STOPPED oder TIMED\$1OUT).
Sie können den Aufbewahrungszeitraum konfigurieren, wenn Sie eine dauerhafte Funktion mit der Lambda-Konsole erstellen, AWS CLI, oder AWS SAM. Wählen Sie in der Lambda-Konsole Ihre Funktion und dann Konfiguration, Dauerhafte Ausführung aus. Legen Sie den Wert für den Aufbewahrungszeitraum in Tagen fest (Standard: 14 Tage, Minimum: 1 Tag, Maximum: 90 Tage).
Wählen Sie einen Aufbewahrungszeitraum, der auf Ihren Compliance-Anforderungen, Debugging-Anforderungen und Kostenerwägungen basiert. Längere Aufbewahrungszeiträume bieten mehr Zeit für Debugging und Audits, erhöhen jedoch die Speicherkosten.
## Weitere Informationen finden Sie auch unter
+ [Dauerhafte Funktionen oder Step Functions](durable-step-functions.md) — Vergleichen Sie langlebige Funktionen mit Step Functions, um herauszufinden, wann jeder Ansatz am effektivsten ist.
# 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)
# Dauerhafte Funktionen oder Step Functions
Beide Funktionen von Lambda sind dauerhaft und AWS Step Functions ermöglichen eine zuverlässige Workflow-Orchestrierung mit automatischem Statusmanagement und Wiederherstellung nach einem Ausfall. Sie dienen unterschiedlichen Entwicklerpräferenzen und Architekturmustern. Dauerhafte Funktionen sind für die Anwendungsentwicklung in Lambda optimiert, während Step Functions für die dienstübergreifende AWS Workflow-Orchestrierung konzipiert ist.
## Wann sollten langlebige Funktionen verwendet werden
Verwenden Sie dauerhafte Funktionen, wenn:
+ Ihr Team bevorzugt Standardprogrammiersprachen und vertraute Entwicklungstools
+ Ihre Anwendungslogik befindet sich hauptsächlich in Lambda-Funktionen
+ Sie möchten eine genaue Kontrolle über den Ausführungsstatus im Code
+ Sie entwickeln Lambda-zentrierte Anwendungen mit enger Kopplung zwischen Workflow und Geschäftslogik
+ Sie möchten schnell iterieren, ohne zwischen Code und Designern hin- und herwechseln zu müssen visual/JSON
## Wann sollte Step Functions verwendet werden?
Verwenden Sie Step Functions, wenn:
+ Sie benötigen eine visuelle Workflow-Darstellung für teamübergreifende Sichtbarkeit
+ Sie orchestrieren mehrere AWS Dienste und wünschen sich native Integrationen ohne benutzerdefinierten SDK-Code
+ Sie benötigen eine wartungsfreie Infrastruktur (kein Patchen, Runtime-Updates)
+ Nicht technisch versierte Akteure müssen die Workflow-Logik verstehen und validieren
## Entscheidungsrahmen
Ermitteln Sie anhand der folgenden Fragen, welcher Service zu Ihrem Anwendungsfall passt:
+ **Was ist Ihr Hauptaugenmerk?** Anwendungsentwicklung in Lambda → langlebige Funktionen. Workflow-Orchestrierung über AWS → Step Functions hinweg.
+ **Was ist Ihr bevorzugtes Programmiermodell?** Standard-Programmiersprachen → langlebige Funktionen. Graphbasiertes DSL oder visueller Designer → Step Functions.
+ **Wie viele AWS Dienste sind betroffen?** In erster Linie Lambda → langlebige Funktionen. Mehrere AWS Dienste → Step Functions.
+ **Welche Entwicklungstools verwenden Sie?** Erfahrung als Lambda-Entwickler, IDE mit LLM-Agent, programmiersprachenspezifische Unit-Test-Frameworks,, AWS SAM AWS CDK, AWS Toolkit → langlebige Funktionen. Visual Workflow Builder, AWS CDK um Workflows zu modellieren → Step Functions.
+ **Wer verwaltet die Infrastruktur?** Sie wünschen sich Flexibilität innerhalb von Lambda → langlebige Funktionen. Sie möchten vollständig verwaltete, wartungsfreie → Step Functions.
## Funktionsvergleich
In der folgenden Tabelle werden die wichtigsten Funktionen von Step Functions und Lambda Durable Functions verglichen:
| Feature | AWS Step Functions | Langlebige Lambda-Funktionen |
| --- | --- | --- |
| Primärer Fokus | Workflow-Orchestrierung auf allen Ebenen AWS | Anwendungsentwicklung in Lambda |
| Servicetyp | Eigenständiger, dedizierter Workflow-Service | Läuft innerhalb von Lambda |
| Programmiermodell | Graphbasiert, DSL in den Amazon-Staaten oder AWS CDK | Standard-Programmiersprachen (JavaScript/TypeScript, Python) |
| Entwicklungstools | Visual Builder in der Konsole// AWS Toolkit-IDE-Erweiterung, AWS CDK | Lambda DX innerhalb von IDE- und LLM-Agenten, Unit-Test-Frameworks AWS SAM, AWS Toolkit-IDE-Erweiterung |
| Integrationen | Über 220 AWS Dienste, 16.000 APIs | Modellerweiterung für ereignisgesteuerte Lambda-Programmierung (Ereignisquellen) |
| Verwaltung | Vollständig verwaltet, laufzeitunabhängig, wartungsfrei (kein Patchen, Runtime-Updates) | In der Lambda-Umgebung verwaltet |
| Am besten geeignet für | Geschäftsprozess- und IT-Automatisierung, Datenverarbeitung, KI-Workflows | Verteilte Transaktionen, zustandsorientierte Anwendungslogik, Funktionsorchestrierung, Datenverarbeitung, KI-Workflows |
## Hybride Architekturen
Viele Anwendungen profitieren von der Nutzung beider Dienste. Ein gängiges Muster ist die Verwendung dauerhafter Funktionen für die Logik auf Anwendungsebene innerhalb von Lambda, während Step Functions Workflows auf hoher Ebene über mehrere AWS Dienste hinweg koordiniert, die über Lambda-Funktionen hinausgehen.
## Überlegungen zur Migration
**Einfach anfangen, komplex werden:** Beginnen Sie mit dauerhaften Funktionen für Lambda-zentrierte Workflows. Fügen Sie Step Functions hinzu, wenn Sie Multiservice-Orchestrierung oder visuelles Workflow-Design benötigen.
**Bestehende Step Functions-Benutzer:** Keep Step Functions für etablierte dienstübergreifende Workflows. Ziehen Sie langlebige Funktionen für eine neue Lambda-Anwendungslogik in Betracht, die Zuverlässigkeit erfordert.
## Zugehörige Ressourcen
+ [Langlebige Lambda-Funktionen](durable-functions.md)
+ [Orchestrierung von Lambda-Funktionen mit Step Functions](with-step-functions.md)
+ [Erste Schritte mit dauerhaften Funktionen](durable-getting-started.md)
# Beispiele und Anwendungsfälle
Mit den dauerhaften Lambda-Funktionen können Sie fehlertolerante, mehrstufige Anwendungen mit dauerhaften Vorgängen wie Steps und Waits erstellen. Mit automatischem Checkpointing und einem Checkpoint-Replay-Modell, bei dem die Ausführung nach einem Ausfall wieder von vorne beginnt, abgeschlossene Checkpoints jedoch überspringt, können Ihre Funktionen nach Ausfällen wiederhergestellt und die Ausführung wieder aufgenommen werden, ohne dass der Fortschritt verloren geht.
## Kurzlebige fehlertolerante Prozesse
Verwenden Sie langlebige Funktionen, um zuverlässige Abläufe aufzubauen, die in der Regel innerhalb von Minuten abgeschlossen werden. Diese Prozesse sind zwar kürzer als langwierige Workflows, profitieren aber dennoch von automatischem Checkpoint und Fehlertoleranz in verteilten Systemen. Zuverlässige Funktionen tragen dazu bei, dass Ihre mehrstufigen Prozesse auch dann erfolgreich abgeschlossen werden, wenn einzelne Serviceanrufe fehlschlagen, ohne dass komplexe Fehlerbehandlungs- oder Statusverwaltungscodes erforderlich sind.
Zu den gängigen Szenarien gehören Hotelbuchungssysteme, Restaurantreservierungsplattformen, Anfragen für Mitfahrgelegenheiten, der Kauf von Veranstaltungstickets und SaaS-Abonnement-Upgrades. Diese Szenarien weisen gemeinsame Merkmale auf: mehrere Serviceanrufe, die zusammen abgeschlossen werden müssen, die Notwendigkeit, bei vorübergehenden Ausfällen automatische Wiederholungsversuche durchzuführen, und die Anforderung, einen konsistenten Status über verteilte Systeme hinweg aufrechtzuerhalten.
### Verteilte Transaktionen über Microservices
Koordinieren Sie Zahlungen, Inventar und Versand für mehrere Dienste mit automatischem Rollback bei Ausfällen. Jeder Servicevorgang ist in einem Schritt zusammengefasst, sodass sichergestellt wird, dass die Transaktion jederzeit wiederhergestellt werden kann, falls ein Service ausfällt.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { orderId, amount, items } = event;
// Reserve inventory across multiple warehouses
const inventory = await context.step("reserve-inventory", async () => {
return await inventoryService.reserve(items);
});
// Process payment
const payment = await context.step("process-payment", async () => {
return await paymentService.charge(amount);
});
// Create shipment
const shipment = await context.step("create-shipment", async () => {
return await shippingService.createShipment(orderId, inventory);
});
return { orderId, status: 'completed', shipment };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
amount = event['amount']
items = event['items']
# Reserve inventory across multiple warehouses
inventory = context.step(
lambda _: inventory_service.reserve(items),
name='reserve-inventory'
)
# Process payment
payment = context.step(
lambda _: payment_service.charge(amount),
name='process-payment'
)
# Create shipment
shipment = context.step(
lambda _: shipping_service.create_shipment(order_id, inventory),
name='create-shipment'
)
return {'orderId': order_id, 'status': 'completed', 'shipment': shipment}
```
------
Schlägt ein Schritt fehl, wiederholt die Funktion den Vorgang automatisch vom letzten erfolgreichen Checkpoint aus. Die Inventarreservierung bleibt auch dann bestehen, wenn die Zahlungsabwicklung vorübergehend fehlschlägt. Wenn die Funktion es erneut versucht, überspringt sie den abgeschlossenen Inventarisierungsschritt und fährt direkt mit der Zahlungsabwicklung fort. Dadurch werden doppelte Reservierungen vermieden und ein einheitlicher Status in Ihrem gesamten verteilten System gewährleistet.
### Auftragsabwicklung mit mehreren Schritten
Bearbeiten Sie Bestellungen durch Validierung, Zahlungsautorisierung, Inventarzuweisung und Versand mit automatischer Wiederholung und Wiederherstellung. Jeder Schritt wird überprüft, sodass sichergestellt wird, dass die Bestellung auch dann bearbeitet wird, wenn einzelne Schritte fehlschlagen und es erneut versucht wird.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { orderId, customerId, items } = event;
// Validate order details
const validation = await context.step("validate-order", async () => {
const customer = await customerService.validate(customerId);
const itemsValid = await inventoryService.validateItems(items);
return { customer, itemsValid };
});
if (!validation.itemsValid) {
return { orderId, status: 'rejected', reason: 'invalid_items' };
}
// Authorize payment
const authorization = await context.step("authorize-payment", async () => {
return await paymentService.authorize(
validation.customer.paymentMethod,
calculateTotal(items)
);
});
// Allocate inventory
const allocation = await context.step("allocate-inventory", async () => {
return await inventoryService.allocate(items);
});
// Fulfill order
const fulfillment = await context.step("fulfill-order", async () => {
return await fulfillmentService.createShipment({
orderId,
items: allocation.allocatedItems,
address: validation.customer.shippingAddress
});
});
return {
orderId,
status: 'completed',
trackingNumber: fulfillment.trackingNumber
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
customer_id = event['customerId']
items = event['items']
# Validate order details
def validate_order(_):
customer = customer_service.validate(customer_id)
items_valid = inventory_service.validate_items(items)
return {'customer': customer, 'itemsValid': items_valid}
validation = context.step(validate_order, name='validate-order')
if not validation['itemsValid']:
return {'orderId': order_id, 'status': 'rejected', 'reason': 'invalid_items'}
# Authorize payment
authorization = context.step(
lambda _: payment_service.authorize(
validation['customer']['paymentMethod'],
calculate_total(items)
),
name='authorize-payment'
)
# Allocate inventory
allocation = context.step(
lambda _: inventory_service.allocate(items),
name='allocate-inventory'
)
# Fulfill order
fulfillment = context.step(
lambda _: fulfillment_service.create_shipment({
'orderId': order_id,
'items': allocation['allocatedItems'],
'address': validation['customer']['shippingAddress']
}),
name='fulfill-order'
)
return {
'orderId': order_id,
'status': 'completed',
'trackingNumber': fulfillment['trackingNumber']
}
```
------
Dieses Muster stellt sicher, dass Bestellungen niemals in Zwischenzuständen stecken bleiben. Schlägt die Validierung fehl, wird die Bestellung vor der Zahlungsautorisierung abgelehnt. Wenn die Zahlungsautorisierung fehlschlägt, wird kein Inventar zugewiesen. Jeder Schritt baut auf dem vorherigen auf und bietet automatische Wiederholungen und Wiederherstellungen.
**Hinweis**
Die bedingte Prüfung `if (!validation.itemsValid)` befindet sich außerhalb eines Schritts und wird während der Wiedergabe erneut ausgeführt. Das ist sicher, weil es deterministisch ist — es liefert immer dasselbe Ergebnis bei demselben Überprüfungsobjekt.
## Prozesse mit langer Laufzeit
Verwenden Sie langlebige Funktionen für Prozesse, die sich über Stunden, Tage oder Wochen erstrecken. Wartevorgänge unterbrechen die Ausführung, ohne dass Rechenkosten anfallen, wodurch Prozesse mit langer Laufzeit kostengünstig werden. Während Wartezeiten wird Ihre Funktion nicht mehr ausgeführt und Lambda recycelt die Ausführungsumgebung. Wenn es Zeit ist, fortzufahren, ruft Lambda Ihre Funktion erneut auf und spielt sie ab dem letzten Checkpoint erneut ab.
Dieses Ausführungsmodell macht langlebige Funktionen ideal für Prozesse, die über einen längeren Zeitraum unterbrochen werden müssen, unabhängig davon, ob sie auf menschliche Entscheidungen, externe Systemreaktionen, geplante Verarbeitungsfenster oder zeitbedingte Verzögerungen warten. Sie zahlen nur für aktive Rechenzeit, nicht für Wartezeiten.
Zu den gängigen Szenarien gehören Prozesse zur Genehmigung von Dokumenten, geplante Stapelverarbeitung, mehrtägige Onboarding-Prozesse, Abonnement-Testprozesse und Systeme für verzögerte Benachrichtigungen. Diese Szenarien haben gemeinsame Merkmale: längere Wartezeiten, gemessen in Stunden oder Tagen, die Notwendigkeit, den Ausführungsstatus während dieser Wartezeiten beizubehalten, und kostensensible Anforderungen, bei denen es unerschwinglich ist, für ungenutzte Rechenzeit zu bezahlen.
### Human-in-the-loop Zulassungen
Unterbrechen Sie die Ausführung für Dokumentenprüfungen, Genehmigungen oder Entscheidungen und behalten Sie dabei den Ausführungsstatus bei. Die Funktion wartet auf externe Rückrufe, ohne Ressourcen zu verbrauchen, und wird automatisch fortgesetzt, wenn die Genehmigung eingeht.
Dieses Muster ist wichtig für Prozesse, die menschliches Urteilsvermögen oder externe Validierung erfordern. Die Funktion wird am Rückrufpunkt unterbrochen, sodass während des Wartens keine Rechenkosten anfallen. Wenn jemand seine Entscheidung über die API übermittelt, ruft Lambda Ihre Funktion erneut auf und spielt sie vom Checkpoint aus erneut ab, wobei das Genehmigungsergebnis angezeigt wird.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { documentId, reviewers } = event;
// Step 1: Prepare document for review
const prepared = await context.step("prepare-document", async () => {
return await documentService.prepare(documentId);
});
// Step 2: Request approval with callback
const approval = await context.waitForCallback(
"approval-callback",
async (callbackId) => {
await notificationService.sendApprovalRequest({
documentId,
reviewers,
callbackId,
expiresIn: 86400
});
},
{
timeout: { seconds: 86400 }
}
);
// Function resumes here when approval is received
if (approval?.approved) {
const finalized = await context.step("finalize-document", async () => {
return await documentService.finalize(documentId, approval.comments);
});
return {
status: 'approved',
documentId,
finalizedAt: finalized.timestamp
};
}
// Handle rejection
await context.step("archive-rejected", async () => {
await documentService.archive(documentId, approval?.reason);
});
return {
status: 'rejected',
documentId,
reason: approval?.reason
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution, WaitConfig
@durable_execution
def lambda_handler(event, context: DurableContext):
document_id = event['documentId']
reviewers = event['reviewers']
# Step 1: Prepare document for review
prepared = context.step(
lambda _: document_service.prepare(document_id),
name='prepare-document'
)
# Step 2: Request approval with callback
def send_approval_request(callback_id):
notification_service.send_approval_request({
'documentId': document_id,
'reviewers': reviewers,
'callbackId': callback_id,
'expiresIn': 86400
})
approval = context.wait_for_callback(
send_approval_request,
name='approval-callback',
config=WaitConfig(timeout=86400)
)
# Function resumes here when approval is received
if approval and approval.get('approved'):
finalized = context.step(
lambda _: document_service.finalize(document_id, approval.get('comments')),
name='finalize-document'
)
return {
'status': 'approved',
'documentId': document_id,
'finalizedAt': finalized['timestamp']
}
# Handle rejection
context.step(
lambda _: document_service.archive(document_id, approval.get('reason') if approval else None),
name='archive-rejected'
)
return {
'status': 'rejected',
'documentId': document_id,
'reason': approval.get('reason') if approval else None
}
```
------
Wenn der Rückruf eingeht und Ihre Funktion wieder aufgenommen wird, wird er von Anfang an wiedergegeben. Der Schritt „Dokument vorbereiten“ gibt sofort das Ergebnis der Prüfung zurück. Der waitForCallback Vorgang kehrt außerdem sofort mit dem gespeicherten Genehmigungsergebnis zurück, anstatt erneut zu warten. Die Ausführung wird dann mit den Finalisierungs- oder Archivierungsschritten fortgesetzt.
### Mehrstufige Datenleitungen
Verarbeiten Sie große Datensätze durch Extraktions-, Transformations- und Ladephasen mit Checkpoints zwischen den Phasen. Jede Phase kann Stunden in Anspruch nehmen, und Checkpoints ermöglichen es, dass die Pipeline bei einer Unterbrechung aus jeder Phase wieder aufgenommen werden kann.
Dieses Muster ist ideal für ETL-Workflows, Datenmigrationen oder Batch-Verarbeitungsaufträge, bei denen Sie Daten stufenweise mit Wiederherstellungspunkten zwischen ihnen verarbeiten müssen. Wenn eine Phase fehlschlägt, wird die Pipeline mit der letzten abgeschlossenen Phase fortgesetzt, anstatt von vorne neu zu starten. Sie können Warteoperationen auch verwenden, um zwischen den Phasen eine Pause einzulegen. Dabei können Sie Ratenbegrenzungen einhalten, warten, bis nachgelagerte Systeme bereit sind, oder die Verarbeitung außerhalb der Spitzenzeiten planen.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { datasetId, batchSize } = event;
// Stage 1: Extract data from source
const extracted = await context.step("extract-data", async () => {
const records = await sourceDatabase.extractRecords(datasetId);
return { recordCount: records.length, records };
});
// Wait 5 minutes to respect source system rate limits
await context.wait({ seconds: 300 });
// Stage 2: Transform data in batches
const transformed = await context.step("transform-data", async () => {
const batches = chunkArray(extracted.records, batchSize);
const results = [];
for (const batch of batches) {
const transformed = await transformService.processBatch(batch);
results.push(transformed);
}
return { batchCount: batches.length, results };
});
// Wait until off-peak hours (e.g., 2 AM)
const now = new Date();
const targetHour = 2;
const msUntilTarget = calculateMsUntilHour(now, targetHour);
await context.wait({ seconds: Math.floor(msUntilTarget / 1000) });
// Stage 3: Load data to destination
const loaded = await context.step("load-data", async () => {
let loadedCount = 0;
for (const result of transformed.results) {
await destinationDatabase.loadBatch(result);
loadedCount += result.length;
}
return { loadedCount };
});
// Stage 4: Verify and finalize
const verified = await context.step("verify-pipeline", async () => {
const verification = await destinationDatabase.verifyRecords(datasetId);
await pipelineService.markComplete(datasetId, verification);
return verification;
});
return {
datasetId,
recordsProcessed: extracted.recordCount,
batchesProcessed: transformed.batchCount,
recordsLoaded: loaded.loadedCount,
verified: verified.success
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
from datetime import datetime
@durable_execution
def lambda_handler(event, context: DurableContext):
dataset_id = event['datasetId']
batch_size = event['batchSize']
# Stage 1: Extract data from source
def extract_data(_):
records = source_database.extract_records(dataset_id)
return {'recordCount': len(records), 'records': records}
extracted = context.step(extract_data, name='extract-data')
# Wait 5 minutes to respect source system rate limits
context.wait(300)
# Stage 2: Transform data in batches
def transform_data(_):
batches = chunk_array(extracted['records'], batch_size)
results = []
for batch in batches:
transformed = transform_service.process_batch(batch)
results.append(transformed)
return {'batchCount': len(batches), 'results': results}
transformed = context.step(transform_data, name='transform-data')
# Wait until off-peak hours (e.g., 2 AM)
now = datetime.now()
target_hour = 2
ms_until_target = calculate_ms_until_hour(now, target_hour)
context.wait(ms_until_target // 1000)
# Stage 3: Load data to destination
def load_data(_):
loaded_count = 0
for result in transformed['results']:
destination_database.load_batch(result)
loaded_count += len(result)
return {'loadedCount': loaded_count}
loaded = context.step(load_data, name='load-data')
# Stage 4: Verify and finalize
def verify_pipeline(_):
verification = destination_database.verify_records(dataset_id)
pipeline_service.mark_complete(dataset_id, verification)
return verification
verified = context.step(verify_pipeline, name='verify-pipeline')
return {
'datasetId': dataset_id,
'recordsProcessed': extracted['recordCount'],
'batchesProcessed': transformed['batchCount'],
'recordsLoaded': loaded['loadedCount'],
'verified': verified['success']
}
```
------
Jede Phase ist in einem Schritt zusammengefasst, wodurch ein Checkpoint entsteht, über den die Pipeline bei einer Unterbrechung aus jeder Phase wieder aufgenommen werden kann. Bei der 5-minütigen Wartezeit zwischen Extrahieren und Transformieren werden die Geschwindigkeitsbegrenzungen des Quellsystems eingehalten, ohne Rechenressourcen zu verbrauchen, während bei der Wartezeit bis 2 Uhr der teure Ladevorgang außerhalb der Spitzenzeiten geplant wird.
**Hinweis**
Der `new Date()` Aufruf und die `calculateMsUntilHour()` Funktion befinden sich außerhalb von Schritten und werden während der Wiedergabe erneut ausgeführt. Für zeitbasierte Operationen, die bei allen Wiederholungen konsistent sein müssen, berechnen Sie den Zeitstempel innerhalb eines Schritts oder verwenden Sie ihn nur für Wartezeiten (die mit Checkpoints versehen sind).
## Fortgeschrittene Muster
Verwenden Sie langlebige Funktionen, um komplexe mehrstufige Anwendungen zu erstellen, die mehrere dauerhafte Operationen, parallel Ausführung, Array-Verarbeitung, bedingte Logik und Polling kombinieren. Mit diesen Mustern können Sie anspruchsvolle Anwendungen erstellen, die viele Aufgaben koordinieren und gleichzeitig die Fehlertoleranz und die automatische Wiederherstellung wahren.
Fortgeschrittene Muster gehen über einfache sequentielle Schritte hinaus. Sie können Operationen gleichzeitig mit diesen Primitiven ausführen`parallel()`, Arrays mit verarbeiten`map()`, auf externe Bedingungen warten und diese Primitive kombinieren`waitForCondition()`, um zuverlässige Anwendungen zu erstellen. Jeder dauerhafte Vorgang erstellt seine eigenen Prüfpunkte, sodass Ihre Anwendung bei einer Unterbrechung jederzeit wiederhergestellt werden kann.
### Onboarding-Prozesse für Benutzer
Führen Sie Benutzer durch die Registrierung, E-Mail-Überprüfung, Profileinrichtung und Erstkonfiguration mit Wiederholungsversuchen. In diesem Beispiel werden aufeinanderfolgende Schritte, Rückrufe und bedingte Logik kombiniert, um einen vollständigen Onboarding-Prozess zu erstellen.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { userId, email } = event;
// Step 1: Create user account
const user = await context.step("create-account", async () => {
return await userService.createAccount(userId, email);
});
// Step 2: Send verification email
await context.step("send-verification", async () => {
return await emailService.sendVerification(email);
});
// Step 3: Wait for email verification (up to 48 hours)
const verified = await context.waitForCallback(
"email-verification",
async (callbackId) => {
await notificationService.sendVerificationLink({
email,
callbackId,
expiresIn: 172800
});
},
{
timeout: { seconds: 172800 }
}
);
if (!verified) {
await context.step("send-reminder", async () => {
await emailService.sendReminder(email);
});
return {
status: "verification_timeout",
userId,
message: "Email verification not completed within 48 hours"
};
}
// Step 4: Initialize user profile in parallel
const setupResults = await context.parallel("profile-setup", [
async (ctx: DurableContext) => {
return await ctx.step("create-preferences", async () => {
return await preferencesService.createDefaults(userId);
});
},
async (ctx: DurableContext) => {
return await ctx.step("setup-notifications", async () => {
return await notificationService.setupDefaults(userId);
});
},
async (ctx: DurableContext) => {
return await ctx.step("create-welcome-content", async () => {
return await contentService.createWelcome(userId);
});
}
]);
// Step 5: Send welcome email
await context.step("send-welcome", async () => {
const [preferences, notifications, content] = setupResults.getResults();
return await emailService.sendWelcome({
email,
preferences,
notifications,
content
});
});
return {
status: "onboarding_complete",
userId,
completedAt: new Date().toISOString()
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution, WaitConfig
from datetime import datetime
@durable_execution
def lambda_handler(event, context: DurableContext):
user_id = event['userId']
email = event['email']
# Step 1: Create user account
user = context.step(
lambda _: user_service.create_account(user_id, email),
name='create-account'
)
# Step 2: Send verification email
context.step(
lambda _: email_service.send_verification(email),
name='send-verification'
)
# Step 3: Wait for email verification (up to 48 hours)
def send_verification_link(callback_id):
notification_service.send_verification_link({
'email': email,
'callbackId': callback_id,
'expiresIn': 172800
})
verified = context.wait_for_callback(
send_verification_link,
name='email-verification',
config=WaitConfig(timeout=172800)
)
if not verified:
context.step(
lambda _: email_service.send_reminder(email),
name='send-reminder'
)
return {
'status': 'verification_timeout',
'userId': user_id,
'message': 'Email verification not completed within 48 hours'
}
# Step 4: Initialize user profile in parallel
def create_preferences(ctx: DurableContext):
return ctx.step(
lambda _: preferences_service.create_defaults(user_id),
name='create-preferences'
)
def setup_notifications(ctx: DurableContext):
return ctx.step(
lambda _: notification_service.setup_defaults(user_id),
name='setup-notifications'
)
def create_welcome_content(ctx: DurableContext):
return ctx.step(
lambda _: content_service.create_welcome(user_id),
name='create-welcome-content'
)
setup_results = context.parallel(
[create_preferences, setup_notifications, create_welcome_content],
name='profile-setup'
)
# Step 5: Send welcome email
def send_welcome(_):
results = setup_results.get_results()
preferences, notifications, content = results[0], results[1], results[2]
return email_service.send_welcome({
'email': email,
'preferences': preferences,
'notifications': notifications,
'content': content
})
context.step(send_welcome, name='send-welcome')
return {
'status': 'onboarding_complete',
'userId': user_id,
'completedAt': datetime.now().isoformat()
}
```
------
Der Prozess kombiniert aufeinanderfolgende Schritte mit Checkpoints für die Kontoerstellung und das Senden von E-Mails und wartet dann bis zu 48 Stunden lang auf die E-Mail-Bestätigung, ohne Ressourcen zu verbrauchen. Die bedingte Logik verarbeitet unterschiedliche Pfade, je nachdem, ob die Überprüfung abgeschlossen ist oder ob das Zeitlimit überschritten wird. Aufgaben zur Profileinrichtung werden gleichzeitig mit parallel Vorgängen ausgeführt, um die Gesamtausführungszeit zu reduzieren. Jeder Schritt wird bei vorübergehenden Ausfällen automatisch wiederholt, um sicherzustellen, dass das Onboarding zuverlässig abgeschlossen wird.
### Funktionsübergreifende verkettete Aufrufe
Rufen Sie andere Lambda-Funktionen aus einer dauerhaften Funktion heraus auf, indem Sie. `context.invoke()` Die aufrufende Funktion wird angehalten, während auf den Abschluss der aufgerufenen Funktion gewartet wird, wodurch ein Checkpoint erstellt wird, der das Ergebnis beibehält. Wenn die aufrufende Funktion nach Abschluss der aufgerufenen Funktion unterbrochen wird, wird sie mit dem gespeicherten Ergebnis fortgesetzt, ohne die Funktion erneut aufzurufen.
Verwenden Sie dieses Muster, wenn Sie über spezielle Funktionen verfügen, die sich mit bestimmten Bereichen befassen (Kundenvalidierung, Zahlungsabwicklung, Bestandsverwaltung) und diese in einem Workflow koordinieren müssen. Jede Funktion behält ihre eigene Logik bei und kann von mehreren Orchestrator-Funktionen aufgerufen werden, wodurch Codeduplikationen vermieden werden.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
// Main orchestrator function
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { orderId, customerId } = event;
// Step 1: Validate customer by invoking customer service function
const customer = await context.invoke(
"validate-customer",
"arn:aws:lambda:us-east-1:123456789012:function:customer-service:1",
{ customerId }
);
if (!customer.isValid) {
return { orderId, status: "rejected", reason: "invalid_customer" };
}
// Step 2: Check inventory by invoking inventory service function
const inventory = await context.invoke(
"check-inventory",
"arn:aws:lambda:us-east-1:123456789012:function:inventory-service:1",
{ orderId, items: event.items }
);
if (!inventory.available) {
return { orderId, status: "rejected", reason: "insufficient_inventory" };
}
// Step 3: Process payment by invoking payment service function
const payment = await context.invoke(
"process-payment",
"arn:aws:lambda:us-east-1:123456789012:function:payment-service:1",
{
customerId,
amount: inventory.totalAmount,
paymentMethod: customer.paymentMethod
}
);
// Step 4: Create shipment by invoking fulfillment service function
const shipment = await context.invoke(
"create-shipment",
"arn:aws:lambda:us-east-1:123456789012:function:fulfillment-service:1",
{
orderId,
items: inventory.allocatedItems,
address: customer.shippingAddress
}
);
return {
orderId,
status: "completed",
trackingNumber: shipment.trackingNumber,
estimatedDelivery: shipment.estimatedDelivery
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
# Main orchestrator function
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
customer_id = event['customerId']
# Step 1: Validate customer by invoking customer service function
customer = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
{'customerId': customer_id},
name='validate-customer'
)
if not customer['isValid']:
return {'orderId': order_id, 'status': 'rejected', 'reason': 'invalid_customer'}
# Step 2: Check inventory by invoking inventory service function
inventory = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:inventory-service:1',
{'orderId': order_id, 'items': event['items']},
name='check-inventory'
)
if not inventory['available']:
return {'orderId': order_id, 'status': 'rejected', 'reason': 'insufficient_inventory'}
# Step 3: Process payment by invoking payment service function
payment = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:payment-service:1',
{
'customerId': customer_id,
'amount': inventory['totalAmount'],
'paymentMethod': customer['paymentMethod']
},
name='process-payment'
)
# Step 4: Create shipment by invoking fulfillment service function
shipment = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:fulfillment-service:1',
{
'orderId': order_id,
'items': inventory['allocatedItems'],
'address': customer['shippingAddress']
},
name='create-shipment'
)
return {
'orderId': order_id,
'status': 'completed',
'trackingNumber': shipment['trackingNumber'],
'estimatedDelivery': shipment['estimatedDelivery']
}
```
------
Jeder Aufruf erstellt einen Checkpoint in der Orchestrator-Funktion. Wenn der Orchestrator nach Abschluss der Kundenvalidierung unterbrochen wird, wird er von diesem Checkpoint aus mit den gespeicherten Kundendaten wieder aufgenommen und der Validierungsaufruf übersprungen. Dies verhindert doppelte Aufrufe von nachgelagerten Diensten und gewährleistet eine konsistente Ausführung auch bei Unterbrechungen.
Bei den aufgerufenen Funktionen kann es sich entweder um dauerhafte Funktionen oder um Standard-Lambda-Funktionen handeln. Wenn Sie eine dauerhafte Funktion aufrufen, kann sie über einen eigenen mehrstufigen Workflow mit Wartezeiten und Checkpoints verfügen. Der Orchestrator wartet einfach darauf, dass die komplette Durable-Ausführung abgeschlossen ist, und erhält das Endergebnis.
**Anmerkung**
Kontoübergreifende Aufrufe werden nicht unterstützt. Alle aufgerufenen Funktionen müssen sich im selben AWS Konto wie die aufrufende Funktion befinden.
### Stapelverarbeitung mit Checkpoints
Verarbeiten Sie Millionen von Datensätzen mit automatischer Wiederherstellung vom letzten erfolgreichen Checkpoint nach Ausfällen. Dieses Beispiel zeigt, wie langlebige Funktionen `map()` Operationen mit Chunking und Ratenbegrenzung kombinieren, um umfangreiche Datenverarbeitungen zu bewältigen.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
interface Batch {
batchIndex: number;
recordIds: string[];
}
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { datasetId, batchSize = 1000 } = event;
// Step 1: Get all record IDs to process
const recordIds = await context.step("fetch-record-ids", async () => {
return await dataService.getRecordIds(datasetId);
});
// Step 2: Split into batches
const batches: Batch[] = [];
for (let i = 0; i < recordIds.length; i += batchSize) {
batches.push({
batchIndex: Math.floor(i / batchSize),
recordIds: recordIds.slice(i, i + batchSize)
});
}
// Step 3: Process batches with controlled concurrency
const batchResults = await context.map(
"process-batches",
batches,
async (ctx: DurableContext, batch: Batch, index: number) => {
const processed = await ctx.step(`batch-${batch.batchIndex}`, async () => {
const results = [];
for (const recordId of batch.recordIds) {
const result = await recordService.process(recordId);
results.push(result);
}
return results;
});
const validated = await ctx.step(`validate-${batch.batchIndex}`, async () => {
return await validationService.validateBatch(processed);
});
return {
batchIndex: batch.batchIndex,
recordCount: batch.recordIds.length,
successCount: validated.successCount,
failureCount: validated.failureCount
};
},
{
maxConcurrency: 5
}
);
// Step 4: Aggregate results
const summary = await context.step("aggregate-results", async () => {
const results = batchResults.getResults();
const totalSuccess = results.reduce((sum, r) => sum + r.successCount, 0);
const totalFailure = results.reduce((sum, r) => sum + r.failureCount, 0);
return {
datasetId,
totalRecords: recordIds.length,
batchesProcessed: batches.length,
successCount: totalSuccess,
failureCount: totalFailure,
completedAt: new Date().toISOString()
};
});
return summary;
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution, MapConfig
from datetime import datetime
from typing import List, Dict
@durable_execution
def lambda_handler(event, context: DurableContext):
dataset_id = event['datasetId']
batch_size = event.get('batchSize', 1000)
# Step 1: Get all record IDs to process
record_ids = context.step(
lambda _: data_service.get_record_ids(dataset_id),
name='fetch-record-ids'
)
# Step 2: Split into batches
batches = []
for i in range(0, len(record_ids), batch_size):
batches.append({
'batchIndex': i // batch_size,
'recordIds': record_ids[i:i + batch_size]
})
# Step 3: Process batches with controlled concurrency
def process_batch(ctx: DurableContext, batch: Dict, index: int):
batch_index = batch['batchIndex']
def process_records(_):
results = []
for record_id in batch['recordIds']:
result = record_service.process(record_id)
results.append(result)
return results
processed = ctx.step(process_records, name=f'batch-{batch_index}')
validated = ctx.step(
lambda _: validation_service.validate_batch(processed),
name=f'validate-{batch_index}'
)
return {
'batchIndex': batch_index,
'recordCount': len(batch['recordIds']),
'successCount': validated['successCount'],
'failureCount': validated['failureCount']
}
batch_results = context.map(
process_batch,
batches,
name='process-batches',
config=MapConfig(max_concurrency=5)
)
# Step 4: Aggregate results
def aggregate_results(_):
results = batch_results.get_results()
total_success = sum(r['successCount'] for r in results)
total_failure = sum(r['failureCount'] for r in results)
return {
'datasetId': dataset_id,
'totalRecords': len(record_ids),
'batchesProcessed': len(batches),
'successCount': total_success,
'failureCount': total_failure,
'completedAt': datetime.now().isoformat()
}
summary = context.step(aggregate_results, name='aggregate-results')
return summary
```
------
Datensätze werden in überschaubare Stapel aufgeteilt, um eine Überlastung des Speichers oder nachgelagerte Dienste zu vermeiden. Anschließend werden mehrere Batches gleichzeitig verarbeitet, wobei die Parallelität kontrolliert wird. `maxConcurrency` Jeder Stapel hat seinen eigenen Prüfpunkt, sodass bei Fehlern nur der fehlgeschlagene Stapel wiederholt wird, anstatt alle Datensätze erneut zu verarbeiten. Dieses Muster ist ideal für ETL-Jobs, Datenmigrationen oder Massenvorgänge, bei denen die Verarbeitung Stunden dauern kann.
## Nächste Schritte
+ Machen Sie sich mit [grundlegenden Konzepten](durable-basic-concepts.md) vertraut DurableContext, lernen Sie Schritte kennen und warten Sie
+ Informieren Sie sich über [bewährte Methoden](durable-best-practices.md) zum Schreiben von deterministischem Code und zur Leistungsoptimierung
+ Erfahren Sie, wie Sie [langlebige Funktionen lokal und in der Cloud testen](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).
# Sicherheit und Berechtigungen für langlebige Lambda-Funktionen
Dauerhafte Lambda-Funktionen erfordern spezielle IAM-Berechtigungen, um Checkpoint-Operationen zu verwalten. Folgen Sie dem Prinzip der geringsten Rechte, indem Sie nur die Berechtigungen gewähren, die Ihre Funktion benötigt.
## Berechtigungen für die Ausführungsrolle
Die Ausführungsrolle Ihrer dauerhaften Funktion benötigt Berechtigungen, um Checkpoints zu erstellen und den Ausführungsstatus abzurufen. Die folgende Richtlinie zeigt die mindestens erforderlichen Berechtigungen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:CheckpointDurableExecution",
"lambda:GetDurableExecutionState"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name:*"
}
]
}
```
Wenn Sie mithilfe der Konsole eine dauerhafte Funktion erstellen, fügt Lambda diese Berechtigungen automatisch der Ausführungsrolle hinzu. Wenn Sie die Funktion mit AWS CLI oder erstellen AWS CloudFormation, fügen Sie diese Berechtigungen Ihrer Ausführungsrolle hinzu.
**Prinzip der geringsten Rechte**
Beschränken Sie das `Resource` Element auf eine bestimmte Funktion, ARNs anstatt Platzhalter zu verwenden. Dies beschränkt die Ausführungsrolle auf Checkpoint-Operationen nur für die Funktionen, die sie benötigen.
**Beispiel: Eingeschränkte Berechtigungen für mehrere Funktionen**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:CheckpointDurableExecution",
"lambda:GetDurableExecutionState"
],
"Resource": [
"arn:aws:lambda:us-east-1:123456789012:function:orderProcessor:*",
"arn:aws:lambda:us-east-1:123456789012:function:paymentHandler:*"
]
}
]
}
```
Alternativ können Sie die AWS verwaltete Richtlinie verwenden, `AWSLambdaBasicDurableExecutionRolePolicy` die die erforderlichen dauerhaften Ausführungsberechtigungen zusammen mit den grundlegenden Lambda-Ausführungsberechtigungen für Amazon CloudWatch Logs umfasst.
## Staatliche Verschlüsselung
Dauerhafte Lambda-Funktionen ermöglichen automatisch und kostenlos die Verschlüsselung im Ruhezustand mithilfe AWS eigener Schlüssel. Jede Funktionsausführung behält einen isolierten Status bei, auf den andere Ausführungen nicht zugreifen können. Vom Kunden verwaltete Schlüssel (CMK) werden nicht unterstützt.
Zu den Checkpoint-Daten gehören:
+ Schrittergebnisse und Rückgabewerte
+ Ausführungsfortschritt und Zeitplan
+ Informationen zum Wartestatus
Alle Daten werden während der Übertragung mit TLS verschlüsselt, wenn Lambda Checkpoint-Daten liest oder schreibt.
### Benutzerdefinierte Verschlüsselung mit benutzerdefinierten Serialisierern und Deserialisierern
Für kritische Sicherheitsanforderungen können Sie mithilfe von benutzerdefinierten Serialisierern und Deserialisierern () mithilfe eines dauerhaften SDK Ihren eigenen Verschlüsselungs- und Entschlüsselungsmechanismus implementieren. SerDer Dieser Ansatz gibt Ihnen die volle Kontrolle über die Verschlüsselungsschlüssel und Algorithmen, die zum Schutz von Checkpoint-Daten verwendet werden.
**Wichtig**
Wenn Sie eine benutzerdefinierte Verschlüsselung verwenden, verlieren Sie die Sichtbarkeit der Betriebsergebnisse in der Lambda-Konsole und in den API-Antworten. Checkpoint-Daten erscheinen im Ausführungsverlauf verschlüsselt und können ohne Entschlüsselung nicht überprüft werden.
Die Anforderungen `kms:Encrypt` und `kms:Decrypt` Berechtigungen der Ausführungsrolle Ihrer Funktion für den AWS KMS Schlüssel, der in der benutzerdefinierten SerDer Implementierung verwendet wird.
## CloudTrail Protokollierung
Lambda protokolliert Checkpoint-Operationen als Datenereignisse. AWS CloudTrail Sie können CloudTrail damit überprüfen, wann Checkpoints erstellt werden, Änderungen des Ausführungsstatus verfolgen und den Zugriff auf dauerhafte Ausführungsdaten überwachen.
Checkpoint-Operationen werden in CloudTrail Protokollen mit den folgenden Ereignisnamen angezeigt:
+ `CheckpointDurableExecution`- Wird protokolliert, wenn ein Schritt abgeschlossen ist und ein Checkpoint erstellt wird
+ `GetDurableExecutionState`- Wird protokolliert, wenn Lambda den Ausführungsstatus während der Wiedergabe abruft
Um die Protokollierung von Datenereignissen für dauerhafte Funktionen zu aktivieren, konfigurieren Sie einen CloudTrail Trail zum Protokollieren von Lambda-Datenereignissen. Weitere Informationen finden Sie im CloudTrail Benutzerhandbuch unter [Protokollieren von Datenereignissen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html).
**Beispiel: CloudTrail Protokolleintrag für den Checkpoint-Betrieb**
```
{
"eventVersion": "1.08",
"eventTime": "2024-11-16T10:30:45Z",
"eventName": "CheckpointDurableExecution",
"eventSource": "lambda.amazonaws.com",
"requestParameters": {
"functionName": "myDurableFunction",
"executionId": "exec-abc123",
"stepId": "step-1"
},
"responseElements": null,
"eventType": "AwsApiCall"
}
```
## Kontoübergreifende Überlegungen
Wenn Sie dauerhafte Funktionen AWS kontenübergreifend aufrufen, benötigt das aufrufende Konto eine `lambda:InvokeFunction` Genehmigung, aber Checkpoint-Operationen verwenden immer die Ausführungsrolle im Konto der Funktion. Das aufrufende Konto kann nicht direkt auf Checkpoint-Daten oder den Ausführungsstatus zugreifen.
Diese Isolierung stellt sicher, dass Checkpoint-Daten innerhalb des Kontos der Funktion sicher bleiben, auch wenn sie von externen Konten aus aufgerufen werden.
## Vererbte Lambda-Sicherheitsfunktionen
Dauerhafte Funktionen übernehmen alle Sicherheits-, Governance- und Compliance-Funktionen von Lambda, einschließlich VPC-Konnektivität, Verschlüsselung mit Umgebungsvariablen, Warteschlangen mit unerlaubten Buchstaben, reservierte Parallelität, Funktions- URLs, Codesignatur- und Compliance-Zertifizierungen (SOC, PCI DSS, HIPAA usw.).
Ausführliche Informationen zu den Sicherheitsfunktionen von Lambda finden Sie unter [Sicherheit AWS Lambda im](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) Lambda Developer Guide. Die einzigen zusätzlichen Sicherheitsaspekte für dauerhafte Funktionen sind die in diesem Handbuch dokumentierten Checkpoint-Berechtigungen.
# SDK für langlebige Ausführung
Das Durable Execution SDK ist die Grundlage für die Entwicklung langlebiger Funktionen. Es bietet die Grundelemente, die Sie benötigen, um den Fortschritt zu überprüfen, Wiederholungsversuche zu verarbeiten und den Ausführungsablauf zu verwalten. Das SDK abstrahiert die Komplexität der Verwaltung und Wiedergabe von Checkpoints und ermöglicht es Ihnen, sequentiellen Code zu schreiben, der automatisch fehlertolerant wird.
Das SDK ist für JavaScript, TypeScript, Python und Java (Preview) verfügbar. Eine vollständige API-Dokumentation und Beispiele finden Sie unter [JavaScript/TypeScript SDK](https://github.com/aws/aws-durable-execution-sdk-js), [Python SDK](https://github.com/aws/aws-durable-execution-sdk-python) und [Java SDK](https://github.com/aws/aws-durable-execution-sdk-java) unter GitHub.
## DurableContext
Das SDK stellt Ihrer Funktion ein `DurableContext` Objekt zur Verfügung, das alle dauerhaften Operationen verfügbar macht. Dieser Kontext ersetzt den Standard-Lambda-Kontext und bietet Methoden zur Erstellung von Checkpoints, zur Verwaltung des Ausführungsflusses und zur Koordination mit externen Systemen.
Um das SDK zu verwenden, umschließen Sie Ihren Lambda-Handler mit dem Durable Execution Wrapper:
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Your function receives DurableContext instead of Lambda context
// Use context.step(), context.wait(), etc.
return result;
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
@durable_execution
def handler(event: dict, context: DurableContext):
# Your function receives DurableContext
# Use context.step(), context.wait(), etc.
return result
```
------
#### [ Java (Preview) ]
```
import software.amazon.lambda.durable.DurableContext;
import software.amazon.lambda.durable.DurableHandler;
public class Handler extends DurableHandler {
@Override
public String handleRequest(Object input, DurableContext context) {
// Your function receives DurableContext
// Use context.step(), context.wait(), etc.
return result;
}
}
```
------
Der Wrapper fängt Ihren Funktionsaufruf ab, lädt alle vorhandenen Checkpoint-Logs und stellt das zur Verfügung, das Replay und Checkpointing verwaltet. `DurableContext`
## Was macht das SDK
Das SDK erfüllt drei wichtige Aufgaben, die eine dauerhafte Ausführung ermöglichen:
**Checkpoint-Verwaltung:** Das SDK erstellt automatisch Checkpoints, wenn Ihre Funktion dauerhafte Operationen ausführt. Jeder Checkpoint zeichnet den Operationstyp, die Eingaben und die Ergebnisse auf. Wenn Ihre Funktion einen Schritt abgeschlossen hat, behält das SDK den Checkpoint bei, bevor der Vorgang fortgesetzt wird. Dadurch wird sichergestellt, dass Ihre Funktion nach jeder abgeschlossenen Operation wieder aufgenommen werden kann, falls sie unterbrochen wird.
**Koordination der Wiedergabe:** Wenn Ihre Funktion nach einer Pause oder Unterbrechung wieder aufgenommen wird, führt das SDK eine Wiederholung durch. Es führt Ihren Code von Anfang an aus, überspringt jedoch abgeschlossene Operationen und verwendet gespeicherte Checkpoint-Ergebnisse, anstatt sie erneut auszuführen. Das SDK stellt sicher, dass die Wiedergabe deterministisch ist. Bei denselben Eingaben und demselben Checkpoint-Log erzeugt Ihre Funktion dieselben Ergebnisse.
**Zustandsisolierung:** Das SDK behält den Ausführungsstatus getrennt von Ihrer Geschäftslogik bei. Jede dauerhafte Ausführung hat ihr eigenes Checkpoint-Protokoll, auf das andere Ausführungen nicht zugreifen können. Das SDK verschlüsselt Checkpoint-Daten im Ruhezustand und stellt sicher, dass der Status bei allen Wiederholungen konsistent bleibt.
## Wie funktioniert Checkpointing
Wenn Sie einen dauerhaften Vorgang aufrufen, folgt das SDK dieser Reihenfolge:
1. Nach einem **vorhandenen Checkpoint suchen:** Das SDK prüft, ob dieser Vorgang bereits bei einem früheren Aufruf abgeschlossen wurde. Wenn ein Checkpoint vorhanden ist, gibt das SDK das gespeicherte Ergebnis zurück, ohne den Vorgang erneut auszuführen.
1. **Führen Sie den Vorgang aus:** Wenn kein Checkpoint vorhanden ist, führt das SDK Ihren Operationscode aus. Für Schritte bedeutet das, dass Sie Ihre Funktion aufrufen. Für Wartezeiten bedeutet dies, die Wiederaufnahme zu planen.
1. **Checkpoint erstellen:** Nach Abschluss des Vorgangs serialisiert das SDK das Ergebnis und erstellt einen Checkpoint. Der Checkpoint umfasst den Operationstyp, den Namen, die Eingaben, das Ergebnis und den Zeitstempel.
1. **Checkpoint beibehalten:** Das SDK ruft die Lambda-Checkpoint-API auf, um den Checkpoint beizubehalten. Dadurch wird sichergestellt, dass der Checkpoint dauerhaft ist, bevor die Ausführung fortgesetzt wird.
1. **Ergebnis zurückgeben:** Das SDK gibt das Vorgangsergebnis an Ihren Code zurück, der mit der nächsten Operation fortgeführt wird.
Diese Reihenfolge stellt sicher, dass das Ergebnis eines Vorgangs sicher gespeichert wird, sobald er abgeschlossen ist. Wenn Ihre Funktion zu irgendeinem Zeitpunkt unterbrochen wird, kann das SDK die Wiedergabe bis zum letzten abgeschlossenen Checkpoint wiederholen.
## Verhalten bei der Wiedergabe
Wenn Ihre Funktion nach einer Pause oder Unterbrechung wieder aufgenommen wird, führt das SDK eine Wiederholung durch:
1. **Checkpoint-Log laden:** Das SDK ruft das Checkpoint-Log für diese Ausführung von Lambda ab.
1. **Von Anfang an ausführen:** Das SDK ruft Ihre Handler-Funktion von Anfang an auf, nicht an der Stelle, an der sie angehalten wurde.
1. **Abgeschlossene dauerhafte Operationen überspringen:** Da Ihr Code dauerhafte Operationen aufruft, überprüft das SDK jeden Vorgang anhand des Checkpoint-Logs. Bei abgeschlossenen dauerhaften Vorgängen gibt das SDK das gespeicherte Ergebnis zurück, ohne den Operationscode auszuführen.
**Anmerkung**
Wenn das Ergebnis eines untergeordneten Kontextes größer als die maximale Checkpoint-Größe (256 KB) war, wird der Code des Kontextes während der Wiedergabe erneut ausgeführt. Auf diese Weise können Sie aus den dauerhaften Vorgängen, die innerhalb des Kontextes ausgeführt wurden, umfangreiche Ergebnisse erstellen, die dann im Checkpoint-Log nachgeschlagen werden. Daher ist es unerlässlich, deterministischen Code nur im Kontext selbst auszuführen. Bei der Verwendung untergeordneter Kontexte mit großen Ergebnissen ist es eine bewährte Methode, lang andauernde oder nicht deterministische Arbeiten innerhalb von Schritten auszuführen und nur Aufgaben mit kurzer Laufzeit auszuführen, die die Ergebnisse im Kontext selbst kombinieren.
1. **Am Unterbrechungspunkt fortsetzen:** Wenn das SDK einen Vorgang ohne Checkpoint erreicht, wird es normal ausgeführt und erstellt neue Checkpoints, sobald dauerhafte Operationen abgeschlossen sind.
Für diesen Wiedergabemechanismus muss Ihr Code deterministisch sein. Bei denselben Eingaben und demselben Checkpoint-Log muss Ihre Funktion dieselbe Reihenfolge von dauerhaften Operationsaufrufen ausführen. Das SDK erzwingt dies, indem es bei der Wiedergabe überprüft, ob die Namen und Typen der Operationen mit dem Checkpoint-Protokoll übereinstimmen.
## Verfügbare dauerhafte Operationen
Das `DurableContext` bietet Operationen für verschiedene Koordinationsmuster. Bei jeder dauerhaften Operation werden automatisch Checkpoints erstellt, sodass Ihre Funktion an jedem beliebigen Punkt wieder aufgenommen werden kann.
### Schritte
Führt Geschäftslogik mit automatischem Checkpoint und Wiederholungsversuch aus. Verwenden Sie Schritte für Operationen, die externe Dienste aufrufen, Berechnungen durchführen oder Logik ausführen, für die ein Checkpoint erforderlich ist. Das SDK erstellt vor und nach dem Schritt einen Checkpoint und speichert das Ergebnis zur Wiederholung.
------
#### [ TypeScript ]
```
const result = await context.step('process-payment', async () => {
return await paymentService.charge(amount);
});
```
------
#### [ Python ]
```
result = context.step(
lambda _: payment_service.charge(amount),
name='process-payment'
)
```
------
#### [ Java (Preview) ]
```
var result = context.step("process-payment", Payment.class,
() -> paymentService.charge(amount)
);
```
------
Die Schritte unterstützen konfigurierbare Wiederholungsstrategien, Ausführungssemantik (at-most-once oder at-least-once) und benutzerdefinierte Serialisierung.
### Waits (Warteereignis)
Unterbricht die Ausführung für eine angegebene Dauer, ohne Rechenressourcen zu verbrauchen. Das SDK erstellt einen Checkpoint, beendet den Funktionsaufruf und plant die Wiederaufnahme. Wenn die Wartezeit abgeschlossen ist, ruft Lambda Ihre Funktion erneut auf und das SDK wiederholt die Wiedergabe bis zum Wartepunkt, bevor es fortfährt.
------
#### [ TypeScript ]
```
// Wait 1 hour without charges
await context.wait({ seconds: 3600 });
```
------
#### [ Python ]
```
# Wait 1 hour without charges
context.wait(3600)
```
------
#### [ Java (Preview) ]
```
// Wait 1 hour without charges
context.wait(Duration.ofHours(1));
```
------
### Rückrufe
Callbacks ermöglichen es Ihrer Funktion, anzuhalten und darauf zu warten, dass externe Systeme Eingaben bereitstellen. Wenn Sie einen Callback erstellen, generiert das SDK eine eindeutige Callback-ID und erstellt einen Checkpoint. Ihre Funktion wird dann unterbrochen (beendet den Aufruf), ohne dass Rechengebühren anfallen. Externe Systeme senden Rückrufergebnisse mit dem `SendDurableExecutionCallbackSuccess` oder `SendDurableExecutionCallbackFailure` APIs Lambda. Wenn ein Callback gesendet wird, ruft Lambda Ihre Funktion erneut auf, das SDK wiederholt die Wiedergabe bis zum Callback-Point und Ihre Funktion fährt mit dem Callback-Ergebnis fort.
Das SDK bietet zwei Methoden für die Arbeit mit Callbacks:
**createCallback: Erstellt einen Callback** und gibt sowohl eine Promise- als auch eine Callback-ID zurück. Sie senden die Callback-ID an ein externes System, das das Ergebnis mithilfe der Lambda-API übermittelt.
------
#### [ TypeScript ]
```
const [promise, callbackId] = await context.createCallback('approval', {
timeout: { hours: 24 }
});
await sendApprovalRequest(callbackId, requestData);
const approval = await promise;
```
------
#### [ Python ]
```
callback = context.create_callback(
name='approval',
config=CallbackConfig(timeout_seconds=86400)
)
context.step(
lambda _: send_approval_request(callback.callback_id),
name='send_request'
)
approval = callback.result()
```
------
#### [ Java (Preview) ]
```
var config = CallbackConfig.builder(Duration.ofHours(24)).timeout()
var callback = context.createCallback("approval", String.class, config);
context.step("send-request", String.class, () -> {
notificationService.sendApprovalRequest(callback.callbackId(), requestData);
return "request-sent";
});
// Blocks until the callback finishes or times out
String approval = callback.get();
```
------
**waitForCallback:** Vereinfacht die Bearbeitung von Rückrufen, indem die Erstellung und Übermittlung von Rückrufen in einem Vorgang kombiniert werden. Das SDK erstellt den Callback, führt Ihre Absenderfunktion mit der Callback-ID aus und wartet auf das Ergebnis.
------
#### [ TypeScript ]
```
const result = await context.waitForCallback(
'external-api',
async (callbackId, ctx) => {
await submitToExternalAPI(callbackId, requestData);
},
{ timeout: { minutes: 30 } }
);
```
------
#### [ Python ]
```
result = context.wait_for_callback(
lambda callback_id: submit_to_external_api(callback_id, request_data),
name='external-api',
config=WaitForCallbackConfig(timeout_seconds=1800)
)
```
------
#### [ Java (Preview) ]
waitForCallback befindet sich noch in der Entwicklung für Java.
------
Konfigurieren Sie Timeouts, um zu verhindern, dass Funktionen auf unbestimmte Zeit warten. Wenn bei einem Callback eine Zeitüberschreitung auftritt, löst das SDK eine aus `CallbackError` und Ihre Funktion kann den Timeout-Fall behandeln. Verwenden Sie Heartbeat-Timeouts für lang andauernde Rückrufe, um zu erkennen, wann externe Systeme nicht mehr reagieren.
Verwenden Sie Callbacks für human-in-the-loop Workflows, die Integration externer Systeme, Webhook-Antworten oder jedes Szenario, in dem die Ausführung für externe Eingaben unterbrochen werden muss.
### Parallele Ausführung
Führt mehrere Operationen gleichzeitig mit optionaler Parallelitätssteuerung aus. Das SDK verwaltet die parallel Ausführung, erstellt Prüfpunkte für jeden Vorgang und behandelt Fehler gemäß Ihrer Abschlussrichtlinie.
------
#### [ TypeScript ]
```
const results = await context.parallel([
async (ctx) => ctx.step('task1', async () => processTask1()),
async (ctx) => ctx.step('task2', async () => processTask2()),
async (ctx) => ctx.step('task3', async () => processTask3())
]);
```
------
#### [ Python ]
```
results = context.parallel(
lambda ctx: ctx.step(lambda _: process_task1(), name='task1'),
lambda ctx: ctx.step(lambda _: process_task2(), name='task2'),
lambda ctx: ctx.step(lambda _: process_task3(), name='task3')
)
```
------
#### [ Java (Preview) ]
Parallel befindet sich noch in der Entwicklung für Java.
------
Wird verwendet`parallel`, um unabhängige Operationen gleichzeitig auszuführen.
### Zuordnung
Führt gleichzeitig einen Vorgang für jedes Element in einem Array mit optionaler Parallelitätssteuerung aus. Das SDK verwaltet die gleichzeitige Ausführung, erstellt Prüfpunkte für jeden Vorgang und behandelt Fehler gemäß Ihrer Abschlussrichtlinie.
------
#### [ TypeScript ]
```
const results = await context.map(itemArray, async (ctx, item, index) =>
ctx.step('task', async () => processItem(item, index))
);
```
------
#### [ Python ]
```
results = context.map(
item_array,
lambda ctx, item, index: ctx.step(
lambda _: process_item(item, index),
name='task'
)
)
```
------
#### [ Java (Preview) ]
Map befindet sich noch in der Entwicklung für Java.
------
Wird verwendet`map`, um Arrays mit Parallelitätssteuerung zu verarbeiten.
### Kontexte für Kinder
Erzeugt einen isolierten Ausführungskontext für Gruppierungsvorgänge. Untergeordnete Kontexte haben ihr eigenes Checkpoint-Log und können mehrere Schritte, Wartezeiten und andere Operationen enthalten. Das SDK behandelt den gesamten untergeordneten Kontext für Wiederholungen und Wiederherstellungen als eine Einheit.
Verwenden Sie untergeordnete Kontexte, um komplexe Workflows zu organisieren, Unterworkflows zu implementieren oder Vorgänge zu isolieren, die zusammen wiederholt werden sollten.
------
#### [ TypeScript ]
```
const result = await context.runInChildContext(
'batch-processing',
async (childCtx) => {
return await processBatch(childCtx, items);
}
);
```
------
#### [ Python ]
```
result = context.run_in_child_context(
lambda child_ctx: process_batch(child_ctx, items),
name='batch-processing'
)
```
------
#### [ Java (Preview) ]
```
var result = context.runInChildContext(
"batch-processing",
String.class,
childCtx -> process_batch(childCtx, items)
);
```
------
Der Wiederholungsmechanismus erfordert, dass dauerhafte Operationen in einer deterministischen Reihenfolge ablaufen. Wenn Sie mehrere untergeordnete Kontexte verwenden, können Sie mehrere Arbeitsabläufe gleichzeitig ausführen lassen, und der Determinismus gilt für jeden Kontext separat. Auf diese Weise können Sie Hochleistungsfunktionen erstellen, die mehrere CPU-Kerne effizient nutzen.
Stellen Sie sich zum Beispiel vor, wir starten zwei untergeordnete Kontexte, A und B. Beim ersten Aufruf wurden die Schritte innerhalb der Kontexte in dieser Reihenfolge ausgeführt, wobei die A-Schritte gleichzeitig mit den B-Schritten ausgeführt wurden: A1, B1, B2, A2, A3. Bei der Wiedergabe ist das Timing viel schneller, da die Ergebnisse aus dem Checkpoint-Protokoll abgerufen werden und die Schritte zufällig in einer anderen Reihenfolge ausgeführt werden: B1, A1, A2, B2, A3. Da die A-Schritte in der richtigen Reihenfolge (A1, A2, A3) und die B-Schritte in der richtigen Reihenfolge (B1, B2) angetroffen wurden, wurde die Notwendigkeit des Determinismus korrekt erfüllt.
### Bedingte Wartezeiten
Führt Abfragen nach einer Bedingung durch, wobei zwischen den Versuchen eine automatische Überprüfung erfolgt. Das SDK führt Ihre Prüffunktion aus, erstellt einen Checkpoint mit dem Ergebnis, wartet entsprechend Ihrer Strategie und wiederholt den Vorgang, bis die Bedingung erfüllt ist.
------
#### [ TypeScript ]
```
const result = await context.waitForCondition(
async (state, ctx) => {
const status = await checkJobStatus(state.jobId);
return { ...state, status };
},
{
initialState: { jobId: 'job-123', status: 'pending' },
waitStrategy: (state) =>
state.status === 'completed'
? { shouldContinue: false }
: { shouldContinue: true, delay: { seconds: 30 } }
}
);
```
------
#### [ Python ]
```
result = context.wait_for_condition(
lambda state, ctx: check_job_status(state['jobId']),
config=WaitForConditionConfig(
initial_state={'jobId': 'job-123', 'status': 'pending'},
wait_strategy=lambda state, attempt:
{'should_continue': False} if state['status'] == 'completed'
else {'should_continue': True, 'delay': 30}
)
)
```
------
#### [ Java (Preview) ]
waitForCondition befindet sich noch in der Entwicklung für Java.
------
Wird verwendet, `waitForCondition` um externe Systeme abzufragen, darauf zu warten, dass Ressourcen bereit sind, oder um Wiederholungsversuche mit Backoff zu implementieren.
### Funktionsaufruf
Ruft eine weitere Lambda-Funktion auf und wartet auf ihr Ergebnis. Das SDK erstellt einen Checkpoint, ruft die Zielfunktion auf und nimmt Ihre Funktion wieder auf, wenn der Aufruf abgeschlossen ist. Dies ermöglicht die Funktionskomposition und die Workflow-Zerlegung.
------
#### [ TypeScript ]
```
const result = await context.invoke(
'invoke-processor',
'arn:aws:lambda:us-east-1:123456789012:function:processor:1',
{ data: inputData }
);
```
------
#### [ Python ]
```
result = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:processor:1',
{'data': input_data},
name='invoke-processor'
)
```
------
#### [ Java (Preview) ]
```
var result = context.invoke(
"invoke-processor",
"arn:aws:lambda:us-east-1:123456789012:function:processor:1",
inputData,
Result.class,
InvokeConfig.builder().build()
);
```
------
## Wie lange Betriebsabläufe gemessen werden
Jeder dauerhafte Vorgang, über den Sie aufrufen, `DurableContext` erstellt Kontrollpunkte, um den Ausführungsfortschritt zu verfolgen und Statusdaten zu speichern. Für diese Operationen fallen je nach Nutzung Gebühren an, und die Checkpoints können Daten enthalten, die zu Ihren Schreib- und Aufbewahrungskosten beitragen. Zu den gespeicherten Daten gehören Aufrufereignisse, Payloads, die von Schritten zurückgegeben wurden, und Daten, die beim Ausführen von Rückrufen weitergegeben werden. Wenn Sie wissen, wie langlebige Operationen gemessen werden, können Sie die Ausführungskosten abschätzen und Ihre Arbeitsabläufe optimieren. Einzelheiten zur Preisgestaltung finden Sie auf der [Seite mit den Lambda-Preisen.](https://aws.amazon.com/lambda/pricing/)
Die Größe der Nutzlast bezieht sich auf die Größe der serialisierten Daten, die bei einem dauerhaften Betrieb fortgeführt werden. Die Daten werden in Byte gemessen und die Größe kann je nach dem für den Vorgang verwendeten Serializer variieren. Die Nutzlast eines Vorgangs kann das Ergebnis selbst sein, wenn der Vorgang erfolgreich abgeschlossen wurde, oder das serialisierte Fehlerobjekt, falls der Vorgang fehlschlägt.
### Grundlegende Operationen
Grundoperationen sind die grundlegenden Bausteine für dauerhafte Funktionen:
| Operation | Zeitpunkt der Checkpoints | Anzahl der Operationen | Die Daten wurden beibehalten |
| --- | --- | --- | --- |
| Ausführung | Gestartet | 1 | Größe der eingegebenen Nutzlast |
| Ausführung | Abgeschlossen () Succeeded/Failed/Stopped | 0 | Größe der Ausgangsnutzlast |
| Schritt | Retry/Succeeded/Failed | 1 \$11 N Wiederholungen | Bei jedem Versuch wurde die Nutzlastgröße zurückgegeben |
| Wait | Gestartet | 1 | – |
| WaitForCondition | Jeder Abfrageversuch | 1 \$1 N Umfragen | Bei jedem Abfrageversuch wurde die Nutzlastgröße zurückgegeben |
| Wiederholter Versuch auf Aufrufebene | Gestartet | 1 | Nutzlast für das Fehlerobjekt |
### Callback-Operationen
Callback-Operationen ermöglichen es Ihrer Funktion, eine Pause einzulegen und darauf zu warten, dass externe Systeme Eingaben bereitstellen. Diese Operationen erstellen Checkpoints, wenn der Callback erstellt und abgeschlossen ist:
| Operation | Zeitpunkt der Checkpoints | Anzahl der Operationen | Die Daten wurden beibehalten |
| --- | --- | --- | --- |
| CreateCallback | Gestartet | 1 | – |
| Abschluss des Rückrufs per API-Aufruf | Completed | 0 | Payload des Rückrufs |
| WaitForCallback | Gestartet | 3 \$1 N Wiederholungen (Kontext \$1 Rückruf \$1 Schritt) | Payloads, die durch Versuche des Absenders zurückgesendet wurden, plus zwei Kopien der Payload für den Rückruf |
### Zusammengesetzte Operationen
Zusammengesetzte Operationen kombinieren mehrere dauerhafte Operationen, um komplexe Koordinationsmuster wie parallel Ausführung, Array-Verarbeitung und verschachtelte Kontexte zu handhaben:
| Operation | Zeitplan für Checkpoints | Anzahl der Operationen | Die Daten wurden beibehalten |
| --- | --- | --- | --- |
| Parallel | Gestartet | 1 \$1 N Zweige (1 übergeordneter Kontext \$1 N untergeordnete Kontexte) | Bis zu zwei Kopien der zurückgegebenen Nutzdatengröße aus jedem Zweig plus den Status jedes Zweigs |
| Zuordnung | Gestartet | 1 \$1 N Zweige (1 übergeordneter Kontext \$1 N untergeordnete Kontexte) | Bis zu zwei Kopien der zurückgegebenen Payload-Größe aus jeder Iteration plus der Status jeder Iteration |
| Versprich Helfer | Completed | 1 | Die Nutzlastgröße wurde aus dem Versprechen zurückgegeben |
| RunInChildContext | Erfolgreich/Fehlgeschlagen | 1 | Die Nutzdatengröße wurde aus dem untergeordneten Kontext zurückgegeben |
Bei Kontexten, die z. B. aus zusammengesetzten Operationen stammen `runInChildContext` oder intern von zusammengesetzten Operationen verwendet werden, werden Ergebnisse, die kleiner als 256 KB sind, direkt überprüft. Größere Ergebnisse werden nicht gespeichert, sondern während der Wiedergabe rekonstruiert, indem die Operationen des Kontextes erneut verarbeitet werden.
# Unterstützte Laufzeiten für langlebige Funktionen
Dauerhafte Funktionen sind für ausgewählte verwaltete Laufzeiten und OCI-Container-Images für zusätzliche Flexibilität bei Laufzeitversionen verfügbar. Sie können dauerhafte Funktionen für Node.js und Python mithilfe verwalteter Laufzeiten direkt in der Konsole oder programmgesteuert erstellen. infrastructure-as-code Dauerhafte Funktionen in Java (Preview) können derzeit nur über Container-Images bereitgestellt werden.
## Von Lambda verwaltete Laufzeiten
Die folgenden verwalteten Laufzeiten unterstützen dauerhafte Funktionen, wenn Sie Funktionen in der Lambda-Konsole erstellen oder AWS CLI mit dem `--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'` Parameter verwenden. Vollständige Informationen zu Lambda-Laufzeiten finden Sie unter [Lambda-Laufzeiten](lambda-runtimes.md).
| Sprache | Laufzeit |
| --- | --- |
| Node.js | nodejs2.x |
| Node.js | nodejs24.x |
| Python | Python 3.13 |
| Python | Python 3,14 |
**Anmerkung**
Zu den Lambda-Laufzeiten gehört das Durable Execution SDK für Tests und Entwicklung. Wir empfehlen jedoch, das SDK in Ihr Bereitstellungspaket für die Produktion aufzunehmen. Dadurch wird die Versionskonsistenz gewährleistet und potenzielle Laufzeitaktualisierungen vermieden, die Ihr Funktionsverhalten beeinträchtigen könnten.
### Node.js
Installieren Sie das SDK in Ihrem Projekt Node.js:
```
npm install @aws/durable-execution-sdk-js
```
Das SDK unterstützt JavaScript und TypeScript. Für TypeScript Projekte enthält das SDK Typdefinitionen.
### Python
Installieren Sie das SDK in Ihrem Python-Projekt:
```
pip install aws-durable-execution-sdk-python
```
Das Python-SDK verwendet synchrone Methoden und benötigt `async/await` keine.
### Java (Vorschau)
Fügen Sie eine Abhängigkeit hinzu zu`pom.xml`:
```
software.amazon.lambda.durable
aws-durable-execution-sdk-java
VERSION
```
Installieren Sie das SDK in Ihrem Java-Projekt:
```
mvn install
```
Eine Vorschauversion des Java-SDK ist verfügbar. Die Operationen waitForCondition, waitForCallback, Parallel und Map befinden sich noch in der Entwicklung.
## Container-Images
Sie können dauerhafte Funktionen mit Container-Images verwenden, um zusätzliche Laufzeitversionen oder benutzerdefinierte Laufzeitkonfigurationen zu unterstützen. Mit Container-Images können Sie Laufzeitversionen verwenden, die nicht als verwaltete Laufzeiten verfügbar sind, oder Ihre Laufzeitumgebung anpassen.
So erstellen Sie eine dauerhafte Funktion mithilfe eines Container-Images:
1. Erstellen Sie ein Dockerfile basierend auf einem Lambda-Basisimage
1. Installieren Sie das Durable Execution SDK in Ihrem Container
1. Erstellen Sie das Container-Image und übertragen Sie es an Amazon Elastic Container Registry
1. Erstellen Sie die Lambda-Funktion aus dem Container-Image mit aktivierter dauerhafter Ausführung
### Beispiel für einen Container
Erstellen Sie ein Dockerfile:
------
#### [ Python ]
Erstellen Sie ein Dockerfile für Python 3.11:
```
FROM public.ecr.aws/lambda/python:3.11
# Copy requirements file
COPY requirements.txt ${LAMBDA_TASK_ROOT}/
# Install dependencies including durable SDK
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}/
# Set the handler
CMD [ "lambda_function.handler" ]
```
Erstelle eine Datei: `requirements.txt`
```
aws-durable-execution-sdk-python
```
------
#### [ Java (Preview) ]
Erstellen Sie ein Dockerfile für Java 25:
```
FROM --platform=linux/amd64 public.ecr.aws/lambda/java:25
# Install Maven
RUN dnf install -y maven
WORKDIR /var/task
# Copy Maven configuration and source code
COPY pom.xml .
COPY src ./src
# Build
RUN mvn clean package -DskipTests
# Move JAR to lib directory
RUN mv target/*.jar lib/
# Set the handler
CMD ["src.path.to.lambdaFunction::handler"]
```
------
Erstellen Sie das Image und übertragen Sie es:
```
# Build the image
docker build -t my-durable-function .
# Tag for ECR
docker tag my-durable-function:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest
# Push to ECR
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest
```
Erstellen Sie die Funktion mit aktivierter dauerhafter Ausführung:
```
aws lambda create-function \
--function-name myDurableFunction \
--package-type Image \
--code ImageUri=123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest \
--role arn:aws:iam::123456789012:role/lambda-execution-role \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
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.
## Überlegungen zur Laufzeit
**SDK-Versionsverwaltung: Nehmen** Sie das Durable Execution SDK in Ihr Bereitstellungspaket oder Container-Image auf. Dadurch wird sichergestellt, dass Ihre Funktion eine bestimmte SDK-Version verwendet und nicht durch Runtime-Updates beeinträchtigt wird. Stecken Sie SDK-Versionen in Ihren PC `package.json``requirements.txt`, um zu kontrollieren, wann Sie ein Upgrade durchführen.
** AWS Runtime-Updates:** aktualisiert verwaltete Laufzeiten um Sicherheitspatches und Bugfixes. Diese Updates können neue SDK-Versionen enthalten. Um unerwartetes Verhalten zu vermeiden, nehmen Sie das SDK in Ihr Bereitstellungspaket auf und testen Sie es gründlich, bevor Sie es in der Produktion einsetzen.
**Größe des Container-Images:** Container-Images haben eine maximale unkomprimierte Größe von 10 GB. Das Durable Execution SDK fügt Ihrem Bild eine minimale Größe hinzu. Optimieren Sie Ihren Container, indem Sie mehrstufige Builds verwenden und unnötige Abhängigkeiten entfernen.
**Kaltstartleistung:** Container-Images haben möglicherweise längere Kaltstartzeiten als verwaltete Laufzeiten. Das langlebige Ausführungs-SDK hat nur minimale Auswirkungen auf die Kaltstartleistung. Verwenden Sie die bereitgestellte Parallelität, wenn die Kaltstart-Latenz für Ihre Anwendung entscheidend ist.
# 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.
# 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:**
+ **Gültig:** Eine dauerhafte Funktion verarbeitet eine Amazon SQS SQS-Nachricht in drei Schritten, die jeweils 2 Minuten dauern, und wartet dann 5 Minuten, bevor ein letzter Schritt abgeschlossen wird. Gesamtausführungszeit: 11 Minuten. Das funktioniert, weil die Gesamtsumme unter 15 Minuten liegt.
+ **Ungültig:** Eine dauerhafte Funktion verarbeitet eine Amazon SQS SQS-Nachricht, schließt die erste Verarbeitung in 2 Minuten ab und wartet dann 20 Minuten auf einen externen Rückruf, bevor der Vorgang abgeschlossen wird. Gesamtausführungszeit: 22 Minuten. Dies überschreitet das 15-Minuten-Limit und schlägt fehl.
+ **Ungültig:** Eine dauerhafte Funktion verarbeitet einen Kinesis-Datensatz mit mehreren Wartevorgängen, die zwischen den Schritten insgesamt 30 Minuten dauern. Obwohl jeder einzelne Aufruf schnell abgeschlossen wird, beträgt die Gesamtausführungszeit mehr als 15 Minuten.
**Wichtig**
Konfigurieren Sie Ihr dauerhaftes Ausführungstimeout auf 15 Minuten oder weniger, wenn Sie Ereignisquellenzuordnungen verwenden. Andernfalls schlägt die Erstellung der Ereignisquellenzuordnung fehl. Wenn Ihr Workflow längere Ausführungszeiten erfordert, verwenden Sie das unten beschriebene Muster für Zwischenfunktionen.
## 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:
+ **Wiederholungsverhalten:** Wenn der erste Aufruf fehlschlägt, versucht die Zuordnung der Ereignisquelle entsprechend ihrer Wiederholungskonfiguration erneut. Konfigurieren Sie die maximale Anzahl an Wiederholungsversuchen und die Wiederholungsintervalle entsprechend Ihren Anforderungen.
+ **Warteschlangen für unzustellbare Briefe: Konfigurieren Sie eine Warteschlange** für unzustellbare Nachrichten, um Datensätze zu erfassen, die nach allen Wiederholungen fehlschlagen. Dies verhindert den Verlust von Nachrichten und ermöglicht die manuelle Überprüfung fehlgeschlagener Datensätze.
+ **Teilweise Batchfehler:** Verwenden Sie für Amazon SQS und Kinesis die Meldung teilweiser Batch-Fehler, um Datensätze einzeln zu verarbeiten und nur fehlgeschlagene Datensätze erneut zu versuchen.
+ Bei **Fehler halbieren:** Aktivieren Sie für Kinesis- und DynamoDB Streams die Option Halbieren bei Fehler, um fehlgeschlagene Batches aufzuteilen und problematische Datensätze zu isolieren.
**Anmerkung**
Dauerhafte Funktionen unterstützen Dead-Letter-Queues (DLQs) für die Fehlerbehandlung, unterstützen aber keine Lambda-Ziele. Konfigurieren Sie eine DLQ, um Datensätze von fehlgeschlagenen Aufrufen zu erfassen.
Vollständige Informationen zur Fehlerbehandlung bei der Zuordnung von Ereignisquellen finden Sie unter Zuordnungen von [Ereignisquellen](invocation-eventsourcemapping.md).
## 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:
1. **Zuordnung der Ereignisquelle:** Ruft die Ereignisquelle ab (Amazon SQS, Kinesis, DynamoDB Streams) und ruft die Zwischenfunktion synchron mit Datensatzstapeln auf.
1. **Zwischenfunktion:** Eine Standard-Lambda-Funktion, die Ereignisse aus der Ereignisquellenzuordnung empfängt, die Daten bei Bedarf validiert und transformiert und die dauerhafte Funktion asynchron aufruft. Diese Funktion wird schnell abgeschlossen (normalerweise in weniger als 1 Sekunde) und gibt die Steuerung an die Ereignisquellenzuordnung zurück.
1. **Dauerhafte Funktion:** Verarbeitet das Ereignis mit einer komplexen, mehrstufigen Logik, die über längere Zeiträume ausgeführt werden kann. Wird asynchron aufgerufen, sodass es nicht durch das 15-Minuten-Limit eingeschränkt ist.
### 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](https://docs.aws.amazon.com//powertools/) 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
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
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:
+ Amazon SQS SQS-Warteschlangen (Standard und FIFO)
+ Kinesis-Streams
+ DynamoDB Streams
+ Amazon Managed Streaming for Apache Kafka (Amazon MSK)
+ Selbstverwaltetes Apache Kafka
+ Amazon MQ (ActiveMQ und RabbitMQ)
+ Amazon DocumentDB DocumentDB-Change-Streams
Für alle Arten von Ereignisquellen gilt beim Aufrufen dauerhafter Funktionen eine maximale Ausführungsdauer von 15 Minuten.
# Wiederholungen für langlebige Lambda-Funktionen
Langlebige Funktionen bieten automatische Wiederholungsfunktionen, die Ihre Anwendungen widerstandsfähig gegen vorübergehende Ausfälle machen. Das SDK verarbeitet Wiederholungen auf zwei Ebenen: schrittweise Wiederholungen bei Ausfällen der Geschäftslogik und Backend-Wiederholungen bei Infrastrukturausfällen.
## Schrittweise Wiederholungen
Wenn innerhalb eines Schritts eine nicht abgefangene Ausnahme auftritt, wiederholt das SDK den Schritt automatisch auf der Grundlage der konfigurierten Wiederholungsstrategie. Wiederholungen von Schritten sind Operationen, bei denen das SDK die Ausführung unterbrechen und später fortsetzen kann, ohne dass der Fortschritt verloren geht.
### Verhalten bei schrittweisen Wiederholungen
In der folgenden Tabelle wird beschrieben, wie das SDK Ausnahmen in Schritten behandelt:
| Szenario | Was passiert | Messung der Auswirkungen |
| --- | --- | --- |
| Ausnahme im Gleichschritt mit den verbleibenden Wiederholungsversuchen | Das SDK erstellt einen Checkpoint für den erneuten Versuch und unterbricht die Funktion. Beim nächsten Aufruf wiederholt sich der Schritt mit der konfigurierten Backoff-Verzögerung. | 1 Vorgang \$1 Fehler, Payload-Größe |
| Ausnahme im Schritt ohne verbleibende Wiederholungsversuche | Der Schritt schlägt fehl und löst eine Ausnahme aus. Wenn Ihr Handler-Code diese Ausnahme nicht catch, schlägt die gesamte Ausführung fehl. | 1 Vorgang \$1 Fehler, Größe der Nutzlast |
Wenn ein Schritt erneut versucht werden muss, überprüft das SDK den Wiederholungsstatus und beendet den Lambda-Aufruf, wenn keine andere Arbeit ausgeführt wird. Auf diese Weise kann das SDK Backoff-Verzögerungen implementieren, ohne Rechenressourcen zu verbrauchen. Die Funktion wird nach Ablauf der Backoff-Periode automatisch wieder aufgenommen.
### Konfiguration von Strategien zur schrittweisen Wiederholung
Konfigurieren Sie Wiederholungsstrategien, um zu steuern, wie Schritte mit Fehlern umgehen. Sie können maximale Versuche, Backoff-Intervalle und Bedingungen für Wiederholungsversuche angeben.
**Exponentieller Backoff mit maximaler Anzahl von Versuchen:**
------
#### [ TypeScript ]
```
const result = await context.step('call-api', async () => {
const response = await fetch('https://api.example.com/data');
if (!response.ok) throw new Error(`API error: ${response.status}`);
return await response.json();
}, {
retryStrategy: (error, attemptCount) => {
if (attemptCount >= 5) {
return { shouldRetry: false };
}
// Exponential backoff: 2s, 4s, 8s, 16s, 32s (capped at 300s)
const delay = Math.min(2 * Math.pow(2, attemptCount - 1), 300);
return { shouldRetry: true, delay: { seconds: delay } };
}
});
```
------
#### [ Python ]
```
def retry_strategy(error, attempt_count):
if attempt_count >= 5:
return {'should_retry': False}
# Exponential backoff: 2s, 4s, 8s, 16s, 32s (capped at 300s)
delay = min(2 * (2 ** (attempt_count - 1)), 300)
return {'should_retry': True, 'delay': delay}
result = context.step(
lambda _: call_external_api(),
name='call-api',
config=StepConfig(retry_strategy=retry_strategy)
)
```
------
**Backoff mit festem Intervall:**
------
#### [ TypeScript ]
```
const orders = await context.step('query-orders', async () => {
return await queryDatabase(event.userId);
}, {
retryStrategy: (error, attemptCount) => {
if (attemptCount >= 3) {
return { shouldRetry: false };
}
return { shouldRetry: true, delay: { seconds: 5 } };
}
});
```
------
#### [ Python ]
```
def retry_strategy(error, attempt_count):
if attempt_count >= 3:
return {'should_retry': False}
return {'should_retry': True, 'delay': 5}
orders = context.step(
lambda _: query_database(event['userId']),
name='query-orders',
config=StepConfig(retry_strategy=retry_strategy)
)
```
------
**Bedingter Wiederholungsversuch (nur bei bestimmten Fehlern wiederholen):**
------
#### [ TypeScript ]
```
const result = await context.step('call-rate-limited-api', async () => {
const response = await fetch('https://api.example.com/data');
if (response.status === 429) throw new Error('RATE_LIMIT');
if (response.status === 504) throw new Error('TIMEOUT');
if (!response.ok) throw new Error(`API_ERROR_${response.status}`);
return await response.json();
}, {
retryStrategy: (error, attemptCount) => {
// Only retry rate limits and timeouts
const isRetryable = error.message === 'RATE_LIMIT' || error.message === 'TIMEOUT';
if (!isRetryable || attemptCount >= 3) {
return { shouldRetry: false };
}
// Exponential backoff: 1s, 2s, 4s (capped at 30s)
const delay = Math.min(Math.pow(2, attemptCount - 1), 30);
return { shouldRetry: true, delay: { seconds: delay } };
}
});
```
------
#### [ Python ]
```
def retry_strategy(error, attempt_count):
# Only retry rate limits and timeouts
is_retryable = str(error) in ['RATE_LIMIT', 'TIMEOUT']
if not is_retryable or attempt_count >= 3:
return {'should_retry': False}
# Exponential backoff: 1s, 2s, 4s (capped at 30s)
delay = min(2 ** (attempt_count - 1), 30)
return {'should_retry': True, 'delay': delay}
result = context.step(
lambda _: call_rate_limited_api(),
name='call-rate-limited-api',
config=StepConfig(retry_strategy=retry_strategy)
)
```
------
**Wiederholungen deaktivieren:**
------
#### [ TypeScript ]
```
const isDuplicate = await context.step('check-duplicate', async () => {
return await checkIfOrderExists(event.orderId);
}, {
retryStrategy: () => ({ shouldRetry: false })
});
```
------
#### [ Python ]
```
is_duplicate = context.step(
lambda _: check_if_order_exists(event['orderId']),
name='check-duplicate',
config=StepConfig(
retry_strategy=lambda error, attempt: {'should_retry': False}
)
)
```
------
Wenn die Wiederholungsstrategie zurückkehrt`shouldRetry: false`, schlägt der Schritt ohne erneute Versuche sofort fehl. Verwenden Sie diese Option für Operationen, die nicht wiederholt werden sollten, z. B. Idempotenzprüfungen oder Operationen mit Nebenwirkungen, die nicht sicher wiederholt werden können.
## Ausnahmen außerhalb von Schritten
Wenn in Ihrem Handlercode, aber außerhalb eines Schritts eine nicht abgefangene Ausnahme auftritt, markiert das SDK die Ausführung als fehlgeschlagen. Dadurch wird sichergestellt, dass Fehler in Ihrer Anwendungslogik ordnungsgemäß erfasst und gemeldet werden.
| Szenario | Was passiert | Messung der Auswirkungen |
| --- | --- | --- |
| Ausnahme im Handler-Code außerhalb eines beliebigen Schritts | Das SDK markiert die Ausführung als FEHLGESCHLAGEN und gibt den Fehler zurück. Die Ausnahme wird nicht automatisch wiederholt. | Fehler bei der Größe der Payload |
Um die automatische Wiederholung von fehleranfälligem Code zu aktivieren, schließen Sie den Vorgang in einem Schritt mit einer Wiederholungsstrategie ab. Schritte bieten automatische Wiederholungsversuche mit konfigurierbarem Backoff, während Code außerhalb von Schritten sofort fehlschlägt.
## Wiederholungen im Backend
Backend-Wiederholungen treten auf, wenn Lambda auf Infrastrukturausfälle oder Laufzeitfehler stößt oder wenn das SDK nicht mit dem Durable Execution Service kommunizieren kann. Lambda versucht diese Fehler automatisch erneut, damit Ihre dauerhaften Funktionen nach vorübergehenden Infrastrukturproblemen wieder hergestellt werden können.
### Szenarien für Wiederholungsversuche im Backend
Lambda versucht automatisch, Ihre Funktion erneut auszuführen, wenn sie auf die folgenden Szenarien trifft:
+ **Interne Dienstfehler** — Wenn Lambda oder der Durable Execution Service einen 5xx-Fehler zurückgibt, was auf ein vorübergehendes Serviceproblem hinweist.
+ **Drosselung** — Wenn Ihre Funktion aufgrund von Parallelitätsbeschränkungen oder Servicekontingenten gedrosselt wird.
+ **Timeouts** — Wenn das SDK den Durable Execution Service innerhalb des Timeout-Zeitraums nicht erreichen kann.
+ **Sandbox-Initialisierungsfehler** — Wenn Lambda die Ausführungsumgebung nicht initialisieren kann.
+ **Laufzeitfehler** — Wenn die Lambda-Laufzeit auf Fehler außerhalb Ihres Funktionscodes stößt, z. B. out-of-memory Fehler oder Prozessabstürze.
+ **Ungültige Checkpoint-Token-Fehler** — Wenn das Checkpoint-Token nicht mehr gültig ist, typischerweise aufgrund von Statusänderungen auf der Serviceseite.
In der folgenden Tabelle wird beschrieben, wie das SDK mit diesen Szenarien umgeht:
| Szenario | Was passiert | Messung der Auswirkungen |
| --- | --- | --- |
| Laufzeitfehler außerhalb des Durable-Handlers (OOM, Timeout, Absturz) | Lambda versucht den Aufruf automatisch erneut. Das SDK wiederholt die Wiedergabe ab dem letzten Checkpoint, wobei abgeschlossene Schritte übersprungen werden. | Fehler: Payload-Größe \$1 1 Vorgang pro Wiederholung |
| Dienstfehler (5xx) oder Timeout beim Aufrufen/CheckpointDurableExecutionGetDurableExecutionState APIs | Lambda versucht den Aufruf automatisch erneut. Das SDK wiederholt die Wiedergabe ab dem letzten Checkpoint. | Fehler: Payload-Größe \$1 1 Vorgang pro Wiederholungsversuch |
| Drosselung (429) oder ungültiges Checkpoint-Token beim Aufrufen von/CheckpointDurableExecutionGetDurableExecutionState APIs | Lambda wiederholt den Aufruf automatisch mit exponentiellem Backoff. Das SDK wiederholt die Wiedergabe ab dem letzten Checkpoint. | Fehler: Payload-Größe \$1 1 Vorgang pro Wiederholungsversuch |
| Client-Fehler (4xx, außer 429 und ungültigem Token) wenn/CheckpointDurableExecutionGetDurableExecutionState APIs | Das SDK markiert die Ausführung als FEHLGESCHLAGEN. Es erfolgt kein automatischer Wiederholungsversuch, da der Fehler auf ein permanentes Problem hinweist. | Fehler bei der Größe der Payload |
Backend-Wiederholungen verwenden exponentielles Backoff und werden fortgesetzt, bis die Funktion erfolgreich ist oder das Ausführungstimeout erreicht ist. Während der Wiedergabe überspringt das SDK abgeschlossene Prüfpunkte und setzt die Ausführung ab dem letzten erfolgreichen Vorgang fort, um sicherzustellen, dass Ihre Funktion abgeschlossene Arbeit nicht erneut ausführt.
## Versuchen Sie es erneut mit bewährten Methoden
Beachten Sie bei der Konfiguration von Wiederholungsstrategien die folgenden bewährten Methoden:
+ **Konfigurieren Sie explizite Wiederholungsstrategien** — Verlassen Sie sich nicht auf das standardmäßige Wiederholungsverhalten in der Produktion. Konfigurieren Sie Strategien für explizite Wiederholungen mit einer für Ihren Anwendungsfall angemessenen maximalen Anzahl von Versuchen und Backoff-Intervallen.
+ **Verwenden Sie bedingte Wiederholungen** — Implementieren Sie `shouldRetry` Logik, um nur vorübergehende Fehler (Ratenbegrenzungen, Timeouts) zu wiederholen und bei dauerhaften Fehlern (Validierungsfehler, nicht gefunden) schnell fehlzuschlagen.
+ **Stellen Sie eine angemessene maximale Anzahl von Versuchen** ein — Balance zwischen Belastbarkeit und Ausführungszeit. Zu viele Wiederholungen können die Fehlererkennung verzögern, während zu wenige Versuche zu unnötigen Fehlern führen können.
+ **Exponentielles Backoff verwenden — Exponentielles Backoff** reduziert die Belastung nachgeschalteter Dienste und erhöht die Wahrscheinlichkeit einer Wiederherstellung nach vorübergehenden Ausfällen.
+ **Fehleranfälligen Code schrittweise zusammenfassen — Code außerhalb von Schritten kann nicht automatisch** wiederholt werden. Integrieren Sie externe API-Aufrufe, Datenbankabfragen und andere fehleranfällige Operationen schrittweise mit Wiederholungsstrategien.
+ **Überwachen Sie Wiederholungsmetriken** — Verfolgen Sie schrittweise Wiederholungsvorgänge und Ausführungsfehler in Amazon CloudWatch , um Muster zu identifizieren und Wiederholungsstrategien zu optimieren.
# Idempotenz
Dauerhafte Funktionen bieten eine eingebaute Idempotenz für Ausführungsstarts anhand von Ausführungsnamen. Wenn Sie einen Ausführungsnamen angeben, verwendet Lambda ihn, um doppelte Ausführungen zu verhindern und sichere Wiederholungen von Aufrufanforderungen zu ermöglichen. Schritte haben standardmäßig eine at-least-once Ausführungssemantik — während der Wiedergabe gibt das SDK Checkpoint-Ergebnisse zurück, ohne abgeschlossene Schritte erneut auszuführen, aber Ihre Geschäftslogik muss idempotent sein, um mögliche Wiederholungen vor Abschluss zu verarbeiten.
**Anmerkung**
Lambda Event Source Mappings (ESM) unterstützen Idempotenz beim Start nicht. Daher startet jeder Aufruf (einschließlich Wiederholungen) eine neue dauerhafte Ausführung. Um eine idempotente Ausführung mit Ereignisquellenzuordnungen sicherzustellen, implementieren Sie entweder Idempotenzlogik in Ihrem Funktionscode, z. B. mit [Powertools for](https://docs.aws.amazon.com//powertools/), AWS Lambda oder verwenden Sie eine reguläre Lambda-Funktion als Proxy (Dispatcher), um eine dauerhafte Funktion mit einem Idempotenzschlüssel (Ausführungsnamenparameter) aufzurufen.
## Namen der Ausführung
Sie können einen Ausführungsnamen angeben, wenn Sie eine dauerhafte Funktion aufrufen. Der Ausführungsname fungiert als Idempotenzschlüssel, sodass Sie Aufrufanforderungen sicher wiederholen können, ohne dass doppelte Ausführungen erforderlich sind. Wenn Sie keinen Namen angeben, generiert Lambda automatisch eine eindeutige Ausführungs-ID.
Ausführungsnamen müssen innerhalb Ihres Kontos und Ihrer Region eindeutig sein. Wenn Sie eine Funktion mit einem bereits vorhandenen Ausführungsnamen aufrufen, hängt das Verhalten von Lambda vom Status der vorhandenen Ausführung ab und davon, ob die Nutzlast übereinstimmt.
## Verhalten bei Idempotenz
In der folgenden Tabelle wird beschrieben, wie Lambda Aufrufanforderungen verarbeitet, je nachdem, ob Sie einen Ausführungsnamen angeben, welchen Ausführungsstatus es gibt und ob die Nutzlast übereinstimmt:
| Szenario | Name angegeben? | Bestehender Ausführungsstatus | Nutzlast identisch? | Behavior |
| --- | --- | --- | --- | --- |
| 1 | Nein | – | – | Neue Ausführung gestartet: Lambda generiert eine eindeutige Ausführungs-ID und startet eine neue Ausführung |
| 2 | Ja | Hat nie existiert oder die Aufbewahrung ist abgelaufen | – | Neue Ausführung gestartet: Lambda startet eine neue Ausführung mit dem angegebenen Namen |
| 3 | Ja | In Ausführung | Ja | Idempotenter Start: Lambda gibt die vorhandenen Ausführungsinformationen zurück, ohne ein Duplikat zu starten. Bei synchronen Aufrufen dient dies als erneutes Anhängen an die laufende Ausführung |
| 4 | Ja | In Ausführung | Nein | Fehler: Lambda gibt einen DurableExecutionAlreadyExists Fehler zurück, weil eine Ausführung mit diesem Namen bereits mit einer anderen Nutzlast ausgeführt wird |
| 5 | Ja | Geschlossen (erfolgreich, fehlgeschlagen, gestoppt oder Zeitlimit überschritten) | Ja | Idempotenter Start: Lambda gibt die vorhandenen Ausführungsinformationen zurück, ohne eine neue Ausführung zu starten. Das Ergebnis der geschlossenen Ausführung wird zurückgegeben |
| 6 | Ja | Geschlossen (erfolgreich, fehlgeschlagen, gestoppt oder Zeitlimit überschritten) | Nein | Fehler: Lambda gibt einen DurableExecutionAlreadyExists Fehler zurück, weil eine Ausführung mit diesem Namen bereits mit einer anderen Nutzlast abgeschlossen wurde |
**Hinweis**
Die Szenarien 3 und 5 zeigen ein idempotentes Verhalten, bei dem Lambda doppelte Aufrufanforderungen sicher verarbeitet, indem es vorhandene Ausführungsinformationen zurückgibt, anstatt Duplikate zu erstellen.
## Schritt Idempotenz
Schritte haben standardmäßig eine at-least-once Ausführungssemantik. Wenn Ihre Funktion nach einem Warten, einem Rückruf oder einem Fehler erneut ausgeführt wird, überprüft das SDK jeden Schritt anhand des Checkpoint-Logs. Für Schritte, die bereits abgeschlossen wurden, gibt das SDK das Checkpoint-Ergebnis zurück, ohne die Schrittlogik erneut auszuführen. Wenn ein Schritt jedoch fehlschlägt oder die Funktion unterbrochen wird, bevor der Schritt abgeschlossen ist, kann der Schritt mehrmals ausgeführt werden.
Ihre in Schritten unterteilte Geschäftslogik muss idempotent sein, um potenzielle Wiederholungsversuche zu bewältigen. Verwenden Sie Idempotenzschlüssel, um sicherzustellen, dass Operationen wie Zahlungen oder Datenbankschreibvorgänge nur einmal ausgeführt werden, auch wenn der Schritt erneut versucht wird.
**Beispiel: Schrittweise Verwendung von Idempotenzschlüsseln**
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
import { randomUUID } from 'crypto';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Generate idempotency key once
const idempotencyKey = await context.step('generate-key', async () => {
return randomUUID();
});
// Use idempotency key in payment API to prevent duplicate charges
const payment = await context.step('process-payment', async () => {
return paymentAPI.charge({
amount: event.amount,
idempotencyKey: idempotencyKey
});
});
return { statusCode: 200, payment };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid
@durable_execution
def handler(event, context: DurableContext):
# Generate idempotency key once
idempotency_key = context.step(
lambda _: str(uuid.uuid4()),
name='generate-key'
)
# Use idempotency key in payment API to prevent duplicate charges
payment = context.step(
lambda _: payment_api.charge(
amount=event['amount'],
idempotency_key=idempotency_key
),
name='process-payment'
)
return {'statusCode': 200, 'payment': payment}
```
------
Sie können Schritte so konfigurieren, dass sie die at-most-once Ausführungssemantik verwenden, indem Sie den Ausführungsmodus auf setzen. `AT_MOST_ONCE_PER_RETRY` Dadurch wird sichergestellt, dass der Schritt pro Wiederholungsversuch höchstens einmal ausgeführt wird, aber möglicherweise überhaupt nicht ausgeführt wird, wenn die Funktion unterbrochen wird, bevor der Schritt abgeschlossen ist.
Das SDK erzwingt eine deterministische Wiedergabe, indem es während der Wiedergabe überprüft, ob die Namen und die Reihenfolge der Schritte mit dem Checkpoint-Protokoll übereinstimmen. Wenn Ihr Code versucht, Schritte in einer anderen Reihenfolge oder mit anderen Namen auszuführen, gibt das SDK eine aus. `NonDeterministicExecutionError`
**So funktioniert die Wiedergabe mit abgeschlossenen Schritten:**
1. Erster Aufruf: Die Funktion führt Schritt A aus, erstellt einen Checkpoint und wartet dann
1. Zweiter Aufruf (nach dem Warten): Die Funktion wird von Anfang an wiederholt, Schritt A gibt sofort ein Checkpoint-Ergebnis zurück, ohne es erneut auszuführen, und fährt dann mit Schritt B fort
1. Dritter Aufruf (nach erneuter Wartezeit): Die Funktion wird von Anfang an wiederholt, die Schritte A und B geben sofort Checkpoint-Ergebnisse zurück und fährt dann mit Schritt C fort
Dieser Wiederholungsmechanismus stellt sicher, dass abgeschlossene Schritte nicht erneut ausgeführt werden, aber Ihre Geschäftslogik muss immer noch idempotent sein, um Wiederholungen vor Abschluss zu verarbeiten.
# Testen langlebiger Lambda-Funktionen
AWS bietet spezielle Tests SDKs für langlebige Funktionen, mit denen Sie Ausführungen sowohl lokal als auch in der Cloud ausführen und überprüfen können. Installieren Sie das Test-SDK für Ihre Sprache:
------
#### [ TypeScript ]
```
npm install --save-dev @aws/aws-durable-execution-sdk-js-testing
```
Eine vollständige Dokumentation und Beispiele finden Sie im [TypeScript Test-SDK](https://github.com/aws/aws-durable-execution-sdk-js/tree/development/packages/aws-durable-execution-sdk-js-testing) unter GitHub.
------
#### [ Python ]
```
pip install aws-durable-execution-sdk-python-testing
```
Eine vollständige Dokumentation und Beispiele finden Sie im [Python-Test-SDK](https://github.com/aws/aws-durable-execution-sdk-python-testing) unter GitHub.
------
Das Test-SDK bietet zwei Testmodi: lokale Tests für schnelle Komponententests und Cloud-Tests für Integrationstests mit bereitgestellten Funktionen.
## Lokale Tests
Beim lokalen Testen werden Ihre dauerhaften Funktionen in Ihrer Entwicklungsumgebung ausgeführt, ohne dass bereitgestellte Ressourcen erforderlich sind. Der Test-Runner führt Ihren Funktionscode direkt aus und erfasst alle Operationen zur Überprüfung.
Verwenden Sie lokale Tests für Komponententests, testgetriebene Entwicklung und CI/CD Pipelines. Tests werden lokal ohne Netzwerklatenz oder zusätzliche Kosten ausgeführt.
**Beispieltest:**
------
#### [ TypeScript ]
```
import { withDurableExecution } from '@aws/aws-durable-execution-sdk-js';
import { DurableFunctionTestRunner } from '@aws/aws-durable-execution-sdk-js-testing';
const handler = withDurableExecution(async (event, context) => {
const result = await context.step('calculate', async () => {
return event.a + event.b;
});
return result;
});
test('addition works correctly', async () => {
const runner = new DurableFunctionTestRunner({ handler });
const result = await runner.run({ a: 5, b: 3 });
expect(result.status).toBe('SUCCEEDED');
expect(result.result).toBe(8);
const step = result.getStep('calculate');
expect(step.result).toBe(8);
});
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
from aws_durable_execution_sdk_python_testing import DurableFunctionTestRunner
from aws_durable_execution_sdk_python.execution import InvocationStatus
@durable_execution
def handler(event: dict, context: DurableContext) -> int:
result = context.step(lambda _: event["a"] + event["b"], name="calculate")
return result
def test_addition():
runner = DurableFunctionTestRunner(handler=handler)
with runner:
result = runner.run(input={"a": 5, "b": 3}, timeout=10)
assert result.status is InvocationStatus.SUCCEEDED
assert result.result == 8
step = result.get_step("calculate")
assert step.result == 8
```
------
Der Test-Runner erfasst den Ausführungsstatus einschließlich des Endergebnisses, der Ergebnisse einzelner Schritte, Warteoperationen, Rückrufe und aller Fehler. Sie können Operationen anhand des Namens überprüfen oder alle Operationen wiederholen, um das Ausführungsverhalten zu überprüfen.
### Die Ausführung wird gespeichert
Das Test-SDK verwendet Ausführungsspeicher, um Testausführungsdaten beizubehalten. Standardmäßig verwenden Tests einen In-Memory-Speicher, der schnell ist und keine Bereinigung erfordert. Zum Debuggen oder Analysieren des Ausführungsverlaufs können Sie einen Dateisystemspeicher verwenden, der Ausführungen als JSON-Dateien speichert.
**In-Memory-Speicher (Standard):**
Der In-Memory-Speicher speichert die Ausführungsdaten während der Testläufe im Speicher. Daten gehen verloren, wenn die Tests abgeschlossen sind, und eignen sich daher ideal für Standard-Komponententests und CI/CD Pipelines, bei denen Sie Ausführungen nach Abschluss der Tests nicht überprüfen müssen.
**Dateisystemspeicher:**
Der Dateisystemspeicher speichert Ausführungsdaten als JSON-Dateien auf der Festplatte. Jede Ausführung wird in einer separaten Datei gespeichert, sodass der Ausführungsverlauf nach Abschluss der Tests leicht überprüft werden kann. Verwenden Sie den Dateisystemspeicher, um komplexe Testfehler zu debuggen oder Ausführungsmuster im Laufe der Zeit zu analysieren.
Konfigurieren Sie den Speicher mithilfe von Umgebungsvariablen:
```
# Use filesystem store
export AWS_DEX_STORE_TYPE=filesystem
export AWS_DEX_STORE_PATH=./test-executions
# Run tests
pytest tests/
```
Ausführungsdateien werden mit bereinigten Namen gespeichert und enthalten den vollständigen Ausführungsstatus, einschließlich Operationen, Prüfpunkten und Ergebnissen. Der Dateisystemspeicher erstellt automatisch das Speicherverzeichnis, falls es nicht existiert.
## Testen in der Cloud
Cloud-Tests rufen bereitgestellte dauerhafte Funktionen auf AWS und rufen deren Ausführungsverlauf mithilfe der Lambda-API ab. Verwenden Sie Cloud-Tests, um das Verhalten in produktionsähnlichen Umgebungen mit echten Diensten und Konfigurationen zu überprüfen. AWS
Für Cloud-Tests sind eine bereitgestellte Funktion und AWS Anmeldeinformationen mit Berechtigungen zum Aufrufen von Funktionen und zum Lesen des Ausführungsverlaufs erforderlich:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetDurableExecution",
"lambda:GetDurableExecutionHistory"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
**Beispiel für einen Cloud-Test:**
------
#### [ TypeScript ]
```
import { DurableFunctionCloudTestRunner } from '@aws/aws-durable-execution-sdk-js-testing';
test('deployed function processes orders', async () => {
const runner = new DurableFunctionCloudTestRunner({
functionName: 'order-processor',
region: 'us-east-1'
});
const result = await runner.run({ orderId: 'order-123' });
expect(result.status).toBe('SUCCEEDED');
expect(result.result.status).toBe('completed');
});
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python_testing import (
DurableFunctionCloudTestRunner,
DurableFunctionCloudTestRunnerConfig
)
def test_deployed_function():
config = DurableFunctionCloudTestRunnerConfig(
function_name="order-processor",
region="us-east-1"
)
runner = DurableFunctionCloudTestRunner(config=config)
result = runner.run(input={"orderId": "order-123"})
assert result.status is InvocationStatus.SUCCEEDED
assert result.result["status"] == "completed"
```
------
Cloud-Tests rufen die tatsächlich bereitgestellte Funktion auf und rufen den Ausführungsverlauf von ab AWS. Auf diese Weise können Sie die Integration mit anderen AWS Diensten überprüfen, Leistungsmerkmale validieren und Tests mit produktionsähnlichen Daten und Konfigurationen durchführen.
## Was muss getestet werden?
Testen Sie langlebige Funktionen, indem Sie die Ausführungsergebnisse, das Betriebsverhalten und die Fehlerbehandlung überprüfen. Konzentrieren Sie sich eher auf die Richtigkeit der Geschäftslogik als auf Implementierungsdetails.
**Überprüfen Sie die Ausführungsergebnisse:** Prüfen Sie, ob die Funktionen die erwarteten Werte für die angegebenen Eingaben zurückgeben. Testen Sie sowohl erfolgreiche Ausführungen als auch Fehlerfälle, um sicherzustellen, dass Funktionen ungültige Eingaben angemessen behandeln.
**Überprüfen Sie die Ausführung des Vorgangs:** Stellen Sie sicher, dass Schritte, Wartezeiten und Callbacks wie erwartet ausgeführt werden. Überprüfen Sie die Schrittergebnisse, um sicherzustellen, dass Zwischenoperationen korrekte Werte ergeben. Stellen Sie sicher, dass Wartevorgänge mit geeigneten Timeouts konfiguriert sind und dass Callbacks mit den richtigen Einstellungen erstellt wurden.
**Testen Sie die Fehlerbehandlung:** Stellen Sie sicher, dass Funktionen korrekt fehlschlagen, und geben Sie beschreibende Fehlermeldungen ein, wenn eine ungültige Eingabe erfolgt. Testen Sie das Wiederholungsverhalten, indem Sie vorübergehende Ausfälle simulieren und sicherstellen, dass der Vorgang ordnungsgemäß wiederholt wird. Stellen Sie sicher, dass permanente Fehler nicht zu unnötigen Wiederholungen führen.
**Workflows validieren:** Stellen Sie bei Workflows mit mehreren Schritten sicher, dass die Vorgänge in der richtigen Reihenfolge ausgeführt werden. Testen Sie die bedingte Verzweigung, um sicherzustellen, dass die verschiedenen Ausführungspfade korrekt funktionieren. Überprüfen Sie, ob parallel Operationen gleichzeitig ausgeführt werden und zu erwarteten Ergebnissen führen.
Die SDK-Dokumentationsrepositorien enthalten umfangreiche Beispiele für Testmuster, darunter mehrstufige Workflows, Fehlerszenarien, Timeout-Behandlung und Abfragemuster.
## Teststrategie
Verwenden Sie lokale Tests für Komponententests während der Entwicklung und in CI/CD Pipelines. Lokale Tests werden schnell ausgeführt, erfordern keine AWS Anmeldeinformationen und bieten sofortiges Feedback zu Codeänderungen. Schreiben Sie lokale Tests, um Geschäftslogik, Fehlerbehandlung und Betriebsverhalten zu überprüfen.
Verwenden Sie Cloud-Tests für Integrationstests, bevor Sie sie in der Produktion einsetzen. Cloud-Tests verifizieren das Verhalten anhand realer AWS Dienste und Konfigurationen, validieren Leistungsmerkmale und testen end-to-end Workflows. Führen Sie Cloud-Tests in Staging-Umgebungen durch, um Integrationsprobleme zu erkennen, bevor sie in die Produktion gelangen.
Simulieren Sie externe Abhängigkeiten in lokalen Tests, um die Funktionslogik zu isolieren und Tests schnell zu halten. Verwenden Sie Cloud-Tests, um die tatsächliche Integration mit externen Diensten wie Datenbanken und anderen AWS Diensten zu überprüfen. APIs
Schreiben Sie gezielte Tests, die ein bestimmtes Verhalten verifizieren. Verwenden Sie aussagekräftige Testnamen, die erklären, was getestet wird. Gruppieren Sie verwandte Tests und verwenden Sie Testvorrichtungen für den allgemeinen Setup-Code. Halten Sie Tests einfach und vermeiden Sie komplexe Testlogik, die schwer zu verstehen ist.
## Fehler beim Debuggen
Wenn Tests fehlschlagen, überprüfen Sie das Ausführungsergebnis, um zu verstehen, was schief gelaufen ist. Überprüfen Sie den Ausführungsstatus, um festzustellen, ob die Funktion erfolgreich war, fehlgeschlagen ist oder ob das Zeitlimit überschritten wurde. Lesen Sie die Fehlermeldungen, um die Fehlerursache zu verstehen.
Untersuchen Sie die einzelnen Betriebsergebnisse, um herauszufinden, wo das Verhalten von den Erwartungen abwich. Überprüfen Sie die Ergebnisse der einzelnen Schritte, um zu sehen, welche Werte erzielt wurden. Überprüfen Sie die Reihenfolge der Operationen, um zu bestätigen, dass die Operationen in der erwarteten Reihenfolge ausgeführt wurden. Zählen Sie die Operationen, um sicherzustellen, dass die richtige Anzahl von Schritten, Wartezeiten und Callbacks erstellt wurde.
Zu den häufigsten Problemen gehören nicht deterministischer Code, der bei der Wiedergabe zu unterschiedlichen Ergebnissen führt, gemeinsamer Status durch globale Variablen, der während der Wiedergabe unterbrochen wird, und fehlende Operationen aufgrund bedingter Logikfehler. Verwenden Sie Standard-Debugger und Protokollierung, um den Funktionscode Schritt für Schritt durchzugehen und den Ausführungsablauf zu verfolgen.
Sehen Sie sich bei Cloud-Tests den Ausführungsverlauf in den CloudWatch Protokollen an, um detaillierte Betriebsprotokolle einzusehen. Verwenden Sie Tracing, um den Ausführungsablauf zwischen Diensten zu verfolgen und Engpässe zu identifizieren.
# Überwachung langlebiger Funktionen
Sie können Ihre dauerhaften Funktionen mithilfe von CloudWatch Metriken, CloudWatch Protokollen und Tracing überwachen. Da langlebige Funktionen über längere Zeiträume ausgeführt werden können und sich über mehrere Funktionsaufrufen erstrecken, erfordert ihre Überwachung das Verständnis ihrer jeweiligen Ausführungsmuster, einschließlich Checkpoints, Zustandsübergängen und Wiedergabeverhalten.
## CloudWatch Metriken
Lambda veröffentlicht automatisch Metriken ohne zusätzliche Kosten. CloudWatch Dauerhafte Funktionen bieten zusätzliche Metriken, die über die Standard-Lambda-Metriken hinausgehen, und unterstützen Sie bei der Überwachung von Workflows mit langer Laufzeit, der Statusverwaltung und der Ressourcennutzung.
### Zuverlässige Ausführungsmetriken
Lambda gibt die folgenden Metriken für dauerhafte Ausführungen aus:
| Metrik | Description |
| --- | --- |
| ApproximateRunningDurableExecutions | Anzahl der dauerhaften Ausführungen im Status RUNNING |
| ApproximateRunningDurableExecutionsUtilization | Prozentsatz des derzeit in Anspruch genommenen maximalen Kontingents für laufende dauerhafte Ausführungen Ihres Kontos |
| DurableExecutionDuration | Verstrichene Zeit in Millisekunden, während der eine dauerhafte Ausführung im Status RUNNING verharrte |
| DurableExecutionStarted | Anzahl der begonnenen dauerhaften Ausführungen |
| DurableExecutionStopped | Anzahl der dauerhaften Ausführungen, die die API nicht mehr verwenden StopDurableExecution |
| DurableExecutionSucceeded | Anzahl der dauerhaften Ausführungen, die erfolgreich abgeschlossen wurden |
| DurableExecutionFailed | Anzahl der dauerhaften Ausführungen, die mit einem Fehler abgeschlossen wurden |
| DurableExecutionTimedOut | Anzahl der dauerhaften Ausführungen, die ihr konfiguriertes Ausführungstimeout überschritten haben |
| DurableExecutionOperations | Gesamtzahl der Operationen, die innerhalb einer dauerhaften Ausführung ausgeführt wurden (max. 3.000) |
| DurableExecutionStorageWrittenBytes | Kumulierte Datenmenge in Byte, die bei einer dauerhaften Ausführung beibehalten wurde (max.: 100 MB) |
### CloudWatch Metriken
Lambda gibt Standardmetriken für Aufruf, Leistung und Parallelität für langlebige Funktionen aus. Da sich eine dauerhafte Ausführung über mehrere Funktionsaufrufen erstrecken kann, während sie Checkpoints und Wiederholungen durchläuft, verhalten sich diese Metriken anders als bei Standardfunktionen:
+ **Aufrufe: Zählt jeden Funktionsaufruf, einschließlich Wiederholungen**. Eine einzige dauerhafte Ausführung kann mehrere Aufruf-Datenpunkte generieren.
+ **Dauer: Misst** jeden Funktionsaufruf separat. Wird `DurableExecutionDuration` für die Gesamtzeit verwendet, die eine einzelne dauerhafte Ausführung benötigt hat.
+ **Fehler:** Verfolgt Fehler beim Aufrufen von Funktionen. Wird `DurableExecutionFailed` für Fehler auf Ausführungsebene verwendet.
Eine vollständige Liste der Standard-Lambda-Metriken finden Sie unter [Typen von Metriken für Lambda-Funktionen](https://docs.aws.amazon.com//lambda/latest/dg/monitoring-metrics-types.html).
### Alarme erstellen CloudWatch
Erstellen Sie CloudWatch Alarme, um Sie zu benachrichtigen, wenn Messwerte Schwellenwerte überschreiten. Zu den häufigsten Alarmen gehören:
+ `ApproximateRunningDurableExecutionsUtilization`überschreitet 80% Ihres Kontingents
+ `DurableExecutionFailed`steigt über einen Schwellenwert
+ `DurableExecutionTimedOut`weist darauf hin, dass bei Hinrichtungen ein Timeout eintritt
+ `DurableExecutionStorageWrittenBytes`nähert sich den Speichergrenzen
Weitere Informationen finden [Sie unter CloudWatch Alarme verwenden.](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) .
## EventBridge Ereignisse
Lambda veröffentlicht dauerhafte Ereignisse zur Änderung des Ausführungsstatus unter. EventBridge Sie können diese Ereignisse verwenden, um Workflows auszulösen, Benachrichtigungen zu senden oder Änderungen des Ausführungslebenszyklus in Ihren dauerhaften Funktionen nachzuverfolgen.
### Ereignisse zur Änderung des Status dauerhafter Ausführung
Lambda gibt jedes Mal ein Ereignis aus, EventBridge wenn sich der Status einer dauerhaften Ausführung ändert. Diese Ereignisse weisen die folgenden Merkmale auf:
+ **Quelle**: `aws.lambda`
+ **Art des Details:** `Durable Execution Status Change`
Statusänderungsereignisse werden für die folgenden Ausführungsstatus veröffentlicht:
+ `RUNNING`- Die Ausführung wurde gestartet
+ `SUCCEEDED`- Die Ausführung wurde erfolgreich abgeschlossen
+ `STOPPED`- Die Ausführung wurde mithilfe der StopDurableExecution API gestoppt
+ `FAILED`- Die Ausführung ist mit einem Fehler fehlgeschlagen
+ `TIMED_OUT`- Die Ausführung hat das konfigurierte Timeout überschritten
Das folgende Beispiel zeigt ein dauerhaftes Ereignis zur Änderung des Ausführungsstatus:
```
{
"version": "0",
"id": "d019b03c-a8a3-9d58-85de-241e96206538",
"detail-type": "Durable Execution Status Change",
"source": "aws.lambda",
"account": "123456789012",
"time": "2025-11-20T13:08:22Z",
"region": "us-east-1",
"resources": [],
"detail": {
"durableExecutionArn": "arn:aws:lambda:us-east-1:123456789012:function:my-function:$LATEST/durable-execution/090c4189-b18b-4296-9d0c-cfd01dc3a122/9f7d84c9-ea3d-3ffc-b3e5-5ec51c34ffc9",
"durableExecutionName": "order-123",
"functionArn": "arn:aws:lambda:us-east-1:123456789012:function:my-function:2",
"status": "RUNNING",
"startTimestamp": "2025-11-20T13:08:22.345Z"
}
}
```
Bei Terminalzuständen (`SUCCEEDED``STOPPED`,,`FAILED`,`TIMED_OUT`) umfasst das Ereignis ein `endTimestamp` Feld, das angibt, wann die Ausführung abgeschlossen wurde.
### EventBridge Regeln erstellen
Erstellen Sie Regeln, um dauerhafte Ereignisse zur Änderung des Ausführungsstatus an Ziele wie Amazon Simple Notification Service, Amazon Simple Queue Service oder andere Lambda-Funktionen weiterzuleiten.
Im folgenden Beispiel wird eine Regel erstellt, die allen Änderungen des Status der dauerhaften Ausführung entspricht:
```
{
"source": ["aws.lambda"],
"detail-type": ["Durable Execution Status Change"]
}
```
Im folgenden Beispiel wird eine Regel erstellt, die nur auf fehlgeschlagene Ausführungen zutrifft:
```
{
"source": ["aws.lambda"],
"detail-type": ["Durable Execution Status Change"],
"detail": {
"status": ["FAILED"]
}
}
```
Im folgenden Beispiel wird eine Regel erstellt, die Statusänderungen für eine bestimmte Funktion abgleicht:
```
{
"source": ["aws.lambda"],
"detail-type": ["Durable Execution Status Change"],
"detail": {
"functionArn": [{
"prefix": "arn:aws:lambda:us-east-1:123456789012:function:my-function"
}]
}
}
```
Weitere Informationen zum Erstellen von Regeln finden Sie in den [ EventBridge Amazon-Tutorials](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-tutorial.html) im EventBridge Benutzerhandbuch.
## AWS X-Ray Rückverfolgung
Sie können die Röntgenverfolgung für Ihre dauerhaften Funktionen aktivieren. Lambda übergibt den X-Ray-Trace-Header an die dauerhafte Ausführung, sodass Sie Anfragen in Ihrem gesamten Workflow verfolgen können.
Um X-Ray; Tracing mit der Lambda-Konsole zu aktivieren, wählen Sie Ihre Funktion aus, wählen Sie dann Configuration, Monitoring and Operations Tools und aktivieren Sie Active Tracing unter X-Ray.
Um X-Ray Tracing zu aktivieren, verwenden Sie: AWS CLI
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--tracing-config Mode=Active
```
Um die AWS X-Ray Ablaufverfolgung zu aktivieren, verwenden Sie: AWS SAM
```
Resources:
MyDurableFunction:
Type: AWS::Serverless::Function
Properties:
Tracing: Active
DurableConfig:
ExecutionTimeout: 3600
```
Weitere Informationen zu X-Ray [finden Sie im AWS X-Ray Developer Guide.](https://docs.aws.amazon.com//xray/latest/devguide/aws-xray.html)
# Bewährte Methoden für langlebige Lambda-Funktionen
Dauerhafte Funktionen verwenden ein auf Wiedergabe basierendes Ausführungsmodell, das andere Muster erfordert als herkömmliche Lambda-Funktionen. Folgen Sie diesen bewährten Methoden, um zuverlässige und kostengünstige Workflows zu erstellen.
## Schreiben Sie deterministischen Code
Während der Wiedergabe wird Ihre Funktion von Anfang an ausgeführt und muss demselben Ausführungspfad folgen wie die ursprüngliche Ausführung. Code außerhalb dauerhafter Operationen muss deterministisch sein und bei denselben Eingaben dieselben Ergebnisse liefern.
**Unterteilen Sie nichtdeterministische Operationen schrittweise:**
+ Generierung von Zufallszahlen und UUIDs
+ Aktuelle Uhrzeit oder Zeitstempel
+ Externe API-Aufrufe und Datenbankabfragen
+ Dateisystemoperationen
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
import { randomUUID } from 'crypto';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Generate transaction ID inside a step
const transactionId = await context.step('generate-transaction-id', async () => {
return randomUUID();
});
// Use the same ID throughout execution, even during replay
const payment = await context.step('process-payment', async () => {
return processPayment(event.amount, transactionId);
});
return { statusCode: 200, transactionId, payment };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid
@durable_execution
def handler(event, context: DurableContext):
# Generate transaction ID inside a step
transaction_id = context.step(
lambda _: str(uuid.uuid4()),
name='generate-transaction-id'
)
# Use the same ID throughout execution, even during replay
payment = context.step(
lambda _: process_payment(event['amount'], transaction_id),
name='process-payment'
)
return {'statusCode': 200, 'transactionId': transaction_id, 'payment': payment}
```
------
**Wichtig**
Verwenden Sie keine globalen Variablen oder Schließungen, um den Status zwischen Schritten zu teilen. Übergeben Sie Daten durch Rückgabewerte. Der globale Status wird während der Wiedergabe unterbrochen, weil Schritte zwischengespeicherte Ergebnisse zurückgeben, globale Variablen jedoch zurückgesetzt werden.
**Vermeiden Sie Mutationen bei Verschlüssen:** Variablen, die in Closures erfasst wurden, können während der Wiedergabe Mutationen verlieren. Schritte geben zwischengespeicherte Ergebnisse zurück, aber Variablenaktualisierungen außerhalb des Schritts werden nicht wiederholt.
------
#### [ TypeScript ]
```
// ❌ WRONG: Mutations lost on replay
export const handler = withDurableExecution(async (event, context) => {
let total = 0;
for (const item of items) {
await context.step(async () => {
total += item.price; // ⚠️ Mutation lost on replay!
return saveItem(item);
});
}
return { total }; // Inconsistent value!
});
// ✅ CORRECT: Accumulate with return values
export const handler = withDurableExecution(async (event, context) => {
let total = 0;
for (const item of items) {
total = await context.step(async () => {
const newTotal = total + item.price;
await saveItem(item);
return newTotal; // Return updated value
});
}
return { total }; // Consistent!
});
// ✅ EVEN BETTER: Use map for parallel processing
export const handler = withDurableExecution(async (event, context) => {
const results = await context.map(
items,
async (ctx, item) => {
await ctx.step(async () => saveItem(item));
return item.price;
}
);
const total = results.getResults().reduce((sum, price) => sum + price, 0);
return { total };
});
```
------
#### [ Python ]
```
# ❌ WRONG: Mutations lost on replay
@durable_execution
def handler(event, context: DurableContext):
total = 0
for item in items:
context.step(
lambda _: save_item_and_mutate(item, total), # ⚠️ Mutation lost on replay!
name=f'save-item-{item["id"]}'
)
return {'total': total} # Inconsistent value!
# ✅ CORRECT: Accumulate with return values
@durable_execution
def handler(event, context: DurableContext):
total = 0
for item in items:
total = context.step(
lambda _: save_item_and_return_total(item, total),
name=f'save-item-{item["id"]}'
)
return {'total': total} # Consistent!
# ✅ EVEN BETTER: Use map for parallel processing
@durable_execution
def handler(event, context: DurableContext):
def process_item(ctx, item):
ctx.step(lambda _: save_item(item))
return item['price']
results = context.map(items, process_item)
total = sum(results.get_results())
return {'total': total}
```
------
## Design für Idempotenz
Operationen können aufgrund von Wiederholungen oder Wiederholungen mehrfach ausgeführt werden. Operationen, die nicht idempotent sind, haben doppelte Nebenwirkungen, z. B. doppelte Gebühren für Kunden oder das Senden mehrerer E-Mails.
**Verwenden Sie Idempotenz-Token:** Generieren Sie Token innerhalb von Schritten und fügen Sie sie externen API-Aufrufen hinzu, um doppelte Operationen zu vermeiden.
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Generate idempotency token once
const idempotencyToken = await context.step('generate-idempotency-token', async () => {
return crypto.randomUUID();
});
// Use token to prevent duplicate charges
const charge = await context.step('charge-payment', async () => {
return paymentService.charge({
amount: event.amount,
cardToken: event.cardToken,
idempotencyKey: idempotencyToken
});
});
return { statusCode: 200, charge };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid
@durable_execution
def handler(event, context: DurableContext):
# Generate idempotency token once
idempotency_token = context.step(
lambda _: str(uuid.uuid4()),
name='generate-idempotency-token'
)
# Use token to prevent duplicate charges
def charge_payment(_):
return payment_service.charge(
amount=event['amount'],
card_token=event['cardToken'],
idempotency_key=idempotency_token
)
charge = context.step(charge_payment, name='charge-payment')
return {'statusCode': 200, 'charge': charge}
```
------
** at-most-onceSemantik verwenden:** Für kritische Operationen, die sich niemals duplizieren dürfen (Finanztransaktionen, Inventarabzüge), konfigurieren Sie den Ausführungsmodus. at-most-once
------
#### [ TypeScript ]
```
// Critical operation that must not duplicate
await context.step('deduct-inventory', async () => {
return inventoryService.deduct(event.productId, event.quantity);
}, {
executionMode: 'AT_MOST_ONCE_PER_RETRY'
});
```
------
#### [ Python ]
```
# Critical operation that must not duplicate
context.step(
lambda _: inventory_service.deduct(event['productId'], event['quantity']),
name='deduct-inventory',
config=StepConfig(execution_mode='AT_MOST_ONCE_PER_RETRY')
)
```
------
**Datenbankidempotenz:** Verwenden Sie check-before-write Muster, bedingte Aktualisierungen oder Upsert-Operationen, um doppelte Datensätze zu verhindern.
## Verwalten Sie den Status effizient
Jeder Checkpoint speichert den Status im persistenten Speicher. Große Zustandsobjekte erhöhen die Kosten, verlangsamen Checkpoints und beeinträchtigen die Leistung. Speichern Sie nur wichtige Daten zur Workflow-Koordination.
**Halten Sie den Status minimal:**
+ Speichern IDs und Verweise, nicht vollständige Objekte
+ Rufen Sie nach Bedarf detaillierte Daten in Schritten ab
+ Verwenden Sie Amazon S3 oder DynamoDB für große Datenmengen, übergeben Sie Referenzen im Status
+ Vermeiden Sie es, große Nutzlasten zwischen den Schritten weiterzugeben
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Store only the order ID, not the full order object
const orderId = event.orderId;
// Fetch data within each step as needed
await context.step('validate-order', async () => {
const order = await orderService.getOrder(orderId);
return validateOrder(order);
});
await context.step('process-payment', async () => {
const order = await orderService.getOrder(orderId);
return processPayment(order);
});
return { statusCode: 200, orderId };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
@durable_execution
def handler(event, context: DurableContext):
# Store only the order ID, not the full order object
order_id = event['orderId']
# Fetch data within each step as needed
context.step(
lambda _: validate_order(order_service.get_order(order_id)),
name='validate-order'
)
context.step(
lambda _: process_payment(order_service.get_order(order_id)),
name='process-payment'
)
return {'statusCode': 200, 'orderId': order_id}
```
------
## Entwerfen Sie effektive Schritte
Stufen sind die grundlegende Arbeitseinheit für langlebige Funktionen. Gut durchdachte Schritte erleichtern das Verständnis, das Debuggen und die Wartung von Workflows.
**Prinzipien der schrittweisen Gestaltung:**
+ **Verwende aussagekräftige Namen** — Namen wie, `validate-order` anstatt Logs und Fehler leichter verständlich zu `step1` machen
+ **Namen statisch halten** — Verwenden Sie keine dynamischen Namen mit Zeitstempeln oder Zufallswerten. Schrittnamen müssen für die Wiedergabe deterministisch sein
+ **Ausgewogene Granularität** — Teilen Sie komplexe Vorgänge in gezielte Schritte auf, vermeiden Sie jedoch übermäßig kleine Schritte, die den Aufwand an den Checkpoints erhöhen
+ **Gruppenbezogene Operationen** — Operationen, die gemeinsam erfolgreich sein oder fehlschlagen sollten, gehören in denselben Schritt
## Verwenden Sie Warteoperationen effizient
Wartevorgänge unterbrechen die Ausführung, ohne Ressourcen zu verbrauchen oder Kosten zu verursachen. Verwenden Sie sie, anstatt Lambda am Laufen zu halten.
**Zeitbasierte Wartezeiten:** Verwenden Sie diese Option `context.wait()` für Verzögerungen anstelle von oder. `setTimeout` `sleep`
**Externe Rückrufe:** `context.waitForCallback()` Wird verwendet, wenn auf externe Systeme gewartet wird. Stellen Sie immer Timeouts ein, um unbestimmte Wartezeiten zu vermeiden.
**Polling: Verwenden Sie diese Option** `context.waitForCondition()` mit exponentiellem Backoff, um externe Dienste abzufragen, ohne sie zu überfordern.
------
#### [ TypeScript ]
```
// Wait 24 hours without cost
await context.wait({ seconds: 86400 });
// Wait for external callback with timeout
const result = await context.waitForCallback(
'external-job',
async (callbackId) => {
await externalService.submitJob({
data: event.data,
webhookUrl: `https://api.example.com/callbacks/${callbackId}`
});
},
{ timeout: { seconds: 3600 } }
);
```
------
#### [ Python ]
```
# Wait 24 hours without cost
context.wait(86400)
# Wait for external callback with timeout
result = context.wait_for_callback(
lambda callback_id: external_service.submit_job(
data=event['data'],
webhook_url=f'https://api.example.com/callbacks/{callback_id}'
),
name='external-job',
config=WaitForCallbackConfig(timeout_seconds=3600)
)
```
------
## Weitere Überlegungen
**Fehlerbehandlung:** Versuchen Sie es erneut mit vorübergehenden Fehlern wie Netzwerk-Timeouts und Ratenbegrenzungen. Versuchen Sie es nicht erneut mit dauerhaften Fehlern wie ungültigen Eingabe- oder Authentifizierungsfehlern. Konfigurieren Sie Wiederholungsstrategien mit einer angemessenen maximalen Anzahl von Versuchen und Backoff-Raten. Ausführliche Beispiele finden Sie unter [Fehlerbehandlung](durable-execution-sdk-retries.md) und Wiederholungen.
**Leistung:** Minimiere die Größe von Checkpoints, indem du Referenzen statt vollständiger Payloads speicherst. Verwenden Sie `context.parallel()` und`context.map()`, um unabhängige Operationen gleichzeitig auszuführen. Batch-bezogene Operationen zur Reduzierung des Checkpoint-Overheads.
**Versionierung:** Rufen Sie Funktionen mit Versionsnummern oder Aliasnamen auf, um Ausführungen an bestimmte Codeversionen zu binden. Stellen Sie sicher, dass neue Codeversionen den Status älterer Versionen verarbeiten können. Benennen Sie Schritte nicht um und ändern Sie ihr Verhalten nicht so, dass die Wiedergabe unterbrochen wird.
**Serialisierung:** Verwenden Sie JSON-kompatible Typen für Operationseingaben und -ergebnisse. Konvertiert Datumsangaben in ISO-Zeichenketten und benutzerdefinierte Objekte in einfache Objekte, bevor Sie sie an dauerhafte Operationen übergeben.
**Überwachung:** Aktivieren Sie die strukturierte Protokollierung mit Ausführungs IDs - und Schrittnamen. Richten Sie CloudWatch Alarme für Fehlerraten und Ausführungsdauer ein. Verwenden Sie Tracing, um Engpässe zu identifizieren. Eine ausführliche Anleitung finden Sie unter [Überwachung](durable-monitoring.md) und Debuggen.
**Testen: Testen** Sie Happy Path, Fehlerbehandlung und Wiedergabeverhalten. Testen Sie Timeout-Szenarien für Rückrufe und Wartezeiten. Verwenden Sie lokale Tests, um die Iterationszeit zu reduzieren. Eine ausführliche Anleitung finden Sie unter [Dauerhafte Funktionen testen](durable-testing.md).
**Häufige Fehler, die Sie vermeiden sollten:** Verschachteln Sie `context.step()` Anrufe nicht, sondern verwenden Sie stattdessen untergeordnete Kontexte. Fassen Sie nicht deterministische Operationen schrittweise zusammen. Legen Sie immer Timeouts für Rückrufe fest. Gleichen Sie die Granularität der Schritte mit dem Checkpoint-Overhead ab. Speichern Sie Referenzen statt großer Objekte im Status.
## Weitere Ressourcen
+ [Python SDK-Dokumentation](https://github.com/aws/aws-durable-execution-sdk-python/tree/main/docs) — Vollständige API-Referenz, Testmuster und erweiterte Beispiele
+ [TypeScript SDK-Dokumentation](https://github.com/aws/aws-durable-execution-sdk-js/tree/main/docs) — Vollständige API-Referenz, Testmuster und Beispiele für Fortgeschrittene