Afficher les X-Ray traces dans Step Functions

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/ l'adresse.

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

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

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

5. Choisissez une ou plusieurs stratégies d'autorisation à attacher au rôle (par exemple, AWSLambdaBasicExecutionRole). Consultez Modèle d'autorisations AWS Lambda.

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

6. Entrez un nom de rôle.

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

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

1. Ouvrez la console Lambda et choisissez Créer une fonction.

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

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

   1. Sous Nom de la fonction, saisissez TestFunction1.

   2. Pour Runtime, choisissez Node.js 18.x.

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

   4. Pour Rôle existant, sélectionnez le rôle Lambda que vous avez créé précédemment.

      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.

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

4. Copiez le code suivant pour la fonction Lambda dans la section Code de fonction de la TestFunction1 page.

   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.

5. Choisissez Enregistrer.

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

2. Dans la console Lambda, vérifiez que vous disposez désormais de trois fonctions Lambda, TestFunction1TestFunction2, et. TestFunction3

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

2. Choisissez Créer à partir du vide.

3. Donnez un nom à votre machine à états, puis choisissez Continuer pour modifier votre machine à états dans Workflow Studio.

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

   {
     "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ésCallTestFunction1, CallTestFunction2 etCallTestFunction3. Chacune appelle l'une de vos trois fonctions Lambda. Pour plus d'informations, consultez Structure de la machine d'état.

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

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

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

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

   La page Nouvelle exécution s'affiche.

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

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

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

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

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

4. 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. TestFunction2a été appelé plus souvent queTestFunction3, et TestFunction1 a été appelé plus de deux fois plus souvent queTestFunction2.

   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é)

   

   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.

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

   

   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