Qu'est-ce que le traçage distribué ?

Le traçage distribué consiste à observer les demandes de données au fur et à mesure qu'elles transitent par un système distribué. L'architecture moderne des microservices comporte souvent plusieurs petits composants indépendants. Ces composants communiquent et échangent des données en permanence à l'aide d'API pour effectuer des tâches complexes. Grâce au traçage distribué, les développeurs peuvent tracer ou suivre visuellement le chemin des requêtes entre différents microservices. Cette visibilité permet de résoudre des erreurs, de corriger des bugs et de traiter des problèmes de performances.

Quels sont les avantages du traçage distribué ?

Les développeurs de logiciels peuvent implémenter des systèmes de suivi distribués dans presque tous les environnements natifs du cloud, ainsi qu'enregistrer les traces distribuées générées par les applications cloud. De plus, les outils de traçage prennent en charge de nombreux langages de programmation et piles de logiciels, ce qui permet aux équipes logicielles de surveiller et de collecter des données de performance pour différentes applications sur la même plateforme. 

Les équipes de développement utilisent le traçage distribué pour améliorer l'observabilité et résoudre les problèmes de performances que les outils classiques de débogage et de surveillance des logiciels ne peuvent pas résoudre. 

Voici d'autres avantages du traçage distribué.

Accélérez le dépannage des logiciels

Les applications modernes s'appuient sur de nombreux microservices pour échanger des données et répondre aux demandes de service sur des systèmes distribués. La résolution des problèmes de performances dans une architecture basée sur des microservices est nettement plus complexe que dans une application logicielle monolithique. Contrairement à une application monolithique, la cause première d'un problème logiciel spécifique peut ne pas être apparente : le chevauchement et les interactions complexes entre plusieurs modules logiciels peuvent compliquer le diagnostic des problèmes. 

Grâce au traçage distribué, les équipes logicielles peuvent surveiller les données qui empruntent des chemins complexes reliant divers microservices et systèmes de stockage de données. À l'aide d'outils de traçage distribués, les équipes logicielles suivent les demandes et visualisent les chemins de propagation des données avec précision. Les équipes logicielles peuvent résoudre rapidement les problèmes de performance et minimiser les interruptions de service. 

Améliorez la collaboration entre développeurs

Plusieurs développeurs sont souvent impliqués dans la création d'une application cloud, chacun étant responsable d'un ou de plusieurs microservices. Le processus de développement logiciel ralentit si les développeurs ne peuvent pas suivre les données échangées par les microservices. Grâce aux systèmes de traçage distribués, les développeurs peuvent collaborer en fournissant des données de télémétrie, telles que des journaux et des traces, pour chaque demande de service effectuée par le microservice. Les développeurs peuvent réagir avec précision aux bogues et autres problèmes logiciels découverts lors des tests et de la production. 

Réduction des délais de commercialisation

Les organisations qui déploient des plateformes de traçage distribuées peuvent rationaliser et accélérer les efforts de mise à disposition d'applications logicielles destinées aux utilisateurs finaux. Les équipes logicielles examinent les traces distribuées pour obtenir des informations qui accélèrent le développement logiciel, minimisent les coûts de développement, comprennent les comportements des utilisateurs et améliorent la préparation au marché. 

Quels sont les différents types de traçage distribué ?

Les équipes logicielles utilisent des outils de suivi distribués pour surveiller, analyser et optimiser les applications.

Suivi du code

Le traçage de code est un processus logiciel qui inspecte le flux de codes sources dans une application lors de l'exécution d'une fonction spécifique. Il aide les développeurs à comprendre le flux logique du code et à identifier les problèmes inconnus. Par exemple, les développeurs utilisent le suivi du code pour vérifier que la demande de service a appelé des étapes pour interroger une base de données. Si certaines fonctions du logiciel ne répondent pas, le système de suivi collectera l'état d'erreur approprié et attirera l'attention sur le temps de réponse. 

Suivi des programmes

Le suivi des programmes est une méthode qui permet aux développeurs d'examiner les adresses des instructions et des variables appelées par une application active. Lorsqu'une application logicielle s'exécute, elle traite chaque ligne de code qui se trouve dans un espace mémoire alloué spécifique. L'application traite également les variables stockées dans la mémoire de la machine. L'inspection des modifications apportées aux programmes et aux mémoires de données est un véritable défi sans outil automatisé. Grâce au suivi des programmes, les équipes logicielles peuvent diagnostiquer des problèmes de performance profondément enracinés tels que le débordement de mémoire, la consommation excessive de ressources et le blocage des opérations logiques. 

