AWS Durable Functions: Lambda-Workflows ohne Step Functions umsetzen

Mit AWS Lambda Durable Functions führt Amazon eine bahnbrechende Neuerung ein, die die Entwicklung von langlaufenden Workflows revolutioniert. Diese Technologie ermöglicht es Lambda-Funktionen, ihren Ausführungsstatus zu speichern, nach Ausfällen ohne vollständigen Neuanlauf fortzusetzen und bis zu ein Jahr lang zu pausieren – ohne dabei Rechenzeitkosten zu verursachen. Besonders für Entwicklerteams, die bisher auf Azure Durable Functions oder Temporal zurückgriffen, bietet diese Lösung eine vertraute, aber vollständig in AWS integrierte Alternative.

Warum AWS Durable Functions eine Gamechanger sind

Traditionelle Lambda-Funktionen führen ihre Aufgaben in einer einzigen, maximalen Ausführungszeit von 15 Minuten durch. Bei Fehlern in Schritt 7 von 10 muss die gesamte Funktion neu gestartet werden. Für menschliche Interaktionen wie Genehmigungen oder verzögerte Aktionen waren bisher komplexe Lösungen mit DynamoDB-Tabellen, API-Gateway-Endpunkten und Callback-Logik erforderlich. Die meisten Teams griffen dazu auf AWS Step Functions zurück, die zwar funktionieren, aber eine Trennung zwischen Geschäftslogik (in Lambda) und Orchestrierungslogik (in Step Functions) erzwingen.

AWS Durable Functions vereint beides in einer einzigen Codebasis. Entwickler können nun Workflows direkt in ihrer bevorzugten Programmiersprache implementieren, ohne zwischen verschiedenen mentalen Modellen wechseln zu müssen. Diese Integration vereinfacht die Codebasis erheblich und beschleunigt die Entwicklung.

Technische Funktionsweise und zentrale Features

Die Aktivierung von Durable Execution erfolgt über eine DurableConfig-Konfiguration in SAM-Templates oder CDK-Konstrukten. Anschließend steht Entwicklern ein SDK mit mehreren Kernfunktionen zur Verfügung:

• `context.step()` führt einen Codeblock aus und speichert das Ergebnis. Bei einem späteren Fehler oder Neustart wird dieser Schritt übersprungen und das zwischengespeicherte Ergebnis zurückgegeben.

• `context.wait()` pausiert die Ausführung für eine definierte Dauer – ohne dabei Rechenzeitkosten zu verursachen.

• `context.waitForCallback()` hält die Funktion an, bis ein externes System eine Antwort zurückgibt. Die maximale Wartezeit beträgt ein Jahr.

• `context.waitForCondition()` prüft in regelmäßigen Abständen eine Bedingung und setzt die Ausführung fort, sobald diese erfüllt ist.

• `context.parallel()` ermöglicht die parallele Ausführung mehrerer durabler Operationen.

• `context.invoke()` ruft eine andere Lambda-Funktion auf und speichert das Ergebnis.

Hinter den Kulissen nutzt AWS ein Checkpoint/Replay-Mechanismus. Bei einem Neustart oder nach einer Wartezeit wird die Funktion vom Anfang ausgeführt. Das SDK durchläuft bereits abgeschlossene Schritte sofort und setzt die Ausführung exakt an der Stelle fort, an der sie unterbrochen wurde – ohne manuelle Zustandsverwaltung.

Praktische Umsetzung: Ein Beispielworkflow

Ein typisches Szenario ist die Benutzerregistrierung mit E-Mail-Verifizierung. Der folgende Code demonstriert, wie sich dieser Prozess mit Durable Functions umsetzen lässt:

import { DurableContext, withDurableExecution } from '@aws/durable-execution-sdk-js';

export const handler = withDurableExecution(
  async (event, context: DurableContext) => {
    // Schritt 1: Benutzerprofil erstellen
    const profile = await context.step("create-profile", async () => 
      createUserProfile(event.email, event.name)
    );

    // Schritt 2: Auf E-Mail-Verifizierung warten (max. 24 Stunden)
    const verification = await context.waitForCallback(
      "wait-for-email-verification",
      async (callbackId) => {
        await sendVerificationEmail(profile, callbackId);
      },
      { timeout: { hours: 24 } }
    );

    // Schritt 3: Abschlussbehandlung
    const result = await context.step("complete-onboarding", async () => {
      if (!verification?.verified) {
        return { ...profile, status: 'failed' };
      }
      await sendWelcomeEmail(profile.email, profile.name);
      return { ...profile, status: 'active' };
    });

    return result;
  }
);

