Dauerhafte Lambda-Funktionen aufrufen

Dauerhafte Lambda-Funktionen unterstützen dieselben Aufrufmethoden wie andere Lambda-Funktionen. Sie können langlebige Funktionen synchron, asynchron oder über Zuordnungen von Ereignisquellen aufrufen. Der Aufrufvorgang ist mit anderen Funktionen identisch, 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 sind auf 15 Minuten begrenzt, oder weniger, wenn das Funktions- oder Ausführungstimeout niedriger ist. Verwenden Sie synchrone Aufrufe, wenn Sie sofortige Ergebnisse benötigen oder wenn Sie APIs und Dienste integrieren, die eine Antwort erwarten. 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 asynchrone Aufrufe 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) zur Fehlerbehandlung, unterstützen jedoch keine Lambda-Destinationen. Konfigurieren Sie einen DLQ, um Datensätze von fehlgeschlagenen Aufrufen zu erfassen.

Qualifizierte ARNs erforderlich

Dauerhafte Funktionen erfordern 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 Funktionsversion angeheftet, mit der sie gestartet wurde. Wenn Ihre Funktion Stunden oder Tage später angehalten und wieder aufgenommen wird, ruft Lambda dieselbe Version auf, sodass sich die Veröffentlichung einer neuen Version nur auf neue Ausführungen auswirkt. In ähnlicher Weise verwenden neue Ausführungen, wenn Sie einen Alias aktualisieren, die neue Version, und laufende Ausführungen werden mit der Version fortgesetzt, mit der sie gestartet wurden.

$LATEST-Ausführungen können bei aktualisiertem Code wieder aufgenommen werden

Ausführungen, die mit dem $LATEST Qualifier gestartet wurden, sind nicht an eine feste Kopie Ihres Codes angeheftet. Wenn Sie Ihren Funktionscode aktualisieren, während eine Ausführung unterbrochen ist, wird die Ausführung mit dem neuen Code fortgesetzt und nicht mit der Version, mit der sie gestartet wurde.

Ihr Code verarbeitet den gespeicherten Ausführungsstatus möglicherweise nicht mehr auf dieselbe Weise, was zu Fehlern führt, die nicht deterministisch sind oder zu unbemerkten Fehlern führen. Weitere Hinweise zum Schreiben von Funktionen, die sicher wiedergegeben werden können, finden Sie unter. Funktionsversionen und Aliase

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. Verwenden Sie diese $LATEST Option nur für die Prototypenerstellung oder zur Verkürzung der Bereitstellungszeiten während der Entwicklung, da Ausführungen möglicherweise nicht korrekt wiedergegeben werden, wenn sich der Code während der Ausführung ä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 dauerhaften Ausführungs-APIs, um den Ausführungsstatus zu verfolgen und die Endergebnisse abzurufen.

Aus dem Anwendungscode aufrufen

Verwenden Sie die AWS SDKs, um dauerhafte Funktionen aus Ihrem Anwendungscode aufzurufen, und zwar mit derselben Invoke API, die Sie für jede Lambda-Funktion verwenden. Fügen Sie eine Versionsnummer, einen Alias oder $LATEST in den Funktionsnamen ein:

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 jede Lambda-Funktion aufrufen, einschließlich einer anderen dauerhaften Funktion, indem sie die invoke Operation von verwenden. DurableContext Dadurch wird ein verketteter Aufruf erzeugt, bei dem die aufrufende Funktion angehalten wird, 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

Cross-account Verkettete Aufrufe werden nicht unterstützt. Die aufgerufene Funktion muss sich in demselben AWS Konto wie die aufrufende Funktion befinden.