Suivi de bout en bout

Grâce au suivi de bout en bout, les équipes de développement peuvent suivre la transformation des données tout au long du processus de demande de service. Lorsqu'une application lance une demande, elle envoie des données à d'autres composants logiciels pour un traitement ultérieur. Les développeurs utilisent des outils de suivi pour suivre et compiler les modifications que subissent les données critiques de bout en bout. Il fournit une vue centrée sur l'application des demandes qui transitent par l'application.

Comment fonctionne le traçage distribué de bout en bout dans une architecture de microservices ?

Lors de l'utilisation d'applications, les utilisateurs lancent des demandes de service et les différents composants de l'application traitent la demande. 

Prenons l'exemple d'un utilisateur effectuant une réservation de billets dans une application de réservation de films en ligne. L'utilisateur saisit ses coordonnées, les détails du film et les informations de paiement et choisit Réserver maintenant. Une demande est créée qui va à :

  • Microservice A qui valide les données saisies par l'utilisateur.
  • Microservice B qui extrait les données de A et crée un enregistrement dans la base de données clients.
  • Microservice C qui extrait les données de B et valide le paiement.
  • Microservice D qui extrait les données de C, attribue un siège et génère des données sur les billets de cinéma.
  • Microservice E qui extrait les données de D et crée un fichier PDF de ticket formaté.

Une réponse contenant le ticket PDF est ensuite renvoyée dans la chaîne de microservices de E à D à C et de B à A, jusqu'à ce qu'elle parvienne finalement à l'utilisateur. L'exemple ci-dessus est simple : une demande passe souvent par plusieurs dizaines de microservices et même par des chaînes de composants logiciels tiers extérieurs à l'application. Cela rend le processus de plus en plus complexe.

Les systèmes de suivi distribués suivent ces interactions des demandes de service avec d'autres microservices et composants logiciels dans l'environnement informatique distribué. Une trace distribuée représente la chronologie et toutes les actions qui se produisent entre la génération de la demande et la réception de la réponse. Les équipes logicielles utilisent la trace pour suivre le mouvement des données via plusieurs microservices avec lesquels la demande initiale interagit. 

Span

Lors du traitement d'une demande de service, une application peut effectuer plusieurs actions. Ces actions sont représentées sous forme de plages dans le suivi distribué. Par exemple, un span peut être un appel d'API, une authentification utilisateur ou l'activation de l'accès au stockage. Si une seule demande entraîne plusieurs actions, la plage initiale (ou parente) peut être divisée en plusieurs plages enfants. Ces couches imbriquées de plages parent-enfant constituent une représentation logique continue des étapes suivies pour répondre à la demande de service.

ID de trace

Le système de suivi distribué attribue un identifiant unique à chaque demande afin d'en assurer le suivi. Chaque span hérite du même identifiant de trace que celui de la demande d'origine à laquelle il appartient. Les intervalles sont également marqués avec un identifiant de plage unique qui permet au système de suivi de consolider les métadonnées, les journaux et les mesures qu'il collecte. 

Collection métrique

Au fur et à mesure que chaque intervalle passe par différents microservices, il ajoute des métriques qui fournissent aux développeurs des informations détaillées et précises sur le comportement du logiciel. Vous pouvez collecter le taux d'erreur, l'horodatage, le temps de réponse et d'autres métadonnées avec les intervalles. Une fois que le suivi a terminé un cycle complet, l'outil de suivi distribué consolide toutes les données collectées. 

Par exemple, un appel d'API est évalué en fonction du temps de réponse, de l'état d'erreur et de la répartition des fonctions secondaires exécutées par plusieurs services tiers. L'outil de suivi transforme les données en formes visuelles, mettant en évidence les indicateurs clés et les résumés des performances. Les ingénieurs en fiabilité des sites peuvent ainsi identifier rapidement les erreurs, inspecter les éléments de données critiques et collaborer avec les équipes de développement pour résoudre les problèmes de performance et garantir la conformité aux accords de niveau de service (SLA).

Que sont les normes de traçage distribué ?

Les normes de traçage distribué fournissent un cadre et des outils logiciels communs aux développeurs. Ces normes surveillent, visualisent et analysent les demandes de service dans les environnements applicatifs modernes. En normalisant le flux de travail de suivi distribué, les équipes logicielles peuvent instrumenter le suivi des demandes sans être soumises à une dépendance vis-à-vis d'un fournisseur. 

Les sections suivantes décrivent les normes introduites pour permettre l'interopérabilité lors de l'exécution du traçage distribué.

Ouvrir traçaget

