Utiliser une fonction Lambda pour poursuivre une nouvelle exécution dans Step Functions

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. L'utilisation de cette approche pour poursuivre votre travail en cours dans le cadre d'une nouvelle exécution vous permet de disposer d'une machine à états capable de diviser les tâches volumineuses en flux de travail plus petits, ou d'avoir une machine à états qui fonctionne 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 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.

État	Objectif
ConfigureCount	PassÉtat qui configure les step valeurs countindex, 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 le cadre d'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.

Prérequis

Avant de commencer, suivez le Création d'une machine d'état Step Functions utilisant Lambda 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 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 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 countindex, 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éation de la fonction Iterate Lambda

1. Ouvrez la console Lambda, puis choisissez Create function (Créer une fonction.

2. Sur la page Create function, sélectionnez Author from scratch.

3. Dans la section Informations de base, configurez votre fonction Lambda comme suit :

   1. Sous Nom de la fonction, saisissez Iterator.

   2. Pour Exécution, choisissez Node.js 16.x.

   3. 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 nom de ressource Amazon (ARN) dans le coin supérieur droit de la page, par exemple :

      arn:aws:lambda:us-east-1:123456789012:function:Iterator

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

5. 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.

2. 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.

3. Sélectionnez Create (Créer).

4. Sur le Itérateur page de votre console Lambda, assurez-vous qu'elle TestIteratorest répertoriée, 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, puis choisissez Create function (Créer une fonction.

2. Sur la page Create function, sélectionnez Author from scratch.

3. Dans la section Informations de base, configurez votre fonction Lambda comme suit :

   1. Sous Nom de la fonction, saisissez Restart.

   2. Pour Exécution, choisissez Node.js 16.x.

4. 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 nom de ressource Amazon (ARN) dans le coin supérieur droit de la page, par exemple :

   arn:aws:lambda:us-east-1:123456789012:function:Iterator

5. Copiez le code suivant pour la fonction Lambda dans la section Code source du Restartpage dans 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);
     });
   
   }

6. Choisissez Deploy pour déployer le code.

Étape 3 : Création d'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.

Exemple ShouldRestart État du choix

L'extrait suivant montre l'ShouldRestartChoiceé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.

Exemple Redémarrer l'état de la tâche

L'extrait suivant montre l'RestartTaské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:us-east-1:123456789012:function:Restart",
  "Next": "Done"
},

Pour créer la machine d'état

1. Ouvrez la console Step Functions et choisissez 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.

2. Dans la boîte de dialogue Choisir un modèle, sélectionnez Vide.

3. Choisissez Sélectionner pour ouvrir Workflow Studio dansMode de conception.

4. Pour ce didacticiel, vous allez écrire la définition Amazon States Language (ASL) de votre machine à états dans leÉditeur de code. Pour ce faire, sélectionnez Code.

5. 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:us-east-1: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:us-east-1:123456789012:function:Restart",
             "Next": "Done"
           },
           "Done": {
               "Type": "Pass",
               "End": true 
           }
       }
   }

6. 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.

7. (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 IAM rôle 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 rôle, ARN puis fournir un ARN pour ce IAM rôle.

8. 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 IAM rôle 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 IAM politique), Step Functions ne pourra pas restaurer ses paramètres d'origine ultérieurement.

9. Enregistrez le nom de ressource Amazon (ARN) de cette machine d'état dans un fichier texte. Vous devez ARN tout en autorisant la fonction Lambda à démarrer une nouvelle exécution de Step Functions.

Étape 4 : Mise à jour de la stratégie 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 IAM rôle que vous utilisez pour votre fonction LambdaRestart. Pour plus d'informations, consultez la section Intégration de politiques intégrées dans le guide de l'IAMutilisateur.

Note

Dans l'exemple précédent, vous pouvez mettre à jour la Resource ligne pour faire référence à votre machine à ContinueAsNew états. ARN 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:123456789012stateMachine:ContinueAsNew"
     }
 ]
}

Étape 5 : Exécutez la machine d'état

Pour démarrer une exécution, fournissez une entrée qui inclut le ARN nom de la machine à états et le nombre de fois où elle doit démarrer une nouvelle exécution. executionCount

1. Sur la ContinueAsNewpage, choisissez Démarrer l'exécution.

   La boîte de dialogue Démarrer l'exécution s'affiche.

2. Dans la boîte de dialogue Démarrer l'exécution, procédez comme suit :

   1. (Facultatif) Pour identifier votre exécution, vous pouvez spécifier un nom ou utiliser le nom d'exécution généré par défaut.

      Note

      Step Functions accepte les noms des machines d'état, des exécutions, des activités et des étiquettes contenant des caractères autres que des ASCII caractères. Étant donné que les noms ne contenant pas de ASCII caractères ne fonctionneront pas avec Amazon CloudWatch, nous vous recommandons de n'utiliser que ASCII des caractères afin de pouvoir suivre les statistiques. CloudWatch

   2. Dans la zone de saisie, entrez l'JSONentrée suivante pour exécuter votre flux de travail.

      {
        "restart": {
          "StateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:ContinueAsNew",
          "executionCount": 4
        }
      }
              

   3. Mettez à jour le StateMachineArn champ avec le ARN correspondant à votre machine ContinueAsNew d'état.

   4. Choisissez Start execution (Démarrer l'exécution).

   5. 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 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, voirPage de détails d'exécution — Vue d'ensemble de l'interface.

      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.

      

      Au fur et à mesure que cette exécution est terminée, vous pouvez regarder la prochaine exécution en cours. Cliquez ContinueAsNewsur 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.