

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.

# Afficher les X-Ray traces dans Step Functions

Dans ce didacticiel, vous allez apprendre à suivre les erreurs qui se produisent lors de l'exécution d'une machine à états. X-Ray Vous pouvez les utiliser [AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) pour visualiser les composants de votre machine à états, identifier les goulots d'étranglement en matière de performances et résoudre les demandes qui ont entraîné une erreur. Dans ce didacticiel, vous allez créer plusieurs fonctions Lambda qui génèrent des erreurs de manière aléatoire, que vous pourrez ensuite tracer et analyser. X-Ray

Le [Création d'une machine d'états Step Functions qui utilise Lambda](tutorial-creating-lambda-state-machine.md) didacticiel explique comment créer une machine à états qui appelle une fonction Lambda. Si vous avez terminé ce didacticiel, passez à l'[étape 2 ](#create-xray-lambda-state-machine-step-4) et utilisez le rôle Gestion des identités et des accès AWS (IAM) que vous avez créé précédemment.

## Étape 1 : Création d'un rôle IAM pour Lambda
<a name="create-xray-lambda-state-machine-step-1"></a>

Les deux AWS Lambda AWS Step Functions peuvent exécuter du code et accéder à AWS des ressources (par exemple, des données stockées dans des compartiments Amazon S3). Pour garantir la sécurité, vous devez autoriser Lambda et Step Functions à accéder à ces ressources.

Lambda vous oblige à attribuer un rôle Gestion des identités et des accès AWS (IAM) lorsque vous créez une fonction Lambda, de la même manière que Step Functions vous demande d'attribuer un rôle IAM lorsque vous créez une machine à états.

### Pour créer un rôle à utiliser avec Lambda
<a name="create-xray-lambda-state-machine-to-create-a-role-for-use-with-lambda"></a>

Vous utilisez la console IAM pour créer un rôle lié à un service.

**Pour créer un rôle (console)**

1. Connectez-vous au Console de gestion AWS et ouvrez la console IAM à [ https://console.aws.amazon.com/iam/ ](https://console.aws.amazon.com/iam/) l'adresse.

1. Dans le panneau de navigation de la console IAM, choisissez **Rôles**. Puis choisissez **Create role (Créer un rôle)**.

1. Choisissez le type **AWS de ** rôle de service, puis choisissez ** Lambda**.

1. Choisissez le cas d'**utilisation ** Lambda. Les cas d'utilisation sont définis par le service pour inclure la politique d'approbation requise par le service. Choisissez ensuite **Suivant : Autorisations**.

1. Choisissez une ou plusieurs stratégies d'autorisation à attacher au rôle (par exemple, `AWSLambdaBasicExecutionRole`). Consultez [Modèle d'autorisations AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html).

    Cochez la case en regard de la stratégie qui affecte les autorisations que vous voulez octroyer au rôle, puis choisissez **Next: Review**.

1. Entrez un **nom de rôle**.

1. (Facultatif) Dans le champ **Description du rôle**, modifiez la description du nouveau rôle lié à un service.

1. Passez en revue les informations du rôle, puis choisissez **Create role** (Créer un rôle).

## Étape 2 : création d’une fonction Lambda
<a name="create-xray-lambda-state-machine-step-2"></a>

Votre fonction Lambda génère des erreurs ou un délai d'expiration de manière aléatoire, produisant des exemples de données à X-Ray afficher.

**Important**  
Assurez-vous que votre fonction Lambda se trouve sous le même AWS compte et Région AWS que votre machine d'état.

