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.
# Création de fonctions Lambda durables
Pour commencer à utiliser les fonctions durables Lambda, utilisez la console Lambda pour créer une fonction durable. En quelques minutes, vous pouvez créer et déployer une fonction durable qui utilise des étapes et des temps d'attente pour démontrer une exécution basée sur des points de contrôle.
Au cours de ce didacticiel, vous découvrirez les concepts fondamentaux des fonctions durables, tels que la façon d'utiliser l'`DurableContext`objet, de créer des points de contrôle avec des étapes et de suspendre l'exécution avec des temps d'attente. Vous découvrirez également comment fonctionne le replay lorsque votre fonction reprend après une attente.
Pour simplifier les choses, ce didacticiel explique comment créer votre fonction à l'aide de l'environnement d'exécution Python ou Node.js. Avec ces langages interprétés, vous pouvez modifier le code de fonction directement dans l'éditeur de code intégré à la console.
Les fonctions durables de Java (version préliminaire) ne peuvent actuellement être déployées que via des images de conteneur. Pour plus d'informations sur la création de fonctions durables à partir d'images de conteneurs, voir [Runtimes pris en charge pour les fonctions durables](durable-supported-runtimes.md) ou [Déployer des fonctions durables Lambda avec Infrastructure as Code](durable-getting-started-iac.md).
**Note**
Les fonctions durables prennent actuellement en charge les environnements d'exécution Python et Node.js (JavaScript/TypeScript) et les images de conteneur (OCI), telles que Java. Pour obtenir la liste complète des versions d'exécution et des options d'image de conteneur prises en charge, voir [Runtimes pris en charge pour des fonctions durables.](durable-supported-runtimes.md) Pour plus d'informations sur l'utilisation d'images de conteneur avec Lambda, consultez la section Création d'images de [conteneur Lambda dans le guide du développeur](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) Lambda.
**Astuce**
Pour apprendre à créer des **solutions sans serveur**, consultez le [Guide du développeur sans serveur](https://docs.aws.amazon.com/serverless/latest/devguide/).
## Conditions préalables
### Inscrivez-vous pour un Compte AWS
Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.
**Pour vous inscrire à un Compte AWS**
1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)
1. Suivez les instructions en ligne.
Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.
Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.
### Création d’un utilisateur doté d’un accès administratif
Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.
**Sécurisez votre Utilisateur racine d'un compte AWS**
1. Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.
Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.
1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.
Pour obtenir des instructions, voir [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.
**Création d’un utilisateur doté d’un accès administratif**
1. Activez IAM Identity Center.
Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.
Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.
**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.
Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.
**Attribution d’un accès à d’autres utilisateurs**
1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.
Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.
Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
## Créez une fonction Lambda durable avec la console
Dans cet exemple, votre fonction durable traite une commande en plusieurs étapes avec un point de contrôle automatique. La fonction prend un objet JSON contenant un numéro de commande, valide la commande, traite le paiement et confirme la commande. Chaque étape est automatiquement contrôlée. Ainsi, si la fonction est interrompue, elle reprend à partir de la dernière étape terminée.
Votre fonction illustre également une opération d'attente, interrompant l'exécution pendant une courte période pour simuler l'attente d'une confirmation externe.
**Pour créer une fonction durable avec la console**
1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.
1. Choisissez **Créer une fonction**.
1. Sélectionnez **Créer à partir de zéro**.
1. Dans le volet **Informations de base**, pour **Nom de la fonction**, saisissez `myDurableFunction`.
1. Pour **Runtime**, choisissez **Node.js 24** ou **Python 3.14**.
1. Sélectionnez **Activer l'exécution durable**.
Lambda crée votre fonction durable avec un [rôle d'exécution](lambda-intro-execution-role.md) qui inclut des autorisations pour les opérations de point de contrôle (`lambda:CheckpointDurableExecutions`et). `lambda:GetDurableExecutionState`
**Note**
Les environnements d'exécution Lambda incluent le SDK Durable Execution, qui vous permet de tester des fonctions durables sans créer de dépendances. Toutefois, nous vous recommandons d'inclure le SDK dans votre package de déploiement pour la production. Cela garantit la cohérence des versions et évite les mises à jour d'exécution potentielles susceptibles d'affecter votre fonction.
Utilisez l'éditeur de code intégré à la console pour ajouter votre code de fonction durable.
------
#### [ Node.js ]
**Pour modifier le code dans la console**
1. Cliquez sur l’onglet **Code**.
Dans l'éditeur de code intégré de la console, vous devriez voir le code de fonction créé par Lambda. Si vous ne voyez pas l'onglet **index.mjs** dans l'éditeur de code, sélectionnez **index.mjs** dans l'explorateur de fichiers, comme le montre le schéma suivant.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/durable-nodejs.png)
1. Collez le code suivant dans l'onglet **index.mjs**, en remplaçant le code créé par Lambda.
```
import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event, context) => {
const orderId = event.orderId;
// Step 1: Validate order
const validationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Validating order ${orderId}`);
return { orderId, status: "validated" };
});
// Step 2: Process payment
const paymentResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Processing payment for order ${orderId}`);
return { orderId, status: "paid", amount: 99.99 };
});
// Wait for 10 seconds to simulate external confirmation
await context.wait({ seconds: 10 });
// Step 3: Confirm order
const confirmationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Confirming order ${orderId}`);
return { orderId, status: "confirmed" };
});
return {
orderId: orderId,
status: "completed",
steps: [validationResult, paymentResult, confirmationResult]
};
}
);
```
1. Dans la section **DÉPLOYER**, choisissez **Déployer** pour mettre à jour le code de votre fonction :
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Comprendre votre code de fonction durable**
Avant de passer à l'étape suivante, examinons le code de la fonction et comprenons les principaux concepts relatifs aux fonctions durables.
+ L'`withDurableExecution`emballage :
Votre fonction durable est emballée avec`withDurableExecution`. Ce wrapper permet une exécution durable en fournissant l'`DurableContext`objet et en gérant les opérations des points de contrôle.
+ L'`DurableContext`objet :
Au lieu du contexte Lambda standard, votre fonction reçoit un. `DurableContext` Cet objet fournit des méthodes pour des opérations durables telles `wait()` que `step()` et qui créent des points de contrôle.
+ Étapes et points de contrôle :
Chaque `context.step()` appel crée un point de contrôle avant et après l'exécution. Si votre fonction est interrompue, elle reprend à partir du dernier point de contrôle terminé. La fonction ne réexécute pas les étapes terminées. Il utilise plutôt leurs résultats enregistrés.
+ Opérations d'attente :
L'`context.wait()`appel interrompt l'exécution sans consommer de ressources informatiques. Une fois l'attente terminée, Lambda appelle à nouveau votre fonction et rejoue le journal des points de contrôle, en substituant des valeurs stockées aux étapes terminées.
+ Mécanisme de rediffusion :
Lorsque votre fonction reprend après une attente ou une interruption, Lambda exécute votre code depuis le début. Toutefois, les étapes terminées ne sont pas réexécutées. Lambda rejoue leurs résultats à partir du journal des points de contrôle. C'est pourquoi votre code doit être déterministe.
------
#### [ Python ]
**Pour modifier le code dans la console**
1. Cliquez sur l’onglet **Code**.
Dans l'éditeur de code intégré de la console, vous devriez voir le code de fonction créé par Lambda. Si vous ne voyez pas l'onglet **lambda\$1function.py** dans l'éditeur de code, sélectionnez **lambda\$1function.py** dans l'explorateur de fichiers, comme le montre le schéma suivant.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/durable-python.png)
1. Collez le code suivant dans l'onglet **lambda\$1function.py**, en remplaçant le code créé par Lambda.
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
from aws_durable_execution_sdk_python.config import Duration
@durable_step
def validate_order(step_context, order_id):
step_context.logger.info(f"Validating order {order_id}")
return {"orderId": order_id, "status": "validated"}
@durable_step
def process_payment(step_context, order_id):
step_context.logger.info(f"Processing payment for order {order_id}")
return {"orderId": order_id, "status": "paid", "amount": 99.99}
@durable_step
def confirm_order(step_context, order_id):
step_context.logger.info(f"Confirming order {order_id}")
return {"orderId": order_id, "status": "confirmed"}
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
# Step 1: Validate order
validation_result = context.step(validate_order(order_id))
# Step 2: Process payment
payment_result = context.step(process_payment(order_id))
# Wait for 10 seconds to simulate external confirmation
context.wait(Duration.from_seconds(10))
# Step 3: Confirm order
confirmation_result = context.step(confirm_order(order_id))
return {
"orderId": order_id,
"status": "completed",
"steps": [validation_result, payment_result, confirmation_result]
}
```
1. Dans la section **DÉPLOYER**, choisissez **Déployer** pour mettre à jour le code de votre fonction :
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Comprendre votre code de fonction durable**
Avant de passer à l'étape suivante, examinons le code de la fonction et comprenons les principaux concepts relatifs aux fonctions durables.
+ Le `@durable_execution` décorateur :
Votre fonction de gestion est décorée avec`@durable_execution`. Ce décorateur permet une exécution durable en fournissant l'`DurableContext`objet et en gérant les opérations aux points de contrôle.
+ Le `@durable_step` décorateur :
Chaque fonction de marche est décorée avec`@durable_step`. Ce décorateur définit la fonction comme une étape durable qui crée des points de contrôle.
+ L'`DurableContext`objet :
Au lieu du contexte Lambda standard, votre fonction reçoit un. `DurableContext` Cet objet fournit des méthodes pour des opérations durables telles `wait()` que `step()` et qui créent des points de contrôle.
+ Étapes et points de contrôle :
Chaque `context.step()` appel crée un point de contrôle avant et après l'exécution. Si votre fonction est interrompue, elle reprend à partir du dernier point de contrôle terminé. La fonction ne réexécute pas les étapes terminées. Il utilise plutôt leurs résultats enregistrés.
+ Opérations d'attente :
L'`context.wait()`appel interrompt l'exécution sans consommer de ressources informatiques. Une fois l'attente terminée, Lambda appelle à nouveau votre fonction et rejoue le journal des points de contrôle, en substituant des valeurs stockées aux étapes terminées.
+ Le SDK Python est synchrone :
Notez que le SDK Python n'utilise `await` pas. Toutes les opérations durables sont des appels de méthode synchrones.
------
## Appelez la fonction durable à l'aide de l'éditeur de code de la console
Lorsqu'aucune version explicite n'est spécifiée (ou publiée), la console invoque la fonction durable à l'aide du qualificatif de `$LATEST` version. Toutefois, pour une exécution déterministe de votre code, vous devez toujours utiliser un ARN qualifié pointant vers une version stable.
**Pour publier une version de votre fonction**
1. Choisissez l'onglet **Versions**.
1. Choisissez **Publish new version (Publier une nouvelle version)**.
1. Dans le **champ Description de la version**, entrez **Initial version** (facultatif).
1. Choisissez **Publier**.
1. Lambda crée la version 1 de votre fonction. Notez que la fonction ARN inclut désormais `:1` à la fin, ce qui indique qu'il s'agit de la version 1.
Créez maintenant un événement de test à envoyer à votre fonction. L'événement est un document au format JSON contenant un numéro de commande.
**Pour créer l'événement de test**
1. Dans la section **ÉVÉNEMENTS DE TEST** de l’éditeur de code de console, choisissez **Créer un événement de test**.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
1. Dans **Event Name (Nom de l'événement)**, saisissez **myTestEvent**.
1. Dans la section **JSON d’événement**, remplacez le JSON par défaut par ce qui suit :
```
{
"orderId": "order-12345"
}
```
1. Choisissez **Enregistrer**.
**Pour tester votre fonctionnalité durable et voir son exécution**
Dans la section **ÉVÉNEMENTS DE TEST** de l’éditeur de code de la console, cliquez sur l’icône d’exécution à côté de votre événement de test :
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
Votre fonction durable commence à s'exécuter. Comme il inclut une attente de 10 secondes, l'appel initial se termine rapidement et la fonction reprend après la période d'attente. Vous pouvez consulter la progression de l'exécution dans l'onglet **Exécutions durables**.
**Pour visualiser l'exécution durable de vos fonctions**
1. Choisissez l'onglet **Exécutions durables**.
1. Trouvez votre exécution dans la liste. L'exécution indique l'état actuel (en cours, réussi ou échec).
1. Choisissez l'ID d'exécution pour afficher les détails, notamment :
+ Chronologie d'exécution indiquant la fin de chaque étape
+ Historique des points de contrôle
+ Périodes d'attente
+ Résultats des étapes
Vous pouvez également consulter les journaux de votre fonction dans CloudWatch Logs pour voir le résultat de chaque étape de la console.
**Pour consulter les enregistrements d'invocation de votre fonction dans Logs CloudWatch**
1. Ouvrez la page [Groupes de journaux](https://console.aws.amazon.com/cloudwatch/home#logs:) de la CloudWatch console.
1. Choisissez le groupe de journaux de votre fonction (`/aws/lambda/myDurableFunction`).
1. Faites défiler la page vers le bas et choisissez le **flux de journaux** pour les invocations de fonctions que vous souhaitez consulter.
![\[\]](http://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/log-stream.png)
Vous devriez voir des entrées de journal pour chaque appel de votre fonction, y compris l'exécution initiale et la rediffusion après l'attente.
**Note**
Lorsque vous utilisez l'enregistreur depuis `DurableContext` (tel que `context.logger` ou`stepContext.logger`), les journaux apparaissent également dans les vues d'exécution durable et d'étape de la console Lambda. Le chargement de ces journaux peut prendre un certain temps.
## Nettoyage
Lorsque vous avez fini d'utiliser l'exemple de fonction durable, supprimez-le. Vous pouvez également supprimer le groupe de journaux qui stocke les journaux de la fonction, et le [rôle d'exécution](lambda-intro-execution-role.md) créé par la console.
**Pour supprimer la fonction Lambda**
1. Ouvrez la [page Functions (Fonctions)](https://console.aws.amazon.com/lambda/home#/functions) de la console Lambda.
1. Sélectionnez la fonction que vous avez créée.
1. Sélectionnez **Actions**, **Supprimer**.
1. Saisissez **confirm** dans la zone de saisie de texte et choisissez **Delete** (Supprimer).
**Pour supprimer le groupe de journaux**
1. Ouvrez la [page Log groups (Groupes de journaux)](https://console.aws.amazon.com/cloudwatch/home#logs:) de la console CloudWatch.
1. Sélectionnez le groupe de journaux de la fonction (`/aws/lambda/myDurableFunction`).
1. Sélectionnez **Actions**, **Delete log group(s) (Supprimer le ou les groupes de journaux)**.
1. Dans la boîte de dialogue **Delete log group(s) (Supprimer le ou les groupes de journaux)**, sélectionnez **Delete (Supprimer)**.
**Pour supprimer le rôle d'exécution**
1. Ouvrez la [page Rôles](https://console.aws.amazon.com/iam/home?#/roles) de la console Gestion des identités et des accès AWS (IAM).
1. Sélectionnez le rôle d'exécution de la fonction (par exemple, `myDurableFunction-role-31exxmpl`).
1. Sélectionnez **Delete (Supprimer)**.
1. Dans la fenêtre de dialogue **Supprimer le rôle**, saisissez le nom du rôle, puis sélectionnez **Supprimer**.
## Ressources supplémentaires et prochaines étapes
Maintenant que vous avez créé et testé une fonction simple et durable à l'aide de la console, procédez comme suit :
+ Découvrez les cas d'utilisation courants des fonctions durables, notamment les transactions distribuées, le traitement des commandes et les flux de travail de révision humaine. Voir les [exemples](durable-examples.md).
+ Découvrez comment surveiller les exécutions de fonctions durables à l'aide de CloudWatch métriques et d'un historique d'exécution. Consultez [la section Surveillance et débogage](durable-monitoring.md).
+ Découvrez comment invoquer des fonctions durables de manière synchrone et asynchrone, et comment gérer les exécutions de longue durée. Voir [Invocation de fonctions durables.](durable-invoking.md)
+ Suivez les meilleures pratiques en matière de rédaction de code déterministe, de gestion de la taille des points de contrôle et d'optimisation des coûts. Consultez la section [Bonnes pratiques](durable-best-practices.md).
+ Découvrez comment tester des fonctions durables localement et dans le cloud. Voir [Tester des fonctions durables](durable-testing.md).
+ Comparez les fonctions durables aux Step Functions pour savoir quand chaque approche est la plus efficace. Voir [Durable functions ou Step Functions](durable-step-functions.md).
# Déployez et invoquez des fonctions durables Lambda avec AWS CLI
Utilisez le AWS CLI pour créer et déployer des fonctions Lambda durables avec des commandes impératives. Cette approche vous permet de contrôler directement chaque étape du processus de déploiement.
## Conditions préalables
+ Installez et configurez l’ AWS CLI. Pour obtenir des instructions, reportez-vous à la section [Installation du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Créez un package de déploiement avec votre code de fonction et le SDK d'exécution durable.
+ Créez un rôle d'exécution IAM avec des autorisations de point de contrôle.
## Créer le rôle d’exécution
Créez un rôle IAM avec des autorisations pour l'exécution Lambda de base et les opérations de point de contrôle.
**Pour créer le rôle d'exécution**
1. Créez un document de politique de confiance qui permet à Lambda d'assumer le rôle. Enregistrez ceci sous le nom `trust-policy.json` :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Créez le rôle :
```
aws iam create-role \
--role-name durable-function-role \
--assume-role-policy-document file://trust-policy.json
```
1. Joignez la politique d'exécution durable pour les opérations de point de contrôle et l'exécution de base :
```
aws iam attach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
```
La politique `AWSLambdaBasicDurableExecutionRolePolicy` gérée inclut les autorisations requises pour les opérations de point de contrôle (`lambda:CheckpointDurableExecutions`et`lambda:GetDurableExecutionState`) et l'exécution de base de Lambda.
## Créez une fonction durable
Créez votre fonction durable avec le `--durable-config` paramètre.
**Pour créer une fonction durable**
1. Package de votre code de fonction avec les dépendances dans un fichier .zip :
```
zip -r function.zip index.mjs node_modules/
```
1. Créez la fonction avec l'exécution durable activée :
```
aws lambda create-function \
--function-name myDurableFunction \
--runtime nodejs22.x \
--role arn:aws:iam::123456789012:role/durable-function-role \
--handler index.handler \
--zip-file fileb://function.zip \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
**Note**
Vous ne pouvez activer l'exécution durable que lors de la création de la fonction. Vous ne pouvez pas l'activer sur les fonctions existantes.
**Note**
Actuellement, les fonctions durables en Java (Preview) ne peuvent actuellement être créées que via des images de conteneur. Pour plus d'informations sur la création de fonctions durables à partir d'images de conteneurs, voir [Runtimes pris en charge pour les fonctions durables.](durable-supported-runtimes.md)
## Publier une version
Bien que les fonctions durables puissent être invoquées à l'aide du qualificatif de `$LATEST` version, vous devez toujours utiliser un ARN qualifié pointant vers une version stable pour garantir une exécution déterministe de votre code.
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Initial version"
```
La commande renvoie l'ARN de la version. Notez le numéro de version (par exemple,`:1`) à la fin de l'ARN.
Vous pouvez éventuellement créer un alias pointant vers la version :
```
aws lambda create-alias \
--function-name myDurableFunction \
--name prod \
--function-version 1
```
## Invoquez la fonction durable
Appelez votre fonction durable à l'aide de l'ARN qualifié (version ou alias).
**Note**
**Invocations idempotentes :** pour éviter les doubles exécutions lors de nouvelles tentatives d'invocation infructueuses, vous pouvez fournir un nom d'exécution garantissant la sémantique d'exécution. at-most-once Voir [Idempotency](durable-execution-idempotency.md) pour plus de détails.
**Invocation synchrone**
Pour les exécutions qui se terminent en 15 minutes, utilisez l'invocation synchrone :
```
aws lambda invoke \
--function-name myDurableFunction:1 \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
Ou en utilisant un alias :
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
**invocation asynchrone**
Pour les exécutions de longue durée, utilisez l'invocation asynchrone :
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--invocation-type Event \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
En cas d'invocation asynchrone, Lambda revient immédiatement. La fonction continue de s'exécuter en arrière-plan.
**Note**
Vous pouvez l'utiliser `$LATEST` pour le prototypage et les tests dans la console. Pour les charges de travail de production, utilisez une version publiée ou un alias.
## Gérez des exécutions durables
Utilisez les commandes suivantes pour gérer et surveiller les exécutions de fonctions durables.
**Lister les exécutions**
Répertoriez toutes les exécutions d'une fonction durable :
```
aws lambda list-durable-executions-by-function \
--function-name myDurableFunction
```
**Obtenir les détails de l'exécution**
Obtenez des informations sur une exécution spécifique :
```
aws lambda get-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**Obtenir l'historique des exécutions**
Consultez l'historique des points de contrôle d'une exécution :
```
aws lambda get-durable-execution-history \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**Arrêter une exécution**
Arrêtez une exécution durable en cours :
```
aws lambda stop-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
## Mettre à jour le code de la fonction
Mettez à jour votre code de fonction durable et publiez une nouvelle version :
**Pour mettre à jour et publier une nouvelle version**
1. Mettez à jour le code de fonction :
```
aws lambda update-function-code \
--function-name myDurableFunction \
--zip-file fileb://function.zip
```
1. Attendez que la mise à jour soit terminée :
```
aws lambda wait function-updated \
--function-name myDurableFunction
```
1. Publiez une nouvelle version :
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Updated order processing logic"
```
1. Mettez à jour l'alias pour qu'il pointe vers la nouvelle version :
```
aws lambda update-alias \
--function-name myDurableFunction \
--name prod \
--function-version 2
```
**Important**
Les exécutions en cours continuent à utiliser la version avec laquelle elles ont débuté. Les nouvelles invocations utilisent la version mise à jour de l'alias.
## Affichage des journaux de fonctions
Consultez les journaux de votre fonction durable dans CloudWatch Logs :
```
aws logs tail /aws/lambda/myDurableFunction --follow
```
Filtrez les journaux pour une exécution spécifique :
```
aws logs filter-log-events \
--log-group-name /aws/lambda/myDurableFunction \
--filter-pattern "exec-abc123"
```
## nettoyer des ressources ;
Supprimez votre fonction durable et les ressources associées :
```
# Delete the function
aws lambda delete-function --function-name myDurableFunction
# Delete the IAM role policies
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
# Delete the role
aws iam delete-role --role-name durable-function-role
```
## Étapes suivantes
Après avoir déployé votre fonction durable avec AWS CLI :
+ Surveillez les exécutions à l'aide `list-durable-executions` des `get-durable-execution` commandes et
+ Afficher les opérations des points de contrôle dans les événements de AWS CloudTrail données
+ Configurez des CloudWatch alarmes en cas d'échec d'exécution ou d'exécutions de longue durée
+ Automatisez les déploiements à l'aide de scripts shell ou CI/CD de pipelines
Pour plus d'informations sur AWS CLI les commandes pour Lambda, consultez la référence des [AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html).
# Déployez des fonctions durables Lambda avec l'infrastructure en tant que code
Vous pouvez déployer des fonctions durables Lambda à l'aide d'outils d'infrastructure en tant que code (IaC) tels que AWS CloudFormation, AWS CDK AWS Serverless Application Model, ou Terraform. Ces outils vous permettent de définir votre fonction, votre rôle d'exécution et vos autorisations dans le code, ce qui rend les déploiements reproductibles et contrôlés par version.
Les trois outils vous obligent à :
+ Permettre une exécution durable de la fonction
+ Accorder des autorisations de point de contrôle au rôle d'exécution
+ Publier une version ou créer un alias (les fonctions durables nécessitent une qualification ARNs)
## Fonctionnalités durables grâce à une fermeture éclair
### AWS CloudFormation
CloudFormation À utiliser pour définir votre fonction durable dans un modèle. L'exemple suivant crée une fonction durable dotée des autorisations requises.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda durable function example
Resources:
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
DurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
Role: !GetAtt DurableFunctionRole.Arn
Code:
ZipFile: |
// Your durable function code here
export const handler = async (event, context) => {
return { statusCode: 200 };
};
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
DurableFunctionVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref DurableFunction
Description: Initial version
DurableFunctionAlias:
Type: AWS::Lambda::Alias
Properties:
FunctionName: !Ref DurableFunction
FunctionVersion: !GetAtt DurableFunctionVersion.Version
Name: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunctionAlias
```
**Pour déployer le modèle**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK vous permet de définir l'infrastructure à l'aide de langages de programmation. Les exemples suivants montrent comment créer une fonction durable à l'aide TypeScript de Python.
------
#### [ TypeScript ]
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.Function(this, 'DurableFunction', {
runtime: lambda.Runtime.NODEJS_22_X,
handler: 'index.handler',
code: lambda.Code.fromAsset('lambda'),
functionName: 'myDurableFunction',
durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
------
#### [ Python ]
```
from aws_cdk import (
Stack,
aws_lambda as lambda_,
aws_iam as iam,
CfnOutput,
)
from constructs import Construct
class DurableFunctionStack(Stack):
def __init__(self, scope: Construct, id: str, **kwargs):
super().__init__(scope, id, **kwargs)
# Create the durable function
durable_function = lambda_.Function(
self, 'DurableFunction',
runtime=lambda_.Runtime.NODEJS_22_X,
handler='index.handler',
code=lambda_.Code.from_asset('lambda'),
function_name='myDurableFunction',
durable_execution={execution_timeout: Duration.hours(1), retention_period: Duration.days(30)}
)
# Add durable execution managed policy for checkpoint permissions
durable_function.role.add_managed_policy(
iam.ManagedPolicy.from_aws_managed_policy_name('service-role/AWSLambdaBasicDurableExecutionRolePolicy')
)
# Create version and alias
version = durable_function.current_version
alias = lambda_.Alias(
self, 'ProdAlias',
alias_name='prod',
version=version
)
# Output the alias ARN
CfnOutput(
self, 'FunctionAliasArn',
value=alias.function_arn,
description='Use this ARN to invoke the durable function'
)
```
------
**Pour déployer la pile CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM simplifie les CloudFormation modèles pour les applications sans serveur. Le modèle suivant crée une fonction durable avec AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
CodeUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Pour déployer le modèle SAM**
```
sam build
sam deploy --guided
```
### Terraform
Terraform est un outil IaC open source populaire qui prend en charge les ressources. AWS L'exemple suivant crée une fonction durable avec Terraform à l'aide du AWS fournisseur version 6.25.0 ou ultérieure.
```
terraform {
required_version = ">= 1.0"
required_providers {
aws = {
source = "hashicorp/aws"
version = ">= 6.25.0"
}
}
}
provider "aws" {
region = "us-east-2"
}
# IAM Role for Lambda Function
resource "aws_iam_role" "lambda_role" {
name = "durable-function-role"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Action = "sts:AssumeRole"
Effect = "Allow"
Principal = {
Service = "lambda.amazonaws.com"
}
}]
})
}
# Attach durable execution policy for checkpoint operations
resource "aws_iam_role_policy_attachment" "lambda_durable" {
policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy"
role = aws_iam_role.lambda_role.name
}
# Lambda Function with Durable Execution enabled
resource "aws_lambda_function" "durable_function" {
filename = "function.zip"
function_name = "myDurableFunction"
role = aws_iam_role.lambda_role.arn
handler = "index.handler"
runtime = "nodejs22.x"
timeout = 30
memory_size = 512
durable_config {
execution_timeout = 900
retention_period = 7
}
}
# Publish a version
resource "aws_lambda_alias" "prod" {
name = "prod"
function_name = aws_lambda_function.durable_function.function_name
function_version = aws_lambda_function.durable_function.version
}
output "function_arn" {
description = "ARN of the Lambda function"
value = aws_lambda_function.durable_function.arn
}
output "alias_arn" {
description = "ARN of the function alias (use this for invocations)"
value = aws_lambda_alias.prod.arn
}
```
**Pour déployer avec Terraform**
```
terraform init
terraform plan
terraform apply
```
**Note**
La prise en charge par Terraform des fonctions durables Lambda nécessite la version 6.25.0 ou ultérieure du AWS fournisseur. Mettez à jour la version de votre fournisseur si vous utilisez une ancienne version.
## Fonctions durables à partir d'une image de conteneur OCI
Vous pouvez également créer des fonctions durables à partir d'images de conteneurs. Pour obtenir des instructions sur la création d'une image de conteneur, voir [Runtimes pris en charge pour des fonctions durables.](durable-supported-runtimes.md)
### AWS CDK
AWS CDK vous permet de définir l'infrastructure à l'aide de langages de programmation. Les exemples suivants montrent comment créer une fonction durable à TypeScript partir d'une image de conteneur.
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.DockerImageFunction(this, 'DurableFunction', {
code: lambda.DockerImageCode.fromImageAsset('./lambda', {
platform: cdk.aws_ecr_assets.Platform.LINUX_AMD64,
}),
functionName: 'myDurableFunction',
memorySize: 512,
timeout: cdk.Duration.seconds(30),
durableConfig: { executionTimeout: cdk.Duration.hours(1), retentionPeriod: cdk.Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
**Pour déployer la pile CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM simplifie les CloudFormation modèles pour les applications sans serveur. Le modèle suivant crée une fonction durable avec AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
PackageType: Image
ImageUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Metadata:
DockerTag: latest
DockerContext: ./src
Dockerfile: Dockerfile
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Pour déployer le modèle SAM**
```
sam build
sam deploy --guided
```
## Modèles de configuration courants
Quel que soit l'outil IaC que vous utilisez, suivez les modèles suivants pour des fonctions durables :
**Permettre une exécution durable**
Définissez la `DurableConfig` propriété de votre fonction pour permettre une exécution durable. Cette propriété n'est disponible que lors de la création de la fonction. Vous ne pouvez pas activer l'exécution durable sur des fonctions existantes.
**Accorder des autorisations aux points de contrôle**
Associez la politique `AWSLambdaBasicDurableExecutionRolePolicy` gérée au rôle d'exécution. Cette politique inclut les `lambda:GetDurableExecutionState` autorisations `lambda:CheckpointDurableExecutions` et les autorisations requises.
**Utiliser qualifié ARNs**
Créez une version ou un alias pour votre fonction. Les fonctions durables nécessitent une qualification ARNs (avec version ou alias) pour être invoquées. Utilisez `AutoPublishAlias` AWS SAM ou créez des versions explicites dans CloudFormation AWS CDK, et Terraform.
**Dépendances de package**
Incluez le SDK d'exécution durable dans votre package de déploiement. Pour Node.js, installez`@aws/durable-execution-sdk-js`. Pour Python, installez`aws-durable-execution-sdk-python`.
## Étapes suivantes
Après avoir déployé votre fonction durable :
+ Testez votre fonction à l'aide de l'ARN qualifié (version ou alias)
+ Surveillez la progression de l'exécution dans la console Lambda sous l'onglet Exécutions durables
+ Afficher les opérations des points de contrôle dans les événements de AWS CloudTrail données
+ Consultez CloudWatch les journaux pour connaître le comportement des fonctions, des sorties et des rediffusions
Pour plus d'informations sur le déploiement de fonctions Lambda avec les outils IaC, voir :
+ [CloudFormation AWS::Lambda::Function référence](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Documentation du module Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Manuel du développeur](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)