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.

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 und Python SDK 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 werden kann 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

DurableContextist 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 verwendetasync/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 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 verwendetcontext.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.

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 DurableConfigObjekt 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 sich nach Ausfällen wiederherstellt.

Wenn Sie beispielsweise ein dauerhaftes Ausführungstimeout von 24 Stunden und ein Lambda-Funktions-Timeout von 5 Minuten festlegen:

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).

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_OUT).

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.