1. Ouvrez la console [ Lambda ](https://console.aws.amazon.com/lambda/home) et choisissez ** Créer une fonction. **

1. Dans la section **Créer une fonction**, choisissez **Créer à partir de zéro**.

1. Dans la ** section Informations ** de base, configurez votre fonction Lambda :

   1. Sous **Nom de la fonction**, saisissez `TestFunction1`.

   1. Pour ** Runtime**, choisissez ** Node.js 18.x**.

   1. Pour **Rôle**, sélectionnez **Choisir un rôle existant**.

   1. Pour Rôle ** existant**, sélectionnez [ le rôle Lambda que vous avez créé précédemment](#create-xray-lambda-state-machine-to-create-a-role-for-use-with-lambda).
**Note**  
Si le rôle IAM que vous avez créé n'apparaît pas dans la liste, il se peut qu'il ait encore besoin de quelques minutes pour être propagé à Lambda.

   1. Choisissez **Créer une fonction**.

      Une fois que Lambda a créé votre fonction, notez son Amazon Resource Name (ARN) affiché sur la page. Par exemple :

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

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

   ```javascript
   function getRandomSeconds(max) {
       return Math.floor(Math.random() * Math.floor(max)) * 1000;
   }
   function sleep(ms) {
       return new Promise(resolve => setTimeout(resolve, ms));
   }
   export const handler = async (event) => {
       if(getRandomSeconds(4) === 0) {
           throw new Error("Something went wrong!");
       }   
       let wait_time = getRandomSeconds(5);
       await sleep(wait_time);
       return { 'response': true }
   };
   ```

   Ce code crée des défaillances chronométrées de manière aléatoire, qui seront utilisées pour générer des exemples d'erreurs dans votre machine à états qui peuvent être visualisés et analysés à l'aide de X-Ray traces.

1. Choisissez **Enregistrer**.

## Étape 3 : Création de deux autres fonctions Lambda
<a name="create-xray-lambda-state-machine-step-3"></a>

Créez deux autres fonctions Lambda.

1. Répétez l'étape 2 pour créer deux autres fonctions Lambda. Pour la fonction suivante, dans Nom de ** la fonction**, entrez`TestFunction2`. Pour la dernière fonction, dans Nom de ** la fonction**, entrez`TestFunction3`.

1. Dans la console Lambda, vérifiez que vous disposez désormais de trois fonctions Lambda, `TestFunction1``TestFunction2`, et. `TestFunction3`

## Étape 4 : Création d'une machine à états
<a name="create-xray-lambda-state-machine-step-4"></a>

Au cours de cette étape, vous allez utiliser la console [ Step Functions ](https://console.aws.amazon.com/states/home?region=us-east-1#/) pour créer une machine à états avec trois `Task` états. Chaque `Task` état fera référence à l'une de vos trois fonctions Lambda. 

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 2 ](#create-xray-lambda-state-machine-step-2) et [ 3](#create-xray-lambda-state-machine-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. Dans la définition de l'état de la tâche, n'oubliez pas de remplacer les exemples d'ARN par les ARN des fonctions Lambda que vous avez créées.

   ```json
   {
     "StartAt": "CallTestFunction1",
     "States": {
       "CallTestFunction1": {
         "Type": "Task",
         "Resource": "{{arn:aws:lambda:{{region}}:123456789012:function:test-function1}}",
         "Catch": [
           {
             "ErrorEquals": [
               "States.TaskFailed"
             ],
             "Next": "AfterTaskFailed"
           }
         ],
         "Next": "CallTestFunction2"
       },
       "CallTestFunction2": {
         "Type": "Task",
         "Resource": "{{arn:aws:lambda:{{region}}:123456789012:function:test-function2}}",
         "Catch": [
           {
             "ErrorEquals": [
               "States.TaskFailed"
             ],
             "Next": "AfterTaskFailed"
           }
         ],
         "Next": "CallTestFunction3"
       },
       "CallTestFunction3": {
         "Type": "Task",
         "Resource": "{{arn:aws:lambda:{{region}}:123456789012:function:test-function3}}",
         "TimeoutSeconds": 5,
         "Catch": [
           {
             "ErrorEquals": [
               "States.Timeout"
             ],
             "Next": "AfterTimeout"
           },
           {
             "ErrorEquals": [
               "States.TaskFailed"
             ],
             "Next": "AfterTaskFailed"
           }
         ],
         "Next": "Succeed"
       },
       "Succeed": {
         "Type": "Succeed"
       },
       "AfterTimeout": {
         "Type": "Fail"
       },
       "AfterTaskFailed": {
         "Type": "Fail"
       }
     }
   }
   ```

   Il s'agit d'une description de votre machine à états en utilisant le langage Amazon States. Il définit trois `Task` états nommés`CallTestFunction1`, `CallTestFunction2` et`CallTestFunction3`. Chacune appelle l'une de vos trois fonctions Lambda. Pour plus d'informations, consultez [Structure de la machine d'état](statemachine-structure.md).

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 **TraceFunctions**.

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, sous Configuration ** supplémentaire**, choisissez ** Activer le X-Ray suivi**. Conservez toutes les autres sélections par défaut dans ** State Machine settings**.

   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. 

## Étape 5 : Exécutez la machine d'état
<a name="create-xray-lambda-state-machine-step-5"></a>

Les exécutions de State Machine sont des instances dans lesquelles vous exécutez votre flux de travail pour effectuer des tâches.

1. Sur la ** {{TraceFunctions}} ** page, choisissez ** Commencer l'exécution**.

   La page **Nouvelle 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. 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).

      Exécutez plusieurs (au moins trois) exécutions.

1. Une fois les exécutions terminées, suivez le ** lien de la carte de ** X-Ray trace. Vous pouvez consulter la trace alors qu'une exécution est toujours en cours d'exécution, mais vous souhaiterez peut-être consulter les résultats de l'exécution avant de consulter la carte de X-Ray trace.

1. Consultez la carte des services pour identifier les endroits où les erreurs se produisent, les connexions à latence élevée ou les traces des demandes qui n'ont pas abouti. Dans cet exemple, vous pouvez voir le volume de trafic reçu par chaque fonction. `TestFunction2`a été appelé plus souvent que`TestFunction3`, et `TestFunction1` a été appelé plus de deux fois plus souvent que`TestFunction2`.

   La cartographie des services indique l'état de chaque nœud en lui appliquant une couleur déterminée par le rapport entre le nombre d'appels réussis et le nombre d'erreurs ou d'échecs:
   +  **Vert** pour les appels réussis 
   +  **Rouge** pour les erreurs serveur (erreurs de type 500) 
   +  **Jaune** pour les erreurs client (erreurs de type 400) 
   +  **Violet** pour les erreurs de limitation (erreur 429, nombre de requêtes trop élevé)   
![Exemple de capture d'écran illustratif de nœuds de X-Ray trace pour trois fonctions de test.](https://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/tutorial-xray-service.png)

   Vous pouvez également choisir un nœud de service pour afficher les demandes pour ce nœud, ou un bord entre deux nœuds pour afficher les demandes qui ont transité par cette connexion. 

1. Consultez la carte de X-Ray suivi pour voir ce qui s'est passé pour chaque exécution. La vue chronologique affiche une hiérarchie de segments et de sous-segments. La première entrée de la liste est le segment, qui représente toutes les données enregistrées par le service pour une seule demande. Sous le segment se trouvent les sous-segments. Cet exemple montre les sous-segments enregistrés par les fonctions Lambda.  
![Exemple de capture d'écran illustratif de segments et de sous-segments de X-Ray chronologie pour les fonctions de test.](https://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/tutorial-xray-trace.png)

   Pour plus d'informations sur la compréhension X-Ray des traces et leur utilisation X-Ray avec Step Functions, consultez le [Les données demandées par Trace Step Functions dans AWS X-Ray](concepts-xray-tracing.md) 