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.

# Examen des exécutions des machines à états dans Step Functions
<a name="debug-sm-exec-using-ui"></a>

Dans ce didacticiel, vous allez apprendre à inspecter les informations d'exécution affichées sur la * page Détails de l'*exécution et à visualiser la raison de l'échec de l'exécution. Vous apprendrez ensuite comment accéder aux différentes itérations d'une exécution d'`Map`état. Enfin, vous allez apprendre à configurer les colonnes de la vue ** Tableau ** et à appliquer des filtres appropriés pour afficher uniquement les informations qui vous intéressent.

Dans ce didacticiel, vous allez créer une machine à états de type Standard, qui obtient le prix d'un ensemble de fruits. Pour ce faire, la machine à états utilise trois AWS Lambda fonctions qui renvoient une liste aléatoire de quatre fruits, le prix de chaque fruit et le coût moyen des fruits. Les fonctions Lambda sont conçues pour générer une erreur si le prix des fruits est inférieur ou égal à une valeur seuil.

**Note**  
Bien que la procédure suivante contienne des instructions sur la manière d'examiner les détails d'une exécution de flux de travail standard, vous pouvez également examiner les détails des exécutions de flux de travail Express. Pour plus d'informations sur les différences entre les détails d'exécution pour les types de flux de travail Standard et Express, consultez[Différences d'expérience entre les consoles Standard et Express](concepts-view-execution-details.md#console-exp-differences).

## Étape 1 : Création et test des fonctions Lambda requises
<a name="step-create-all-lambda-functions"></a>

1. Ouvrez la console [ Lambda, ](https://console.aws.amazon.com/lambda/home) puis effectuez les étapes 1 à 4 de la [Étape 1 : créer une fonction Lambda](tutorial-creating-lambda-state-machine.md#create-lambda-function) section. Assurez-vous de nommer la fonction Lambda. **GetListOfFruits**

1. Après avoir créé votre fonction Lambda, copiez le nom de ressource Amazon (ARN) de la fonction affiché. Pour copier l'ARN, cliquez sur l'icône de copie pour copier le nom de ressource Amazon de la fonction Lambda. Voici un exemple d'ARN, où se {{`function-name`}} trouve le nom de la fonction Lambda (dans ce cas,`GetListOfFruits`) :

   ```
   arn:aws:lambda:{{region}}:123456789012:function:{{function-name}}
   ```

1. Copiez le code suivant pour la fonction Lambda dans la ** zone ** Code source de la ** GetListOfFruits ** page.

   ```
   function getRandomSubarray(arr, size) {
       var shuffled = arr.slice(0), i = arr.length, temp, index;
       while (i--) {
           index = Math.floor((i + 1) * Math.random());
           temp = shuffled[index];
           shuffled[index] = shuffled[i];
           shuffled[i] = temp;
       }
       return shuffled.slice(0, size);
   }
   
   exports.handler = async function(event, context) {
       
       const fruits = ['Abiu','Açaí','Acerola','Ackee','African cucumber','Apple','Apricot','Avocado','Banana','Bilberry','Blackberry','Blackcurrant','Jostaberry'];
   
       
        const errorChance = 45;
       
       const waitTime = Math.floor( 100 * Math.random() );
   
       await new Promise( r => setTimeout(() => r(), waitTime));
   
       const num = Math.floor( 100 * Math.random() );
       // const num = 51;
        if (num <= errorChance) {
            throw(new Error('Error'));
        }
   
       return getRandomSubarray(fruits, 4);
   };
   ```

1. Choisissez ** Déployer**, puis choisissez ** Tester ** pour déployer les modifications et voir le résultat de votre fonction Lambda.

1. Créez deux fonctions Lambda supplémentaires, nommées **GetFruitPrice** et **CalculateAverage** respectivement, en procédant comme suit :

   1. Copiez le code suivant dans la ** zone ** Code source de la fonction ** GetFruitPrice ** Lambda :

      ```
      exports.handler = async function(event, context) {
          
          const errorChance = 0;
          const waitTime = Math.floor( 100 * Math.random() );
      
          await new Promise( r => setTimeout(() => r(), waitTime));
      
          const num = Math.floor( 100 * Math.random() );
          if (num <= errorChance) {
              throw(new Error('Error'));
          }
      
          return Math.floor(Math.random()*100)/10;
      };
      ```

   1. Copiez le code suivant dans la ** zone ** Code source de la fonction ** CalculateAverage ** Lambda :

      ```
      function getRandomSubarray(arr, size) {
          var shuffled = arr.slice(0), i = arr.length, temp, index;
          while (i--) {
              index = Math.floor((i + 1) * Math.random());
              temp = shuffled[index];
              shuffled[index] = shuffled[i];
              shuffled[i] = temp;
          }
          return shuffled.slice(0, size);
      }
      
      const average = arr => arr.reduce( ( p, c ) => p + c, 0 ) / arr.length;
          
      exports.handler = async function(event, context) {
              const errors = [
              "Error getting data from DynamoDB",
              "Error connecting to DynamoDB",
              "Network error",
              "MemoryError - Low memory"
              ]
              
          const errorChance = 0;
          
          const waitTime = Math.floor( 100 * Math.random() );
      
          await new Promise( r => setTimeout(() => r(), waitTime));
      
          const num = Math.floor( 100 * Math.random() );
          if (num <= errorChance) {
              throw(new Error(getRandomSubarray(errors, 1)[0]));
          }
      
          return average(event);
      };
      ```

   1. Assurez-vous de copier les ARN de ces deux fonctions Lambda, puis ** déployez-les ** et ** ** testez-les.

## Étape 2 : Création et exécution de la machine à états
<a name="step-create-exec-sm"></a>

Utilisez la console [ Step Functions ](https://console.aws.amazon.com/states/home?region=us-east-1#/) pour créer une machine d'états qui appelle les fonctions [ Lambda que vous avez créées à l'étape 1. ](#step-create-all-lambda-functions) Dans cette machine à états, trois `Map` états sont définis. Chacun de ces `Map` états contient un `Task` état qui invoque l'une de vos fonctions Lambda. En outre, un `Retry` champ est défini dans chaque `Task` état avec un certain nombre de tentatives de nouvelle tentative définies pour chaque état. Si un `Task` état rencontre une erreur d'exécution, il est exécuté à nouveau dans la limite du nombre de tentatives défini pour cela`Task`.

1. Ouvrez la console [ Step Functions ](https://console.aws.amazon.com/states/home) et choisissez ** Écrire votre flux de travail dans du code**.
**Important**  
Assurez-vous que votre machine d'état se trouve sous le même AWS compte et la même région que la fonction Lambda que vous avez créée précédemment.

1. Pour ** Type**, conservez la sélection par défaut ** Standard**.

1. Copiez la définition suivante d'Amazon States Language et collez-la sous ** Définition**. Assurez-vous de remplacer les ARN affichés par ceux des fonctions Lambda que vous avez créées précédemment.

   ```
   {
       "StartAt": "LoopOverStores",
       "States": {
           "LoopOverStores": {
               "Type": "Map",
               "Iterator": {
                   "StartAt": "GetListOfFruits",
                   "States": {
                       "GetListOfFruits": {
                           "Type": "Task",
                           "Resource": "arn:aws:states:::lambda:invoke",
                           "OutputPath": "$.Payload",
                           "Parameters": {
                               "FunctionName": "arn:aws:lambda:{{{{region}}}}:{{123456789012}}:function:GetListofFruits:$LATEST",
                               "Payload": {
                                   "storeName.$": "$"
                               }
                           },
                           "Retry": [
                               {
                                   "ErrorEquals": [
                                       "States.ALL"
                                   ],
                                   "IntervalSeconds": 2,
                                   "MaxAttempts": 1,
                                   "BackoffRate": 1.3
                               }
                           ],
                           "Next": "LoopOverFruits"
                       },
                       "LoopOverFruits": {
                           "Type": "Map",
                           "Iterator": {
                               "StartAt": "GetFruitPrice",
                               "States": {
                                   "GetFruitPrice": {
                                       "Type": "Task",
                                       "Resource": "arn:aws:states:::lambda:invoke",
                                       "OutputPath": "$.Payload",
                                       "Parameters": {
                                           "FunctionName": "arn:aws:lambda:{{{{region}}}}:{{123456789012}}:function:GetFruitPrice:$LATEST",
                                           "Payload": {
                                               "fruitName.$": "$"
                                           }
                                       },
                                       "Retry": [
                                           {
                                               "ErrorEquals": [
                                                   "States.ALL"
                                               ],
                                               "IntervalSeconds": 2,
                                               "MaxAttempts": 3,
                                               "BackoffRate": 1.3
                                           }
                                       ],
                                       "End": true
                                   }
                               }
                           },
                           "ItemsPath": "$",
                           "End": true
                       }
                   }
               },
               "ItemsPath": "$.stores",
               "Next": "LoopOverStoreFruitsPrice",
               "ResultPath": "$.storesFruitsPrice"
           },
           "LoopOverStoreFruitsPrice": {
               "Type": "Map",
               "End": true,
               "Iterator": {
                   "StartAt": "CalculateAverage",
                   "States": {
                       "CalculateAverage": {
                           "Type": "Task",
                           "Resource": "arn:aws:states:::lambda:invoke",
                           "OutputPath": "$.Payload",
                           "Parameters": {
                               "FunctionName": "arn:aws:lambda:{{{{region}}}}:{{123456789012}}:function:Calculate-average:$LATEST",
                               "Payload.$": "$"
                           },
                           "Retry": [
                               {
                                   "ErrorEquals": [
                                       "States.ALL"
                                   ],
                                   "IntervalSeconds": 2,
                                   "MaxAttempts": 2,
                                   "BackoffRate": 1.3
                               }
                           ],
                           "End": true
                       }
                   }
               },
               "ItemsPath": "$.storesFruitsPrice",
               "ResultPath": "$.storesPriceAverage",
               "MaxConcurrency": 1
           }
       }
   }
   ```

1. Entrez un nom pour votre machine d'État. Conservez les sélections par défaut pour les autres options de cette page et choisissez ** Create state machine**.

1. Ouvrez la page intitulée avec le nom de votre machine d'état. Effectuez les étapes 1 à 4 de la [Étape 4 : Exécutez la machine d'état](tutorial-creating-lambda-state-machine.md#start-lambda-function) section, mais utilisez les données suivantes comme entrée d'exécution :

   ```
   {
       "stores": [
         "Store A",
         "Store B",
         "Store C",
         "Store D"
       ]
   }
   ```

## Étape 3 : Afficher les détails d'exécution de la machine d'état
<a name="view-sm-exec-details"></a>

Sur la page intitulée avec votre identifiant d'exécution, vous pouvez consulter les résultats de votre exécution et corriger les éventuelles erreurs.

1. (Facultatif) Choisissez l'un des onglets affichés sur la * page Détails de l'*exécution pour voir les informations présentes dans chacun d'eux. Par exemple, pour afficher l'entrée de la machine d'état et sa sortie d'exécution, choisissez Entrée et sortie d'**exécution dans ** la [* section Résumé de *](concepts-view-execution-details.md#exec-details-intf-exec-summ) l'exécution.

1. Si l'exécution de votre machine d'état a échoué, choisissez ** Cause ** ou ** Afficher les détails de l'étape dans ** le message d'erreur. Les détails de l'erreur sont affichés dans la [* section Détails de l'*](concepts-view-execution-details.md#exec-details-intf-step-details)étape. Notez que l'étape à l'origine de l'erreur, qui est un `Task` état nommé ** GetListofFruits**, est mise en surbrillance dans la vue ** Graphique ** et la vue ** Tableau**.
**Note**  
Étant donné que l'**GetListofFruits**étape est définie dans un `Map` état et que l'étape n'a pas pu s'exécuter correctement, l'**étape `Map` État ** de l'état s'affiche comme ** Échec**.

## Étape 4 : Explorez les différents *Modes d'affichage*
<a name="sm-exec-details-exp-view-modes"></a>

Vous pouvez choisir un mode préféré pour afficher le flux de travail de la machine à états ou l'historique des événements d'exécution. Certaines des tâches que vous pouvez effectuer dans ces modes d'*affichage * sont les suivantes :

### **Vue graphique** — Basculer entre les différentes itérations de `l'état de` la carte
<a name="graph-view-see-map-state-iterations"></a>

Si ** l'état de votre ** carte comporte cinq itérations et que vous souhaitez afficher les détails d'exécution des troisième et quatrième itérations, procédez comme suit :

1. Choisissez l'`Map`état pour lequel vous souhaitez afficher les données d'itération.

1. Dans la visionneuse d'itérations ** cartographiques**, choisissez l'itération que vous souhaitez afficher. Les itérations sont comptées à partir de zéro. Pour choisir la troisième itération sur cinq, choisissez ** \#2 ** dans la liste déroulante à côté du nom de l'**état de la ** carte.
**Note**  
Si votre machine à états contient des `Map` états imbriqués, Step Functions affiche les itérations des `Map` états parent et enfant sous la forme de deux listes déroulantes distinctes représentant les données d'itération pour les états imbriqués.

1. (Facultatif) Si une ou plusieurs de vos itérations d'`Map`état n'ont pas pu s'exécuter ou ont été arrêtées en mode abandonné, vous pouvez consulter les détails de l'itération ayant échoué. Pour voir ces détails, choisissez les numéros d'itération concernés sous ** Échec ** ou ** Abandonné ** dans la liste déroulante.

### **Vue du tableau** — Basculer entre les différentes itérations de `l'état de` la carte
<a name="table-view-see-map-state-iterations"></a>

Si ** l'état de votre ** carte comporte cinq itérations et que vous souhaitez afficher les détails d'exécution pour les itérations numéro trois et quatre, procédez comme suit :

1. Choisissez l'`Map`état pour lequel vous souhaitez afficher les différentes données d'itération.

1. Dans l'arborescence des itérations d'`Map`état, choisissez la ligne pour l'itération nommée ** \#2 ** pour l'itération numéro trois. De même, choisissez la ligne nommée ** \#3 ** pour l'itération numéro quatre.

### **Vue du tableau** — Configurez les colonnes à afficher
<a name="table-view-cfg-display-cols"></a>

Choisissez l'icône des paramètres. Ensuite, dans la boîte ** de dialogue ** Préférences, choisissez les colonnes que vous souhaitez afficher sous ** Sélectionner les colonnes visibles**.

Par défaut, ce mode affiche les ** colonnes ** Nom**, ** Type**, ** État ****, ** Ressource et ** Commencé après.

### **Vue du tableau** — Filtrer les résultats
<a name="table-view-filter-results"></a>

Limitez la quantité d'informations affichées en appliquant un ou plusieurs filtres en fonction d'une propriété, telle que le ** statut**, ou d'une plage de dates et d'heures. Par exemple, pour afficher les étapes dont l'exécution a échoué, appliquez le filtre suivant :

1. Choisissez ** Filtrer par propriétés ou effectuez une recherche par mot clé**, puis choisissez ** État ** sous ** Propriétés**.

1. Sous ** Opérateurs**, choisissez ** Status =**.

1. Choisissez ** État = Échec**.

1. (Facultatif) Choisissez ** Effacer les filtres ** pour supprimer les filtres appliqués.

### **Vue de l'événement** — Filtrer les résultats
<a name="event-view-filter-results"></a>

Limitez la quantité d'informations affichées en appliquant un ou plusieurs filtres en fonction d'une propriété, telle que le ** Type ** ou une plage de dates et d'heures. Par exemple, pour afficher les étapes `Task` d'état dont l'exécution a échoué, appliquez le filtre suivant :

1. Choisissez ** Filtrer par propriétés ou effectuer une recherche par mot clé**, puis choisissez ** Type ** sous ** Propriétés**.

1. Sous ** Opérateurs**, choisissez ** Type =**.

1. Choisissez ** Type = TaskFailed**.

1. (Facultatif) Choisissez ** Effacer les filtres ** pour supprimer les filtres appliqués.

### **Vue de l'événement** — Inspectez un **TaskFailed** détail de l'événement
<a name="event-view-inspect-failed-task-details"></a>

Choisissez l'icône en forme de flèche à côté de l'ID d'un ** TaskFailed ** événement pour inspecter ses détails, notamment les entrées, les sorties et l'appel de ressources qui apparaissent dans une liste déroulante.