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.

Invocation de fonctions Lambda durables

Les fonctions Lambda durables prennent en charge les mêmes méthodes d'appel que les fonctions Lambda standard. Vous pouvez invoquer 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 de l'état.

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 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 démarrer une exécution idempotente, utilisez le paramètre de nom d'exécution comme décrit dans Idempotence.

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

Invocation asynchrone : mettez un événement en file d'attente pour traitement sans attendre de réponse. Lambda place l'événement dans une file d'attente et y retourne immédiatement. Les appels asynchrones prennent en charge des durées d'exécution allant jusqu'à 1 an. Utilisez l'invocation asynchrone pour les scénarios de type « fire and forget » ou lorsque le traitement peut avoir lieu en arrière-plan. Pour démarrer une exécution idempotente, utilisez le paramètre de nom d'exécution comme décrit dans Idempotence.

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 invoquer 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 de l'événement et invoquent votre fonction avec des lots d'enregistrements. Pour plus de détails sur l'utilisation de mappages de sources d'événements avec des fonctions durables, y compris les limites de durée d'exécution, consultez Mappages de sources d'événements avec des fonctions durables.

Pour plus de détails sur chaque méthode d'invocation, consultez les rubriques Invocation synchrone et Invocation asynchrone.

Exigence d'ARN qualifiés

Les fonctions durables nécessitent des identifiants qualifiés pour être invoquées. Vous devez invoquer des fonctions durables à l'aide d'un numéro de version, d'un alias ou$LATEST. Vous pouvez utiliser soit un ARN complet, soit un nom de fonction avec un version/alias suffixe. Vous ne pouvez pas utiliser d'identifiant non qualifié (sans suffixe de version ou 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 démarré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 commencé.

Bonne pratique

Utilisez plutôt $LATEST des versions numérotées ou des alias pour les fonctions durables de production. 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 se reproduire correctement si le code change pendant leur exécution.

Comprendre le cycle de vie d'exécution

Lorsque vous invoquez une fonction durable, Lambda crée une exécution durable qui peut couvrir plusieurs appels de fonctions :

Pour les appels synchrones, l'appelant attend la fin de l'exécution durable dans son intégralité, 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 appels asynchrones, Lambda renvoie immédiatement et l'exécution se poursuit indépendamment. Utilisez les API d'exécution durables pour suivre l'état d'exécution et récupérer les résultats finaux.

Invocation à partir du code de l'application

Utilisez les AWS SDK 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 from. DurableContext Cela crée une invocation en chaîne dans laquelle 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 reprend depuis le point de contrôle avec le résultat de la fonction invoquée, sans réinvoquer la fonction.