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 par machine à é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 à connaître 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 apprendrez à configurer les colonnes de la **vue Tableau** et à appliquer les filtres appropriés pour n'afficher que 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 façon 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éer et tester les 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é dans le coin supérieur droit de la page. 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ù *`function-name`* est 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 **Deploy**, puis choisissez **Test**, 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 **Source du code** 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 **Source du code** 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 ces deux fonctions Lambda, puis de les **déployer** et de les **tester**. ARNs 

## É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 à états qui invoque les [fonctions Lambda que vous avez créées à](#step-create-all-lambda-functions) l'étape 1. 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 nombre de tentatives de nouvelle tentative défini 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 **Write your workflow in code**.
**Important**  
Assurez-vous que votre machine d'état se trouve sous le même AWS compte et dans 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 Amazon States Language suivante et collez-la sous **Définition**. Assurez-vous de remplacer les éléments ARNs illustré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 à états. 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 à états. 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 à états
<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 erreurs éventuelles.

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 à états et sa sortie d'exécution, choisissez **Entrée et sortie d'exécution** dans la section *[Résumé de l'exécution](concepts-view-execution-details.md#exec-details-intf-exec-summ)*.

1. Si l'exécution de votre machine à états a échoué, choisissez **Cause** ou **Afficher le détail de l'étape** dans le message d'erreur. Les détails de l'erreur sont affichés dans la section *[Détails de l'étape](concepts-view-execution-details.md#exec-details-intf-step-details)*. Notez que l'étape à l'origine de l'erreur, à savoir un `Task` état nommé **GetListofFruits**, est surlignée dans la **vue graphique** et dans la **vue Tableau**.
**Note**  
**Étant donné que l'**GetListofFruits**étape est définie dans un `Map` état et qu'elle n'a pas réussi à s'exécuter, l'étape `Map` État de l'état est affichée comme **ayant échoué**.**

## É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 :

### **Affichage graphique** — Basculer entre les différentes itérations `Map` d'état
<a name="graph-view-see-map-state-iterations"></a>

Si l'état de votre **carte** comporte cinq itérations et que vous souhaitez consulter 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 le **visualiseur 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 **\$12** 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 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 être exécutées ou ont été arrêtées alors qu'elles étaient abandonnées, vous pouvez consulter les détails de l'itération échouée. Pour voir ces détails, choisissez les numéros d'itération concernés sous **Echec** ou **Abandonné** dans la liste déroulante.

### **Affichage sous forme de tableau** — Basculer entre différentes itérations `Map` d'états
<a name="table-view-see-map-state-iterations"></a>

Si l'état de votre **carte** comporte cinq itérations et que vous souhaitez consulter les détails d'exécution des 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'affichage en arborescence des itérations d'`Map`état, choisissez la ligne d'itération nommée **\$12** pour l'itération numéro trois. De même, choisissez la ligne nommée **\$13** pour l'itération numéro quatre.

### **Affichage sous forme de 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**.

### **Affichage sous forme de tableau** — Filtrez les résultats
<a name="table-view-filter-results"></a>

Limitez la quantité d'informations affichées en appliquant un ou plusieurs filtres basés sur une propriété, telle que le **statut**, ou 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 rechercher par mot clé**, puis sélectionnez **État** sous **Propriétés**.

1. Sous **Opérateurs**, sélectionnez **Status =**.

1. Choisissez **Status = Echec**.

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

### **Affichage des événements** — Filtrez les résultats
<a name="event-view-filter-results"></a>

Limitez la quantité d'informations affichées en appliquant un ou plusieurs filtres basés sur 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 rechercher par mot clé**, puis sélectionnez **Type** sous **Propriétés**.

1. Sous **Opérateurs**, sélectionnez **Type =**.

1. Choisissez **Type = TaskFailed**.

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

### **Vue des événements** — Inspecter les détails d'un **TaskFailed**événement
<a name="event-view-inspect-failed-task-details"></a>

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