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. # Utiliser une fonction Lambda pour poursuivre une nouvelle exécution dans Step Functions **Astuce** L'approche suivante utilise une fonction Lambda pour démarrer une nouvelle exécution de flux de travail. Nous **vous recommandons** d'utiliser un état de tâche Step Functions pour démarrer de nouvelles exécutions de flux de travail. Découvrez comment dans le didacticiel suivant : **[Poursuivre les flux de travail de longue durée à l'aide de l'API Step Functions (recommandé)](tutorial-continue-new.md)**. Vous pouvez créer une machine à états qui utilise une fonction Lambda pour démarrer une nouvelle exécution avant la fin de l'exécution en cours. Grâce à cette approche permettant de poursuivre le travail en cours dans le cadre d'une nouvelle exécution, vous pouvez diviser des tâches volumineuses en flux de travail plus petits ou exécuter un flux de travail indéfiniment. Ce didacticiel repose sur le concept d'utilisation d'une fonction Lambda externe pour modifier votre flux de travail, qui a été démontré dans le [Itérer une boucle avec une fonction Lambda dans Step Functions](tutorial-create-iterate-pattern-section.md) didacticiel. Vous utilisez la même fonction Lambda (`Iterator`) pour itérer une boucle un certain nombre de fois. En outre, vous créez une autre fonction Lambda pour démarrer une nouvelle exécution de votre flux de travail et pour décrémenter un nombre à chaque fois qu'il commence une nouvelle exécution. En définissant le nombre d'exécutions dans l'entrée, cette machine d'état termine et redémarre une exécution un nombre de fois spécifié. La machine d'état que vous allez créer implémente les états suivants. | State | Objectif | | --- | --- | | `ConfigureCount` | `Pass`État qui configure les `step` valeurs `count``index`, et utilisées par la fonction `Iterator` Lambda pour effectuer des itérations de travail. | | `Iterator` | `Task`État qui fait référence à la fonction `Iterator` Lambda. | | `IsCountReached` | ChoiceÉtat qui utilise une valeur booléenne issue de la Iterator fonction pour décider si la machine à états doit continuer le travail d'exemple ou passer à l'ShouldRestartétat. | | `ExampleWork` | PassÉtat qui représente l'Taskétat qui exécuterait le travail dans une implémentation réelle. | | `ShouldRestart` | ChoiceÉtat qui utilise la executionCount valeur pour décider s'il doit mettre fin à une exécution et en démarrer une autre, ou simplement se terminer. | | `Restart` | TaskÉtat qui utilise une fonction Lambda pour démarrer une nouvelle exécution de votre machine à états. Comme la fonction Iterator, cette fonction décrémente également un nombre. L'Restartétat transmet la valeur décrémentée du décompte à l'entrée de la nouvelle exécution. | ## Conditions préalables Avant de commencer, suivez le [Création d'une machine d'état Step Functions utilisant Lambda](tutorial-creating-lambda-state-machine.md) didacticiel pour vous assurer que vous êtes familiarisé avec l'utilisation conjointe de Lambda et de Step Functions. ## Étape 1 : créer une fonction Lambda pour itérer un décompte **Note** Si vous avez terminé le [Itérer une boucle avec une fonction Lambda dans Step Functions](tutorial-create-iterate-pattern-section.md) didacticiel, vous pouvez ignorer cette étape et utiliser cette fonction Lambda. Cette section et le [Itérer une boucle avec une fonction Lambda dans Step Functions](tutorial-create-iterate-pattern-section.md) didacticiel montrent comment utiliser une fonction Lambda pour suivre un décompte, par exemple le nombre d'itérations d'une boucle dans votre machine à états. La fonction Lambda suivante reçoit les valeurs d'entrée pour `count``index`, et. `step` Elle renvoie ces valeurs avec un `index` mis à jour et une valeur booléenne nommée `continue`. La fonction Lambda est définie `continue` sur `true` si le `index` est inférieur à. `count` Votre machine d'état implémente alors un état `Choice` qui exécute une certaine logique d'application si `continue` a la valeur `true`, ou de déplace à `ShouldRestart` si `continue` a la valeur `false`. ### Créez la fonction Iterate Lambda 1. Ouvrez la [console Lambda](https://console.aws.amazon.com/lambda/home), puis choisissez **Create function (Créer une fonction**. 1. Sur la page **Create function**, sélectionnez **Author from scratch**. 1. Dans la section **Informations de base**, configurez votre fonction Lambda comme suit : 1. Sous **Nom de la fonction**, saisissez `Iterator`. 1. Pour **Exécution**, choisissez **Node.js 16.x**. 1. Conservez toutes les sélections par défaut sur la page, puis choisissez **Créer une fonction**. Lorsque votre fonction Lambda est créée, notez son Amazon Resource Name (ARN) dans le coin supérieur droit de la page, par exemple : ``` arn:aws:lambda:region:123456789012:function:Iterator ``` 1. Copiez le code suivant pour la fonction Lambda dans la section **Source du code** de la ***Iterator***page de la console Lambda. ``` exports.handler = function iterator (event, context, callback) { let index = event.iterator.index; let step = event.iterator.step; let count = event.iterator.count; index = index + step; callback(null, { index, step, count, continue: index < count }) } ``` Le code accepte les valeurs d'entrée pour `count`, `index` et `step`. Il incrémente `index` de la valeur de `step` et retourne ces valeurs, et la valeur booléenne `continue`. La valeur de `continue` est `true` si `index` est inférieur à `count`. 1. Choisissez **Deploy** pour déployer le code. ### Tester la fonction Iterate Lambda Pour vérifier le fonctionnement de votre fonction `Iterate`, exécutez-la avec des valeurs numériques. Vous pouvez fournir des valeurs d'entrée pour votre fonction Lambda qui imitent une itération pour voir quelle sortie vous obtenez avec des valeurs d'entrée spécifiques. #### Pour tester votre fonction Lambda 1. Dans la boîte de dialogue **Configure test event**, choisissez **Create new test event**, puis entrez `TestIterator` pour **Event name**. 1. Remplacez les données de l'exemple par les suivantes. ``` { "Comment": "Test my Iterator function", "iterator": { "count": 10, "index": 5, "step": 1 } } ``` Ces valeurs simulent ce qui provient de votre machine d'état au cours d'une itération. La fonction Lambda incrémente l'index et renvoie sous la forme. `continue` `true` Quand l'index n'est pas inférieur à `count`, la fonction renvoie `continue` avec la valeur `false`. Pour ce test, l'index a déjà été incrémenté à `5`. Les résultats doivent incrémenter `index` à `6` et définir `continue` avec la valeur `true`. 1. Choisissez **Créer**. 1. **Sur la ***Iterator*** page de votre console Lambda, assurez-vous que cela **TestIterator**figure dans la liste, puis choisissez Test.** Les résultats du test sont affichés en haut de la page. Choisissez **Details** et vérifiez le résultat. ``` { "index": 6, "step": 1, "count": 10, "continue": true } ``` **Note** Si vous définissez `index` avec la valeur `9` pour ce test, `index` s'incrémente à `10` et `continue` a la valeur `false`. ## Étape 2 : Création d'une fonction Restart Lambda pour démarrer une nouvelle exécution de Step Functions 1. Ouvrez la [console Lambda](https://console.aws.amazon.com/lambda/home), puis choisissez **Create function (Créer une fonction**. 1. Sur la page **Create function**, sélectionnez **Author from scratch**. 1. Dans la section **Informations de base**, configurez votre fonction Lambda comme suit : 1. Sous **Nom de la fonction**, saisissez `Restart`. 1. Pour **Exécution**, choisissez **Node.js 16.x**. 1. Conservez toutes les sélections par défaut sur la page, puis choisissez **Créer une fonction**. Lorsque votre fonction Lambda est créée, notez son Amazon Resource Name (ARN) dans le coin supérieur droit de la page, par exemple : ``` arn:aws:lambda:region:123456789012:function:Iterator ``` 1. Copiez le code suivant pour la fonction Lambda dans la section **Source du code** de la ***Restart***page de la console Lambda. Le code suivant décrémente le compte du nombre d'exécutions et démarre une nouvelle exécution de votre machine d'état, valeur décrémentée incluse. ``` var aws = require('aws-sdk'); var sfn = new aws.StepFunctions(); exports.restart = function(event, context, callback) { let StateMachineArn = event.restart.StateMachineArn; event.restart.executionCount -= 1; event = JSON.stringify(event); let params = { input: event, stateMachineArn: StateMachineArn }; sfn.startExecution(params, function(err, data) { if (err) callback(err); else callback(null,event); }); } ``` 1. Choisissez **Deploy** pour déployer le code. ## Étape 3 : créer une machine à états Maintenant que vous avez créé vos deux fonctions Lambda, créez une machine à états. Dans cette machine d'état, les états `ShouldRestart` et `Restart` se rapportent à la façon dont vous scindez votre tâche en plusieurs exécutions. **Example ShouldRestart État du choix** L'extrait suivant montre l'`ShouldRestart``Choice`état. Cet état détermine si vous devez ou non redémarrer l'exécution. ``` "ShouldRestart": { "Type": "Choice", "Choices": [ { "Variable": "$.restart.executionCount", "NumericGreaterThan": 1, "Next": "Restart" } ], ``` La valeur `$.restart.executionCount` est incluse dans les données d'entrée de l'exécution initiale. Elle est décrémenté d'une unité chaque fois que la fonction `Restart` est appelée, puis placée dans l'entrée pour chaque exécution suivante. **Example Redémarrer l'état de la tâche** L'extrait suivant montre l'`Restart``Task`état. Cet état utilise la fonction Lambda que vous avez créée précédemment pour redémarrer l'exécution et décrémenter le nombre d'exécutions afin de suivre le nombre d'exécutions restantes à démarrer. ``` "Restart": { "Type": "Task", "Resource": "arn:aws:lambda:region:123456789012:function:Restart", "Next": "Done" }, ``` **Pour créer la machine d'état** 1. Ouvrez la [console Step Functions](https://console.aws.amazon.com/states/home), choisissez **State machines** dans le menu, puis **Create state machine**. **Important** [Assurez-vous que votre machine à états se trouve sous le même AWS compte et dans la même région que les fonctions Lambda que vous avez créées précédemment aux [étapes 1 et 2](#tutorial-continue-new-step-1).](#tutorial-continue-new-step-3) 1. Choisissez **Créer à partir de rien**. 1. Donnez un nom à votre machine d'état, puis choisissez **Continuer** pour modifier votre machine d'état dans Workflow Studio. 1. Pour ce didacticiel, vous allez écrire la définition [Amazon States Language](concepts-amazon-states-language.md) (ASL) de votre machine à états dans le[Éditeur de code](workflow-studio.md#wfs-interface-code-editor). Pour ce faire, sélectionnez **Code**. 1. Supprimez le code standard existant et collez le code suivant. N'oubliez pas de remplacer ARNs le contenu de ce code par les ARNs fonctions Lambda que vous avez créées. ``` { "Comment": "Continue-as-new State Machine Example", "StartAt": "ConfigureCount", "States": { "ConfigureCount": { "Type": "Pass", "Result": { "count": 100, "index": -1, "step": 1 }, "ResultPath": "$.iterator", "Next": "Iterator" }, "Iterator": { "Type": "Task", "Resource": "arn:aws:lambda:region:123456789012:function:Iterator", "ResultPath": "$.iterator", "Next": "IsCountReached" }, "IsCountReached": { "Type": "Choice", "Choices": [ { "Variable": "$.iterator.continue", "BooleanEquals": true, "Next": "ExampleWork" } ], "Default": "ShouldRestart" }, "ExampleWork": { "Comment": "Your application logic, to run a specific number of times", "Type": "Pass", "Result": { "success": true }, "ResultPath": "$.result", "Next": "Iterator" }, "ShouldRestart": { "Type": "Choice", "Choices": [ { "Variable": "$.restart.executionCount", "NumericGreaterThan": 0, "Next": "Restart" } ], "Default": "Done" }, "Restart": { "Type": "Task", "Resource": "arn:aws:lambda:region:123456789012:function:Restart", "Next": "Done" }, "Done": { "Type": "Pass", "End": true } } } ``` 1. Spécifiez un nom pour votre machine à états. Pour ce faire, cliquez sur l'icône d'édition à côté du nom de la machine à états par défaut de **MyStateMachine**. Ensuite, dans **Configuration de la machine d'état**, spécifiez un nom dans le champ **Nom de la machine d'état**. Pour ce didacticiel, saisissez le nom **ContinueAsNew**. 1. (Facultatif) Dans **Configuration de la machine à états**, spécifiez d'autres paramètres de flux de travail, tels que le type de machine à états et son rôle d'exécution. Pour ce didacticiel, conservez toutes les sélections par défaut dans **les paramètres State Machine**. Si vous avez [déjà créé un rôle IAM](procedure-create-iam-role.md) avec les autorisations appropriées pour votre machine d'état et que vous souhaitez l'utiliser, dans **Autorisations**, sélectionnez **Choisir un rôle existant**, puis sélectionnez un rôle dans la liste. Vous pouvez également sélectionner **Entrer un ARN de rôle**, puis fournir un ARN pour ce rôle IAM. 1. Dans la boîte de dialogue **Confirmer la création du rôle**, choisissez **Confirmer** pour continuer. Vous pouvez également choisir **Afficher les paramètres des rôles** pour revenir à la **configuration de la machine State**. **Note** Si vous supprimez le rôle IAM créé par Step Functions, Step Functions ne pourra pas le recréer ultérieurement. De même, si vous modifiez le rôle (par exemple, en supprimant Step Functions des principes de la politique IAM), Step Functions ne pourra pas restaurer ses paramètres d'origine ultérieurement. 1. Enregistrez le nom de ressource Amazon (ARN) de cette machine d'état dans un fichier texte. Vous devez fournir l'ARN tout en autorisant la fonction Lambda à démarrer une nouvelle exécution de Step Functions. ## Étape 4 : Mettre à jour la politique IAM Pour vous assurer que votre fonction Lambda est autorisée à démarrer une nouvelle exécution de Step Functions, associez une politique en ligne au rôle IAM que vous utilisez pour votre fonction Lambda. `Restart` Pour plus d'informations, consultez la section [Intégration de politiques intégrées](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console) dans le guide de l'utilisateur *IAM*. **Note** Vous pouvez mettre à jour la ligne `Resource` de l'exemple précédent pour faire référence à l'ARN de votre machine d'état `ContinueAsNew`. Cette limite la stratégie afin qu'elle ne puisse démarrer qu'une exécution de cette machine d'état spécifique. **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "states:StartExecution" ], "Resource": "arn:aws:states:us-east-2:123456789012:stateMachine:ContinueAsNew" } ] } ``` ## Étape 5 : Exécutez la machine d'état Pour démarrer une exécution, fournissez une entrée qui inclut l'ARN de la machine d'état et un `executionCount` relatif au nombre de fois où une nouvelle exécution doit être démarrée. 1. Sur la **ContinueAsNew**page, choisissez **Démarrer l'exécution**. La boîte de dialogue **Démarrer l'exécution** s'affiche. 1. Dans la boîte de dialogue **Démarrer l'exécution**, procédez comme suit : 1. (Facultatif) Entrez un nom d'exécution personnalisé pour remplacer le nom par défaut généré. **Noms non ASCII et journalisation** Step Functions accepte les noms des machines à états, des exécutions, des activités et des étiquettes contenant des caractères non ASCII. Dans la mesure où ces caractères empêcheront Amazon CloudWatch d'enregistrer les données, nous vous recommandons de n'utiliser que des caractères ASCII afin de pouvoir suivre les métriques de Step Functions. 1. Dans le champ **Entrée**, entrez l'entrée JSON suivante pour exécuter votre flux de travail. ``` { "restart": { "StateMachineArn": "arn:aws:states:region:account-id:stateMachine:ContinueAsNew", "executionCount": 4 } } ``` 1. Mettez à jour le champ `StateMachineArn` avec l'ARN de votre machine d'état `ContinueAsNew`. 1. Choisissez **Start execution (Démarrer l'exécution)**. 1. La console Step Functions vous dirige vers une page intitulée avec votre ID d'exécution. Cette page est connue sous le nom de page *Détails de l'exécution*. Sur cette page, vous pouvez consulter les résultats de l'exécution au fur et à mesure que l'exécution progresse ou une fois celle-ci terminée. Pour consulter les résultats de l'exécution, choisissez des états individuels dans la **vue graphique**, puis choisissez les onglets individuels du [Détails de l'étape](concepts-view-execution-details.md#exec-details-intf-step-details) volet pour afficher les détails de chaque état, y compris les entrées, les sorties et la définition respectivement. Pour plus de détails sur les informations d'exécution que vous pouvez consulter sur la page *Détails de l'exécution*, voir[Vue d'ensemble des détails d'exécution](concepts-view-execution-details.md#exec-details-interface-overview). La **vue graphique** affiche la première des quatre exécutions. Avant de se terminer, il va transmettre l'état `Restart` et démarrer une nouvelle exécution. ![\[Schéma d'exécution montrant la première exécution sur quatre.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/execution-test1.png) Au fur et à mesure que cette exécution est terminée, vous pouvez regarder la prochaine exécution en cours. Cliquez **ContinueAsNew**sur le lien en haut pour voir la liste des exécutions. Vous devriez voir à la fois l'exécution récemment clôturée et une exécution en cours lancée par la fonction `Restart` Lambda. Une fois toutes les exécutions terminées, vous devez voir quatre exécutions réussies dans la liste. La première exécution démarrée affiche le nom que vous avez choisi et un nom a été généré pour les exécutions suivantes. ![\[Capture d'écran illustrative montrant que toutes les exécutions sont terminées.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/execution-test1-complete.png)