Dauerhafte Lambda-Funktionen aufrufen - AWS Lambda
Methoden zum AufrufenQualifizierte Anforderung ARNs Den Ausführungslebenszyklus verstehenAus dem Anwendungscode aufrufenVerkettete Aufrufe

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Dauerhafte Lambda-Funktionen 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.

Methoden zum Aufrufen

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.


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.


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 mit dauerhaften Funktionen.

Vollständige Informationen zu den einzelnen Aufrufmethoden finden Sie unter synchroner Aufruf und asynchroner Aufruf.

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.

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 gewährleisten eine 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 sich über mehrere Funktionsaufrufe erstrecken 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.

  2. Ausführung und Checkpointing: Während Ihre Funktion dauerhafte Operationen ausführt, erstellt das SDK Checkpoints, die den Fortschritt verfolgen.

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

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

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