Gestion des conditions d'erreur dans une machine à états Step Functions

Dans ce didacticiel, vous allez créer une machine à AWS Step Functions états avec un état Task qui invoque un exemple de fonction Lambda conçue pour générer une erreur personnalisée.

Les tâches sont l'États de repliune des tâches pour lesquelles vous pouvez configurer un Catch champ. Lorsque des erreurs sont reçues par l'intégration, les étapes suivantes sont choisies par le champ catch en fonction du nom de l'erreur.

Étape 1 : créer une fonction Lambda qui génère une erreur

Utilisez une fonction Lambda pour simuler une condition d'erreur.

1. Ouvrez la AWS Lambda console à l'adresse https://console.aws.amazon.com/lambda/.

2. Choisissez Créer une fonction.

3. Choisissez Utiliser un plan, recherchezStep Functions, puis choisissez Lancer une erreur personnalisée.

4. Sous Nom de la fonction, saisissez ThrowErrorFunction.

5. Pour Role (Rôle), choisissez Create a new role with basic Lambda permissions (Créer un nouveau rôle avec les autorisations Lambda de base).

6. Choisissez Créer une fonction.

   Le code suivant doit être affiché dans le volet de code.

   export const handler = async () => {
       function CustomError(message) {
           this.name = 'CustomError';
           this.message = message;
       }
       CustomError.prototype = new Error();
   
       throw new CustomError('This is a custom error!');
   };
   

Étape 2 : Testez votre fonction Lambda

Avant de créer une machine à états, vérifiez que votre fonction Lambda vous renvoie CustomError lorsqu'elle est invoquée.

1. Choisissez l’onglet Test.

2. Choisissez Créer un nouvel événement et conservez le JSON d'événement par défaut

3. Choisissez Test pour appeler votre fonction avec votre événement de test.

4. Développez la fonction d'exécution pour passer en revue les détails de l'erreur générée.

Vous avez maintenant une fonction Lambda prête à générer une erreur personnalisée.

À l'étape suivante, vous allez configurer une machine à états pour détecter et réessayer de corriger cette erreur.

Étape 3 : Créez votre machine à états

Utilisez la console Step Functions pour créer une machine à états qui utilise un État du flux de travail des tâches avec une Catch configuration. La machine à états invoquera la fonction Lambda, que vous avez conçue pour simuler le renvoi d'une erreur lorsque la fonction est invoquée. Step Functions réessaie la fonction en utilisant un décalage exponentiel entre les tentatives.

1. Ouvrez la console Step Functions, choisissez State machines dans le menu, puis Create state machine.

2. Choisissez Créer à partir du champ vide, puis entrez dans le champ State machine nameCatchErrorStateMachine.

3. Acceptez le type par défaut (Standard), puis choisissez Continuer pour modifier votre machine d'état dans Workflow Studio.

4. Choisissez Code pour passer à l'éditeur ASL, puis remplacez le code par la définition de machine à états suivante :

   {
     "Comment": "Example state machine that can catch a custom error thrown by a function integration.",
     "StartAt": "CreateAccount",
     "States": {
       "CreateAccount": {
         "Type": "Task",
         "Resource": "arn:aws:states:::lambda:invoke",
         "Output": "{% $states.result.Payload %}",
         "Arguments": {
           "FunctionName": "arn:aws:lambda:region:account-id:function:ThrowErrorFunction:$LATEST",
           "Payload": "{% $states.input %}"
         },
         "Catch": [
           {
             "ErrorEquals": [
               "CustomError"
             ],
             "Next": "CustomErrorFallback"
           },
           {
             "ErrorEquals": [
               "States.ALL"
             ],
             "Next": "CatchAllFallback"
           }
         ],
         "End": true,
         "Retry": [
           {
             "ErrorEquals": [
               "CustomError",
               "Lambda.ServiceException",
               "Lambda.AWSLambdaException",
               "Lambda.SdkClientException",
               "Lambda.TooManyRequestsException"
             ],
             "IntervalSeconds": 1,
             "MaxAttempts": 3,
             "BackoffRate": 2,
             "JitterStrategy": "FULL"
           }
         ]
       },
       "CustomErrorFallback": {
         "Type": "Pass",
         "End": true,
         "Output": {
           "Result": "Fallback from a custom error function."
         }
       },
       "CatchAllFallback": {
         "Type": "Pass",
         "End": true,
         "Output": {
           "Result": "Fallback from all other error codes."
         }
       }
     },
     "QueryLanguage": "JSONata"
   }

Étape 4 : Configuration de votre machine à états

Avant d'exécuter votre machine à états, vous devez d'abord vous connecter à la fonction Lambda que vous avez créée précédemment.

1. Revenez en mode Design et sélectionnez l'état de tâche Lambda : Invoke nommé. CreateAccount

2. Dans l'onglet Configuration, recherchez les arguments de l'API. Dans Nom de la fonction, choisissez la fonction Lambda que vous avez créée précédemment.

3. Choisissez Créer, passez en revue les rôles, puis choisissez Confirmer pour créer votre machine à états.

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

Après avoir créé et configuré votre machine d'état, vous pouvez l'exécuter et examiner le flux.

1. Dans l'éditeur, choisissez Execute.

   Sinon, dans la liste State machines, sélectionnez Démarrer l'exécution.

2. Dans la boîte de dialogue Démarrer l'exécution, acceptez l'ID généré et, dans le champ Entrée, entrez le code JSON suivant :

   { "Cause" : "Custom Function Error" }

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

La console Step Functions vous dirige vers une page intitulée avec votre ID d'exécution, connue sous le nom de page Execution Details. Vous pouvez consulter les résultats de l'exécution au fur et à mesure que le flux de travail progresse et une fois celui-ci terminé.

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, voirVue d'ensemble des détails d'exécution.

Votre machine à états invoque la fonction Lambda, qui lance un. CustomError Choisissez l'CreateAccountétape dans la vue graphique pour voir la sortie d'état. La sortie de votre machine à états doit ressembler à l'illustration suivante :

Félicitations !

Vous disposez désormais d'une machine à états capable de détecter et de gérer les conditions d'erreur générées par une fonction Lambda. Vous pouvez utiliser ce modèle pour implémenter une gestion robuste des erreurs dans vos flux de travail.

Note

Vous pouvez également créer des machines à états qui réessayent en cas d'expiration du délai d'expiration ou qui sont utilisées Catch pour passer à un état spécifique en cas d'erreur ou de délai d'expiration. Pour accéder à des exemples de ces techniques de gestion des erreurs, consultez Exemples utilisant Retry et utilisant Catch.