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 les fonctions durables de Lambda

Les fonctions Lambda durables prennent en charge les mêmes méthodes d'appel que les autres fonctions Lambda. 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 autres fonctions, 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 à 15 minutes, ou moins si le délai d'expiration de la fonction ou le délai d'exécution est inférieur. Utilisez l'invocation synchrone lorsque vous avez besoin de résultats immédiats ou lorsque vous intégrez des API et 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 scénarios « fire and forget » ou lorsque le traitement peut se faire 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.

Exigence d'ARN qualifiés

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 épinglée à la version de la fonction qui l'a lancée. Si votre fonction s'arrête et reprend des heures ou des jours plus tard, Lambda invoque la même version. La publication d'une nouvelle version n'affecte donc que les nouvelles exécutions. De même, lorsque vous mettez à jour un alias, les nouvelles exécutions utilisent la nouvelle version et les exécutions en cours se poursuivent sur la version sur laquelle elles ont débuté.

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 permettent 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. À utiliser $LATEST uniquement pour le prototypage ou pour raccourcir les délais de déploiement pendant le développement, car les exécutions risquent de ne pas être reexécutées correctement si le code change pendant leur exécution.

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 :

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 les API d'exécution durable pour suivre l'état d'exécution et obtenir les résultats finaux.

Invocation depuis le code de l'application

Utilisez les AWS SDK pour invoquer des fonctions durables à partir du code de votre application, avec la même Invoke API que celle que vous utilisez pour n'importe quelle fonction Lambda. Incluez un numéro de version, un alias ou $LATEST dans le nom de la fonction :

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 appeler n'importe quelle fonction Lambda, y compris une autre fonction durable, en utilisant l'invokeopération from. DurableContext Cela crée un appel enchaîné où la fonction appelante est suspendue jusqu'à ce que la fonction invoquée soit terminé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.