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.

Concepts de base

Lambda fournit une exécution durable SDKs pour JavaScript TypeScript, et Python. Ils SDKs constituent la base de la création de fonctions durables, fournissant les primitives dont vous avez besoin pour contrôler la progression, gérer les nouvelles tentatives et gérer le flux d'exécution. Pour obtenir une documentation complète et des exemples du SDK, consultez le TypeScript SDKJavaScript/et le SDK Python sur. GitHub

Exécution durable

Une exécution durable représente le cycle de vie complet d'une fonction durable Lambda, utilisant un point de contrôle et un mécanisme de réexécution pour suivre l'évolution de la logique métier, suspendre l'exécution et rétablir les opérations en cas de défaillance. Lorsque les fonctions reprennent après une suspension ou une interruption, les points de contrôle précédemment complétés sont rejoués et la fonction poursuit son exécution.

Le cycle de vie peut inclure plusieurs invocations d'une fonction Lambda pour terminer l'exécution, en particulier après des suspensions ou une reprise après défaillance. Cette approche permet à votre fonction de fonctionner pendant de longues périodes (jusqu'à un an) tout en maintenant une progression fiable malgré les interruptions.

Comment fonctionne le replay

Lambda tient un journal de toutes les opérations durables (étapes, attentes et autres opérations) au fur et à mesure de l'exécution de votre fonction. Lorsque votre fonction doit être mise en pause ou rencontre une interruption, Lambda enregistre ce journal de points de contrôle et arrête l'exécution. Au moment de reprendre, Lambda invoque à nouveau votre fonction depuis le début et rejoue le journal des points de contrôle, en substituant des valeurs stockées aux opérations terminées. Cela signifie que votre code s'exécute à nouveau, mais que les étapes précédemment effectuées ne sont pas réexécutées. Leurs résultats enregistrés sont utilisés à la place.

Ce mécanisme de rediffusion est fondamental pour comprendre les fonctions durables. Votre code doit être déterministe lors de la rediffusion, c'est-à-dire qu'il produit les mêmes résultats avec les mêmes entrées. Évitez les opérations comportant des effets secondaires (comme la génération de nombres aléatoires ou l'obtention de l'heure actuelle) en dehors des étapes, car elles peuvent produire des valeurs différentes lors de la rediffusion et entraîner un comportement non déterministe.

DurableContext

DurableContextest l'objet de contexte que reçoit votre fonction durable. Il fournit des méthodes pour des opérations durables, telles que des étapes et des attentes qui créent des points de contrôle et gèrent le flux d'exécution.

Votre fonction durable reçoit un contexte Lambda DurableContext au lieu du contexte par défaut :

TypeScript

import {
  DurableContext,
  withDurableExecution,
} from "@aws/durable-execution-sdk-js";

export const handler = withDurableExecution(
  async (event: any, context: DurableContext) => {
    const result = await context.step(async () => {
      return "step completed";
    });
    return result;
  },
);

Python

from aws_durable_execution_sdk_python import (
    DurableContext,
    durable_execution,
    durable_step,
)

@durable_step
def my_step(step_context, data):
    # Your business logic
    return result

@durable_execution
def handler(event, context: DurableContext):
    result = context.step(my_step(event["data"]))
    return result

Le SDK Python pour les fonctions durables utilise des méthodes synchrones et ne les prend pas en charge. await Le TypeScript SDK utiliseasync/await.

Étapes

Steps exécute une logique métier avec des tentatives intégrées et des points de contrôle automatiques. Chaque étape enregistre son résultat, ce qui garantit que votre fonction peut reprendre à partir de n'importe quelle étape terminée après une interruption.

TypeScript

// Each step is automatically checkpointed
const order = await context.step(async () => processOrder(event));
const payment = await context.step(async () => processPayment(order));
const result = await context.step(async () => completeOrder(payment));

Python

# Each step is automatically checkpointed
order = context.step(lambda: process_order(event))
payment = context.step(lambda: process_payment(order))
result = context.step(lambda: complete_order(payment))

États d'attente

Les états d'attente sont des pauses planifiées pendant lesquelles votre fonction cesse de fonctionner (et de se recharger) jusqu'à ce qu'il soit temps de continuer. Utilisez-les pour attendre des périodes, des rappels externes ou des conditions spécifiques.

TypeScript

// Wait for 1 hour without consuming resources
await context.wait({ seconds:3600 });

// Wait for external callback
const approval = await context.waitForCallback(
  async (callbackId) => sendApprovalRequest(callbackId)
);

Python

# Wait for 1 hour without consuming resources
context.wait(3600)

# Wait for external callback
approval = context.wait_for_callback(
    lambda callback_id: send_approval_request(callback_id)
)

Lorsque votre fonction attend ou doit faire une pause, Lambda enregistre le journal des points de contrôle et arrête l'exécution. Au moment de reprendre, Lambda invoque à nouveau votre fonction et rejoue le journal des points de contrôle, en substituant des valeurs stockées aux opérations terminées.

Pour les flux de travail plus complexes, les fonctions Lambda durables sont également associées à des opérations avancées telles que parallel() l'exécution simultanée, le traitement map() de tableaux, les opérations imbriquées et runInChildContext() les interrogations. waitForCondition() Reportez-vous à la section Exemples pour obtenir des exemples détaillés et des conseils sur le moment d'utiliser chaque opération.

Invocation d'autres fonctions

Invoke permet à une fonction durable d'appeler d'autres fonctions Lambda et d'attendre leurs résultats. La fonction appelante est suspendue pendant que la fonction invoquée s'exécute, créant ainsi un point de contrôle qui préserve le résultat. Cela vous permet de créer des flux de travail modulaires dans lesquels des fonctions spécialisées gèrent des tâches spécifiques.

context.invoke()À utiliser pour appeler d'autres fonctions depuis votre fonction durable. L'invocation est un point de contrôle. Ainsi, si votre fonction est interrompue une fois la fonction invoquée terminée, elle reprend avec le résultat enregistré sans avoir à réinvoquer la fonction.

TypeScript

// Invoke another function and wait for result
const customerData = await context.invoke(
  'validate-customer',
  'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
  { customerId: event.customerId }
);

// Use the result in subsequent steps
const order = await context.step(async () => {
  return processOrder(customerData);
});

Python

# Invoke another function and wait for result
customer_data = context.invoke(
    'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
    {'customerId': event['customerId']},
    name='validate-customer'
)

# Use the result in subsequent steps
order = context.step(
    lambda: process_order(customer_data),
    name='process-order'
)

La fonction invoquée peut être une fonction Lambda durable ou standard. Si vous invoquez une fonction durable, la fonction appelante attend la fin de l'exécution durable complète. Ce modèle est courant dans les architectures de microservices où chaque fonction gère un domaine spécifique, ce qui vous permet de composer des flux de travail complexes à partir de fonctions spécialisées et réutilisables.

Configuration fonctionnelle durable

Les fonctions durables ont des paramètres de configuration spécifiques qui contrôlent le comportement d'exécution et la conservation des données. Ces paramètres sont distincts de la configuration standard de la fonction Lambda et s'appliquent à l'ensemble du cycle de vie d'exécution durable.

L'DurableConfigobjet définit la configuration des fonctions durables :

{
  "ExecutionTimeout": Integer,
  "RetentionPeriodInDays": Integer
}

Execution timeout (Délai d'exécution)

Le délai d'exécution contrôle la durée pendant laquelle une exécution durable peut s'exécuter du début à la fin. Cela est différent du délai d'expiration de la fonction Lambda, qui contrôle la durée pendant laquelle une seule invocation de fonction peut être exécutée.

Une exécution durable peut s'étendre sur plusieurs invocations de fonctions Lambda au fur et à mesure qu'elle progresse entre les points de contrôle, les temps d'attente et les rediffusions. Le délai d'exécution s'applique au temps total écoulé pendant l'exécution durable, et non aux invocations de fonctions individuelles.

Comprendre la différence

Le délai d'expiration de la fonction Lambda (maximum 15 minutes) limite chaque appel individuel de votre fonction. Le délai d'exécution durable (maximum 1 an) limite le temps total entre le début de l'exécution et sa fin, son échec ou son expiration. Au cours de cette période, votre fonction peut être invoquée plusieurs fois pendant qu'elle traite des étapes, attend et se rétablit après un échec.

Par exemple, si vous définissez un délai d'exécution durable de 24 heures et un délai d'expiration de la fonction Lambda de 5 minutes :

Vous pouvez configurer le délai d'exécution lors de la création d'une fonction durable à l'aide de la console Lambda AWS CLI, ou. AWS SAM Dans la console Lambda, choisissez votre fonction, puis Configuration, Exécution durable. Définissez la valeur du délai d'exécution en secondes (par défaut : 86400 secondes/24 heures, minimum : 60 secondes, maximum : 31536000 secondes/1 an).

Période de conservation

La période de conservation contrôle la durée pendant laquelle Lambda conserve l'historique des exécutions et les données des points de contrôle après la fin d'une exécution durable. Ces données incluent les résultats des étapes, l'état d'exécution et le journal complet des points de contrôle.

Une fois la période de conservation expirée, Lambda supprime l'historique d'exécution et les données des points de contrôle. Vous ne pouvez plus récupérer les détails de l'exécution ni rejouer l'exécution. La période de rétention commence lorsque l'exécution atteint un état terminal (SUCCEDED, FAILED, STOPPED ou TIMED_OUT).

Vous pouvez configurer la période de rétention lors de la création d'une fonction durable à l'aide de la console Lambda AWS CLI, ou. AWS SAM Dans la console Lambda, choisissez votre fonction, puis Configuration, Exécution durable. Définissez la valeur de la période de conservation en jours (par défaut : 14 jours, minimum : 1 jour, maximum : 90 jours).

Choisissez une période de rétention en fonction de vos exigences de conformité, de vos besoins de débogage et de considérations financières. Des périodes de rétention plus longues permettent de consacrer plus de temps au débogage et à l'audit, mais augmentent les coûts de stockage.