Invoquer des fonctions Lambda durables - AWS Lambda
Méthodes d'invocation ARNs Exigence qualifiéeComprendre le cycle de vie d'exécutionInvocation depuis le code de l'applicationInvocations enchaînées

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Invoquer des fonctions Lambda durables

Les fonctions Lambda durables prennent en charge les mêmes méthodes d'appel que les fonctions Lambda standard. Vous pouvez appeler des fonctions durables de manière synchrone, asynchrone ou via des mappages de sources d'événements. Le processus d'invocation est identique aux fonctions standard, mais les fonctions durables offrent des fonctionnalités supplémentaires pour les exécutions de longue durée et la gestion automatique des états.

Méthodes d'invocation

Invocation synchrone : invoquez une fonction durable et attendez la réponse. Les appels synchrones sont limités par le Lambda à 15 minutes (ou moins, selon la fonction configurée et le délai d'exécution). Utilisez l'invocation synchrone lorsque vous avez besoin de résultats immédiats ou lorsque vous intégrez APIs des services qui attendent une réponse. Vous pouvez utiliser les opérations d'attente pour un calcul efficace sans perturber l'appelant : l'invocation attend la fin de l'exécution durable complète. Pour les démarrages d'exécution idempotents, utilisez le paramètre de nom d'exécution tel que décrit dans Idempotentie.


aws lambda invoke \
  --function-name my-durable-function:1 \
  --cli-binary-format raw-in-base64-out \
  --payload '{"orderId": "12345"}' \
  response.json

Invocation asynchrone : mettez en file d'attente un événement pour qu'il soit traité sans attendre de réponse. Lambda place l'événement dans une file d'attente et y retourne immédiatement. Les invocations asynchrones prennent en charge des durées d'exécution allant jusqu'à 1 an. Utilisez l'invocation asynchrone pour les fire-and-forget scénarios ou lorsque le traitement peut avoir lieu en arrière-plan. Pour les démarrages d'exécution idempotents, utilisez le paramètre de nom d'exécution tel que décrit dans Idempotentie.


aws lambda invoke \
  --function-name my-durable-function:1 \
  --invocation-type Event \
  --cli-binary-format raw-in-base64-out \
  --payload '{"orderId": "12345"}' \
  response.json

Mappages de sources d'événements : configurez Lambda pour appeler automatiquement votre fonction durable lorsque des enregistrements sont disponibles à partir de services basés sur des flux ou des files d'attente tels qu'Amazon SQS, Kinesis ou DynamoDB. Les mappages de sources d'événements interrogent la source d'événements et invoquent votre fonction avec des lots d'enregistrements. Pour plus de détails sur l'utilisation des mappages de sources d'événements avec des fonctions durables, y compris les limites de durée d'exécution, voir Mappages de sources d'événements avec des fonctions durables.

Pour obtenir des informations complètes sur chaque méthode d'appel, consultez les sections Invocation synchrone et Invocation asynchrone.

Note

Les fonctions durables prennent en charge les files d'attente en lettres mortes (DLQs) pour la gestion des erreurs, mais ne prennent pas en charge les destinations Lambda. Configurez un DLQ pour capturer les enregistrements des appels ayant échoué.

ARNs Exigence qualifiée

Les fonctions durables nécessitent des identifiants qualifiés pour l'invocation. Vous devez invoquer des fonctions durables à l'aide d'un numéro de version, d'un alias ou$LATEST. Vous pouvez utiliser un ARN qualifié complet ou un nom de fonction avec version/alias suffixe. Vous ne pouvez pas utiliser un identifiant non qualifié (sans version ni suffixe d'alias).

Invocations valides :


# 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

Invocations non valides :


# Unqualified ARN (not allowed)
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function

# Unqualified function name (not allowed)
my-durable-function

Cette exigence garantit que les exécutions durables restent cohérentes tout au long de leur cycle de vie. Lorsqu'une exécution durable démarre, elle est associée à la version de fonction spécifique. Si votre fonction s'arrête et reprend des heures ou des jours plus tard, Lambda invoque la même version qui a démarré l'exécution, garantissant ainsi la cohérence du code dans l'ensemble du flux de travail.

Bonne pratique

Utilisez plutôt $LATEST des versions numérotées ou des alias pour produire des fonctions durables. Les versions numérotées sont immuables et garantissent une rediffusion déterministe. Les alias fournissent éventuellement une référence stable que vous pouvez mettre à jour pour pointer vers de nouvelles versions sans modifier le code d'appel. Lorsque vous mettez à jour un alias, les nouvelles exécutions utilisent la nouvelle version, tandis que les exécutions en cours reprennent leur version d'origine. Vous pouvez l'utiliser $LATEST pour le prototypage ou pour raccourcir les délais de déploiement pendant le développement, en sachant que les exécutions risquent de ne pas se reproduire correctement (voire d'échouer) si le code sous-jacent change pendant les exécutions.

Comprendre le cycle de vie d'exécution

Lorsque vous appelez une fonction durable, Lambda crée une exécution durable qui peut couvrir plusieurs invocations de fonction :

  1. Invocation initiale : votre demande d'invocation crée une nouvelle exécution durable. Lambda attribue un ID d'exécution unique et lance le traitement.

  2. Exécution et pointage : lorsque votre fonction exécute des opérations durables, le SDK crée des points de contrôle qui permettent de suivre la progression.

  3. Suspension (si nécessaire) : si votre fonction utilise des temps d'attente prolongés, tels que wait des tentatives ou des tentatives automatiqueswaitForCallback, Lambda suspend l'exécution et arrête de facturer le temps de calcul.

  4. Reprise : au moment de reprendre (y compris après de nouvelles tentatives), Lambda invoque à nouveau votre fonction. Le SDK rejoue le journal des points de contrôle et continue à partir de l'endroit où l'exécution a été interrompue.

  5. Achèvement : lorsque votre fonction renvoie un résultat final ou renvoie une erreur non gérée, l'exécution durable est terminée.

Pour les invocations synchrones, l'appelant attend la fin complète de l'exécution durable, y compris les opérations d'attente. Si l'exécution dépasse le délai d'invocation (15 minutes ou moins), l'invocation expire. Pour les invocations asynchrones, Lambda revient immédiatement et l'exécution se poursuit indépendamment. Utilisez l'exécution durable APIs pour suivre l'état d'exécution et obtenir les résultats finaux.

Invocation depuis le code de l'application

Utilisez le AWS SDKs pour invoquer des fonctions durables à partir du code de votre application. Le processus d'invocation est identique aux fonctions standard :

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'})
)

Invocations enchaînées

Les fonctions durables peuvent invoquer d'autres fonctions durables et non durables à l'aide de l'invokeopération deDurableContext. Cela crée un appel enchaîné dans lequel la fonction appelante attend (suspend) la fin de la fonction invoquée :

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

Les invocations enchaînées créent un point de contrôle dans la fonction d'appel. Si la fonction appelante est interrompue, elle repart du point de contrôle avec le résultat de la fonction invoquée, sans la réinvoquer.

Note

Les invocations chaînées entre comptes ne sont pas prises en charge. La fonction invoquée doit se trouver dans le même AWS compte que la fonction appelante.