

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.

# Utilisation d'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, qui permet de poursuivre le travail en cours dans une nouvelle exécution, vous pouvez diviser les 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 réduire un nombre à chaque fois qu'une nouvelle exécution est lancée. 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 que la fonction `Iterator` Lambda utilise pour effectuer les itérations du 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 poursuivre le travail d'exemple ou passer à l'ShouldRestartétat. | 
| `ExampleWork` | PassÉtat qui représente l'État qui effectuerait le Task travail dans le cadre d'une mise en œuvre 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 s'arrêter.  | 
| `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
<a name="tutorial-continue-new-prereq"></a>

Avant de commencer, parcourez le [Création d'une machine d'états Step Functions qui utilise Lambda](tutorial-creating-lambda-state-machine.md) didacticiel pour vous assurer que vous êtes familiarisé avec l'utilisation conjointe des fonctions Lambda et Step.

## Étape 1 : Création d'une fonction Lambda pour itérer un décompte
<a name="tutorial-continue-new-step-1"></a>

**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 des 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 définit `continue` `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éation de la fonction Iterate Lambda
<a name="tutorial-continue-new-create-lambda-function"></a>

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 ** Runtime**, choisissez ** Node.js 16.x**.

   1. Conservez toutes les sélections par défaut sur la page, puis choisissez ** Créer une fonction**.

      Une fois que Lambda a créé votre fonction, notez son Amazon Resource Name (ARN), par exemple :

      ```
      arn:aws:lambda:{{region}}:123456789012:function:Iterator
      ```

1. Copiez le code suivant pour la fonction Lambda dans la ** section ** Code source de la ** {{Iterator}} ** page de la console Lambda.

   ```javascript
   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 ** Déployer ** pour déployer le code.

### Testez la fonction Iterate Lambda
<a name="tutorial-continue-new-step-1-test"></a>

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
<a name="tutorial-continue-new-test-lambda-function"></a>

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.

   ```json
   {
     "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 `continue` comme. `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 ** TestIterator ** c'est répertorié, puis choisissez ** Tester**.

   Les résultats des tests apparaissent sur la page. Choisissez **Details** et vérifiez le résultat.

   ```json
   {
     "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
<a name="tutorial-continue-new-step-3"></a>

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 ** Runtime**, choisissez ** Node.js 16.x**.

1. Conservez toutes les sélections par défaut sur la page, puis choisissez ** Créer une fonction**.

   Une fois que Lambda a créé votre fonction, notez son Amazon Resource Name (ARN), par exemple :

   ```
   arn:aws:lambda:{{region}}:123456789012:function:Iterator
   ```

1. Copiez le code suivant pour la fonction Lambda dans la ** section ** Code source 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.

   ```javascript
   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 ** Déployer ** pour déployer le code.

## Étape 3 : Création d'une machine à états
<a name="tutorial-continue-new-step-4"></a>

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 relancer l'exécution.  

```json
"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 relancer l'exécution et pour réduire le nombre afin de suivre le nombre d'exécutions restant à démarrer.  

```json
"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 choisissez ** Create state machine**.
**Important**  
Assurez-vous que votre machine d'état se trouve sous le même AWS compte et la même région que les fonctions Lambda que vous avez créées précédemment aux [ étapes 1 ](#tutorial-continue-new-step-1) et [ 2](#tutorial-continue-new-step-3).

1. Choisissez ** Créer à partir du vide**.

1. Donnez un nom à votre machine à états, puis choisissez ** Continuer ** pour modifier votre machine à états 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 les ARN de ce code par les ARN des fonctions Lambda que vous avez créées.

   ```json
   {
       "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 d'état. Pour ce faire, choisissez l'icône d'édition à côté du nom de la machine d'état par défaut de ** MyStateMachine**. Ensuite, dans Configuration de la machine ** d'état**, spécifiez un nom dans la ** zone 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 à états et que vous souhaitez l'utiliser, dans ** Autorisations**, sélectionnez ** Choisir un rôle existant**, puis sélectionnez un rôle dans la liste. Ou sélectionnez ** Entrez un ARN de rôle, ** puis fournissez 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 ** d'état**.
**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 paramètres principaux de la politique IAM), Step Functions ne pourra pas restaurer ses paramètres d'origine ultérieurement. 

1. Enregistrez l'Amazon Resource Name (ARN) de cette machine d'état dans un fichier texte. Vous devrez 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
<a name="tutorial-continue-new-step-2"></a>

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 `Restart` fonction Lambda. Pour plus d'informations, consultez la section [ Intégrer des politiques en ligne ](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.

****  

```json
{
 "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
<a name="tutorial-continue-new-step-5"></a>

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é.
**Non-ASCII noms 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. Comme ces caractères empêcheront Amazon CloudWatch d'enregistrer des données, nous vous recommandons d'utiliser uniquement des caractères ASCII afin de pouvoir suivre les métriques de Step Functions.

   1. Dans la ** zone de ** saisie, 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 de l'exécution 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 dans le [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 l'entrée, la sortie 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, consultez[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.](https://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/execution-test1.png)

      Une fois cette exécution 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 fermée et une exécution en cours que la fonction `Restart` Lambda a démarrée.

      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.](https://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/execution-test1-complete.png)