In diesem Beispiel wird das Benutzerprofil erstellt und eine Verifizierungs-E-Mail versendet. Die Funktion pausiert dann für bis zu 24 Stunden, bis der Benutzer auf den Link klickt. Während dieser Wartezeit entstehen keine Kosten. Nach der Verifizierung setzt die Funktion die Ausführung nahtlos fort und sendet eine Willkommens-E-Mail – ohne dass der Entwickler manuell den Zustand verwalten muss.

Die dazugehörige SAM-Konfiguration sieht wie folgt aus:

Resources:
  UserOnboardingFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: UserOnboardingFunction
      CodeUri: ./src
      Handler: index.handler
      Runtime: nodejs24.x
      Timeout: 60
      DurableConfig:
        ExecutionTimeout: 90000  # 25 Stunden
        RetentionPeriodInDays: 7

Wichtig ist der Unterschied zwischen Timeout (maximal 15 Minuten pro Ausführung) und ExecutionTimeout (gesamte Laufzeit inkl. Wartezeiten, bis zu einem Jahr).

Step Functions vs. Durable Functions: Wann was nutzen?

Die Entscheidung zwischen beiden Technologien hängt von den spezifischen Anforderungen ab:

AWS Durable Functions eignen sich besonders für:

• Teams, die mit Standard-Programmiersprachen und vertrauten Entwicklungstools arbeiten
• Workflows, die hauptsächlich aus Lambda-Funktionen bestehen, die andere AWS-Dienste über das SDK ansprechen
• Szenarien, in denen die Orchestrierungs- und Geschäftslogik in derselben Datei gepflegt werden sollen
• Entwickler, die den Checkpoint/Replay-Mechanismus verstehen und lokal mit sam local invoke testen möchten

AWS Step Functions sind die bessere Wahl bei:

• Orchestrierung mehrerer AWS-Dienste mit nativen Integrationen (SQS, SNS, DynamoDB, ECS)
• Anforderungen, dass auch Nicht-Entwickler die Workflows verstehen müssen (visueller Designer)
• Szenarien, in denen keine Runtime-Wartung gewünscht ist (keine SDK-Updates erforderlich)
• Nutzung von über 220 direkten Service-Integrationen ohne zusätzliche Lambda-Funktionen

Eine Kombination beider Technologien kann sinnvoll sein, wenn:

• Step Functions die hochlevelige Steuerung über mehrere AWS-Dienste übernimmt
• Durable Functions komplexe Anwendungslogik innerhalb einzelner Lambda-Funktionen abbildet

Grundsätzlich gilt: Durable Functions reduzieren den Overhead für Lambda-interne Workflows deutlich. Step Functions bieten dagegen mehr Flexibilität für cross-service-Orchestrierung. Wer beispielsweise einen Workflow wie "Lambda → Lambda → Lambda mit zwischengeschalteten Wartezeiten“ umsetzt, profitiert von Durable Functions. Bei Workflows mit nativen AWS-Integrationen wie „SQS-Nachricht empfangen → in DynamoDB schreiben → ECS-Task starten → auf Abschluss warten → SNS-Benachrichtigung senden“ ist Step Functions die effizientere Lösung.

Fazit: Effizienzsteigerung für Lambda-Workflows

AWS Durable Functions markieren einen wichtigen Schritt in der Evolution serverloser Anwendungen. Durch die Integration von Orchestrierungsfähigkeiten direkt in Lambda-Funktionen entfallen komplexe Zustandsverwaltung und externe Abhängigkeiten. Entwickler erhalten mehr Freiheit bei der Gestaltung ihrer Workflows, während gleichzeitig die Kosten für Wartezeiten entfallen. Für Teams, die bisher auf Step Functions oder Drittanbieter-Lösungen wie Temporal angewiesen waren, bietet diese AWS-native Alternative eine attraktive Vereinfachung. Die Zukunft serverloser Anwendungen wird zunehmend von solchen integrierten Lösungen geprägt sein – und AWS Durable Functions sind ein überzeugender Beweis dafür.