OpenTracing est une norme de traçage distribué open source développée par la Cloud Native Computing Foundation (CNCF). OpenTracing vise à permettre aux développeurs de générer des traces à l'aide d'une API d'instrumentation. Cela permet aux développeurs de générer des traces distribuées à partir de différentes parties de la base de code, de la bibliothèque ou d'autres dépendances.

Recensement ouvert

OpenCensus se compose de bibliothèques multilingues capables d'extraire des métriques logicielles et de les envoyer aux systèmes dorsaux pour analyse. Les développeurs peuvent utiliser l'API fournie pour gérer la manière dont les traces sont générées et collectées. Contrairement à OpenTracing, les développeurs travaillent avec OpenCensus à partir d'un référentiel de projet unique au lieu de bases de code et de bibliothèques individuelles. 

Télémétrie ouverte

OpenTelemetry unifie OpenTracing et OpenCensus. Il combine les meilleures fonctionnalités des deux normes pour fournir un cadre de suivi distribué complet. OpenTelemetry fournit de nombreux kits de développement logiciel, des API, des bibliothèques et d'autres outils d'instrumentation permettant de mettre en œuvre le traçage distribué plus facilement. 

Quelle est la différence entre le suivi distribué et la journalisation ?

La journalisation est une pratique qui consiste à enregistrer des événements spécifiques qui se produisent lors de l'exécution d'une application. Les outils de journalisation collectent des événements horodatés, tels que les erreurs système, les interactions avec les utilisateurs, l'état des communications et d'autres indicateurs, afin d'aider les équipes de développement à détecter les anomalies du système. En général, il existe deux types de journalisation : 

  • La journalisation centralisée collecte toutes les activités enregistrées et les stocke en un seul endroit.
  • La journalisation distribuée stocke les fichiers journaux dans des emplacements distincts sur le cloud. 

Les deux méthodes de journalisation fournissent un aperçu statique des incidents qui montrent aux développeurs ce qui s'est passé dans l'application. En revanche, le suivi distribué fournit une piste d'audit qui explique pourquoi un incident s'est produit en corrélant les différentes données de télémétrie collectées tout au long de la période d'une demande de service. Le suivi distribué peut utiliser la journalisation et d'autres méthodes de collecte de données pour suivre une demande de service spécifique. 

Quels sont les défis du traçage distribué ?

Le traçage distribué a simplifié les efforts des développeurs en matière de diagnostic, de débogage et de résolution des problèmes logiciels. Malgré cela, les équipes logicielles doivent toujours tenir compte des défis suivants lorsqu'elles choisissent des outils de traçage.

Instrumentation manuelle

Certains outils de traçage obligent les équipes logicielles à instrumenter manuellement leurs codes pour générer les traces nécessaires. Lorsque les développeurs modifient des codes pour suivre les demandes, des erreurs de codage risquent d'affecter les versions de production. En outre, le manque d'automatisation complique le traçage, ce qui entraîne des retards et peut être une collecte de données inexacte. 

Couverture frontale limitée

Les développeurs peuvent ne pas être en mesure de contrôler complètement les problèmes de performances si leurs outils de suivi se limitent à l'analyse du backend. Dans certains cas, le système de suivi distribué ne commence à collecter des données que lorsque le premier service principal reçoit la demande. Cela signifie que les développeurs ne peuvent pas détecter et inspecter les problèmes liés aux services frontaux au cours de la session utilisateur correspondante.

Échantillonnage aléatoire

Certains outils ne permettent pas aux équipes logicielles de hiérarchiser le traçage, ce qui limite l'observabilité aux traces échantillonnées de manière aléatoire. Avec des échantillons de données limités, les entreprises ont besoin d'approches de dépannage logiciel supplémentaires pour détecter les problèmes majeurs qui échappent à l'outil de suivi. 

Comment AWS peut-il vous aider à répondre à vos besoins en matière de traçage distribué ?

AWS X-Ray est une plateforme de suivi distribuée qui aide les développeurs de logiciels à suivre les demandes des utilisateurs et à identifier les goulots d'étranglement dans leurs applications cloud. Les entreprises utilisent X-Ray pour visualiser les indicateurs des applications et améliorer la disponibilité des charges de travail. Avec AWS X-Ray, vous pouvez :

Commencez à utiliser le traçage distribué sur AWS en créant un compte dès aujourd'hui.

Prochaines étapes sur AWS

Créer gratuitement un compte

Obtenez un accès instantané à l'offre gratuite AWS.

S'inscrire 
Commencez à créer sur la console

Démarrez la création dans la console de gestion AWS.

Se connecter