Migration de l'instrumentation X-Ray vers l' OpenTelemetry instrumentation - AWS X-Ray
Compréhension OpenTelemetryComprendre les OpenTelemetry concepts relatifs à la migrationPrésentation de la migrationMigration de X-Ray Daemon vers un AWS CloudWatch agent ou un collecteur OpenTelemetry

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.

Migration de l'instrumentation X-Ray vers l' OpenTelemetry instrumentation

X-Ray est en train de devenir OpenTelemetry (OTel) sa principale norme d'instrumentation pour le suivi et l'observabilité des applications. Ce changement stratégique s'aligne sur les AWS meilleures pratiques du secteur et offre aux clients une solution plus complète, flexible et tournée vers l'avenir pour répondre à leurs besoins en matière d'observabilité. OpenTelemetry, largement adoptée dans le secteur, permet de suivre les demandes sur divers systèmes, y compris ceux extérieurs AWS qui peuvent ne pas s'intégrer directement à X-Ray.

Ce chapitre fournit des recommandations pour une transition en douceur et souligne l'importance de migrer vers des solutions OpenTelemetry basées pour garantir un support continu et un accès aux dernières fonctionnalités en matière d'instrumentation et d'observabilité des applications.

Il est recommandé de l'adopter OpenTelemetry comme solution d'observabilité pour l'instrumentation de votre application.

Rubriques

Compréhension OpenTelemetry

OpenTelemetry est un cadre d'observabilité standard qui fournit des protocoles et des outils standardisés pour la collecte de données de télémétrie. Il propose une approche unifiée pour l'instrumentation, la génération, la collecte et l'exportation de données de télémétrie telles que les métriques, les journaux et les traces.

Lorsque vous migrez de X-Ray SDKs vers OpenTelemetry, vous bénéficiez des avantages suivants :

  • Support amélioré du framework et de l'instrumentation de bibliothèque

  • Support pour d'autres langages de programmation

  • Capacités d'instrumentation automatique

  • Options de configuration d'échantillonnage flexibles

  • Collecte unifiée de métriques, de journaux et de traces

Le OpenTelemetry collecteur offre davantage d'options pour les formats de collecte de données et les destinations d'exportation que le daemon X-Ray.

OpenTelemetry soutien dans AWS

AWS propose plusieurs solutions pour travailler avec OpenTelemetry :

  • AWS Distro pour OpenTelemetry

    Exportez OpenTelemetry les traces sous forme de segments vers X-Ray.

    Pour plus d'informations, consultez AWS Distro for OpenTelemetry.

  • CloudWatch Signaux d'application

    Exportez OpenTelemetry des traces et des métriques personnalisées pour surveiller l'état de santé des applications.

    Pour plus d'informations, consultez la section Utilisation des signaux d'application.

  • CloudWatch OTel Point final

    Exportez OpenTelemetry les traces vers X-Ray à l'aide du point de OTel terminaison HTTP avec une OpenTelemetry instrumentation native.

    Pour plus d'informations, consultez la section Utilisation des OTel points de terminaison.

Utilisation OpenTelemetry avec AWS CloudWatch

AWS CloudWatch prend en charge les OpenTelemetry traces via l'instrumentation des applications côté client et les AWS CloudWatch services natifs tels que les signaux d'application, les traces, les cartes, les métriques et les journaux. Pour de plus amples informations, veuillez consulter OpenTelemetry.

Comprendre les OpenTelemetry concepts relatifs à la migration

Le tableau suivant fait correspondre les concepts X-Ray à leurs OpenTelemetry équivalents. La compréhension de ces mappages vous permet de traduire votre instrumentation X-Ray existante en OpenTelemetry :

Concept X-Ray OpenTelemetry concept
Enregistreur X-Ray Fournisseur de traceurs et traceurs
Plug-ins de service Détecteur de ressources
Segment Espagne (serveur)
Sous-segment Span (hors serveur)
Règles d'échantillonnage aux rayons X OpenTelemetry Échantillonnage (personnalisable)
Émetteur de rayons X Span Exporter (personnalisable)
Annotations/Métadonnées Attributs
Instrumentation de bibliothèque Instrumentation de bibliothèque
Contexte de X-Ray Trace Contexte Span
Propagation du contexte de X-Ray Trace Propagation du contexte de trace du W3C
Échantillonnage de traces par rayons X OpenTelemetry échantillonnage de traces
N/A Traitement Span
N/A Bagages
Démon X-Ray OpenTelemetry Collectionneur
Note

Pour plus d'informations sur OpenTelemetry les concepts, consultez la OpenTelemetry documentation.

Comparaison des fonctionnalités

Le tableau suivant indique les fonctionnalités prises en charge dans les deux services. Utilisez ces informations pour identifier les lacunes que vous devez combler lors de la migration :

Fonctionnalité Instrumentation X-Ray OpenTelemetry instrumentation
Instrumentation de bibliothèque Pris en charge Pris en charge
Échantillonnage aux rayons X Pris en charge

Pris en charge dans OTel Java/.net/GO

Pris en charge dans ADOT Java/. NET/Python/Node.js
Propagation du contexte de X-Ray Trace Pris en charge Pris en charge
Détection des ressources Pris en charge Pris en charge
Annotations de segments Pris en charge Pris en charge
Métadonnées du segment Pris en charge Pris en charge
Instrumentation automatique à code zéro Pris en charge en Java

Pris en charge en OTel Java/. NET/Python/Node.js

Pris en charge dans ADOT Java/. NET/Python/Node.js
Création manuelle de traces Pris en charge Pris en charge

Configuration et configuration du suivi

Pour créer des traces dans OpenTelemetry, vous avez besoin d'un traceur. Vous obtenez un traceur en initialisant un fournisseur de traceurs dans votre application. Cela est similaire à la façon dont vous utilisez le X-Ray Recorder pour configurer X-Ray et créer des segments et des sous-segments dans un X-Ray Trace.

Note

Le OpenTelemetry Tracer Provider propose davantage d'options de configuration que le X-Ray Recorder.

Comprendre la structure des données de trace

Après avoir compris les concepts de base et les mappages de fonctionnalités, vous pouvez en apprendre davantage sur les détails de mise en œuvre spécifiques tels que la structure des données de trace et l'échantillonnage.

OpenTelemetry utilise des étendues plutôt que des segments et des sous-segments pour structurer les données de suivi. Chaque travée inclut les composants suivants :

  • Nom

  • Identifiant unique

  • Horodatages de début et de fin

  • Type d'envergure

  • Contexte de Span

  • Attributs (métadonnées clé-valeur)

  • Événements (journaux horodatés)

  • Liens vers d'autres spans

  • Informations sur le statut

  • Références relatives à l'espace parent

Lorsque vous migrez vers OpenTelemetry, vos travées sont automatiquement converties en segments ou sous-segments X-Ray. Cela garantit que votre expérience de CloudWatch console existante reste inchangée.

Utilisation des attributs span

Le SDK X-Ray propose deux méthodes pour ajouter des données aux segments et sous-segments :

Annotations

Paires clé-valeur indexées pour le filtrage et la recherche

Métadonnées

Paires clé-valeur contenant des données complexes qui ne sont pas indexées pour la recherche

Par défaut, les attributs OpenTelemetry span sont convertis en métadonnées dans les données brutes de X-Ray. Pour convertir des attributs spécifiques en annotations, ajoutez leurs clés à la liste des aws.xray.annotations attributs.

Détecter les ressources dans votre environnement

OpenTelemetry utilise des détecteurs de ressources pour collecter des métadonnées sur les ressources qui génèrent des données de télémétrie. Ces métadonnées sont stockées sous forme d'attributs de ressource. Par exemple, une entité produisant de la télémétrie peut être un cluster Amazon ECS ou une EC2 instance Amazon, et les attributs de ressources qui peuvent être enregistrés à partir de ces entités peuvent inclure l'ARN du cluster Amazon ECS ou l'ID d' EC2 instance Amazon.

Gestion des stratégies d'échantillonnage

L'échantillonnage de traces vous aide à gérer les coûts en collectant des données à partir d'un sous-ensemble représentatif de demandes plutôt que de toutes les demandes. Les deux, OpenTelemetry ainsi que X-Ray, prennent en charge l'échantillonnage, mais l'implémentent différemment.

Note

L'échantillonnage de moins de 100 % des traces réduit vos coûts d'observabilité tout en conservant des informations pertinentes sur les performances de votre application.

OpenTelemetry fournit plusieurs stratégies d'échantillonnage intégrées et vous permet de créer des stratégies personnalisées. Vous pouvez également configurer un X-Ray Remote Sampler dans certains langages du SDK pour utiliser les règles d'échantillonnage X-Ray avec. OpenTelemetry

Les stratégies d'échantillonnage supplémentaires OpenTelemetry sont les suivantes :

  • Échantillonnage basé sur les parents — Respecte la décision d'échantillonnage de l'intervalle parent avant d'appliquer des stratégies d'échantillonnage supplémentaires

  • Échantillonnage basé sur le ratio d'identification des traces — >Échantillonne de manière aléatoire un pourcentage spécifié de plages

  • Échantillonnage de la queue — Applique les règles d'échantillonnage pour compléter les traces dans le OpenTelemetry collecteur

  • Échantillonneurs personnalisés — Implémentez votre propre logique d'échantillonnage à l'aide de l'interface d'échantillonnage

Pour plus d'informations sur les règles d'échantillonnage X-Ray, voir Règles d'échantillonnage dans la console X-Ray

Pour plus d'informations sur l'échantillonnage de OpenTelemetry la queue, voir Processeur d'échantillonnage de la queue

Gestion du contexte de suivi

X-Ray SDKs gère le contexte du segment pour gérer correctement les relations parent-enfant entre les segments et les sous-segments d'une trace. OpenTelemetry utilise un mécanisme similaire pour s'assurer que les travées ont la bonne étendue parent. Il stocke et propage les données de suivi dans un contexte de demande. Par exemple, lorsque votre application traite une demande et crée un intervalle de serveur pour représenter cette demande, OpenTelemetry elle stocke l'intervalle de serveur dans le OpenTelemetry contexte afin que, lorsqu'un intervalle enfant est créé, celui-ci puisse faire référence à l'intervalle du contexte en tant que parent.

Propagation du contexte de trace

X-Ray et OpenTelemetry Use utilisent les en-têtes HTTP pour propager le contexte de trace entre les services. Cela vous permet de relier les données de suivi générées par différents services et de conserver les décisions d'échantillonnage.

Le SDK X-Ray propage automatiquement le contexte de trace à l'aide de l'en-tête X-Ray Trace. Lorsqu'un service en appelle un autre, l'en-tête de trace contient le contexte nécessaire pour maintenir les relations parent-enfant entre les traces.

OpenTelemetry prend en charge plusieurs formats d'en-tête de trace pour la propagation du contexte, notamment :

  • Contexte de trace du W3C (par défaut)

  • En-tête X-Ray Trace

  • Autres formats personnalisés

Note

Vous pouvez configurer OpenTelemetry pour utiliser un ou plusieurs formats d'en-tête. Par exemple, utilisez le X-Ray Propagator pour envoyer le contexte de trace aux AWS services qui prennent en charge le X-Ray Propagator.

Configurez et utilisez le X-Ray Propagator pour activer le suivi entre les AWS services. Cela vous permet de propager le contexte de trace aux points de terminaison API Gateway et aux autres services compatibles avec X-Ray.

Utilisation de l'instrumentation de bibliothèque

X-Ray et OpenTelemetry Supply Library Instrumentation qui nécessitent un minimum de modifications de code pour ajouter du traçage à vos applications.

X-Ray fournit des fonctionnalités d'instrumentation de bibliothèque. Cela vous permet d'ajouter des instruments X-Ray prédéfinis avec un minimum de modifications du code d'application. Ces instruments prennent en charge des bibliothèques spécifiques telles que le AWS SDK et les clients HTTP, ainsi que des frameworks Web tels que Spring Boot ou Express.js.

OpenTelemetryles bibliothèques d'instrumentation génèrent des étendues détaillées pour vos bibliothèques par le biais de crochets de bibliothèque ou de modifications automatiques du code, nécessitant un minimum de modifications de code.

Pour déterminer si OpenTelemetry Library Instrumentations prend en charge votre bibliothèque, recherchez-la dans le OpenTelemetry registre à OpenTelemetry Registry.

Exporter des traces

X-Ray et OpenTelemetry utilisez différentes méthodes pour exporter les données de trace.

Exportation de X-Ray Trace

Le X-Ray SDKs utilise un émetteur pour envoyer des données de trace :

  • Envoie des segments et des sous-segments au X-Ray Daemon

  • Utilise le protocole UDP pour des E/S non bloquantes

  • Configuré par défaut dans le SDK

OpenTelemetry exportation de traces

OpenTelemetry utilise des Span Exporters configurables pour envoyer des données de suivi :

  • Utilise les protocoles http/proto.buf ou grpc

  • Les exportations s'étendent vers les points de terminaison surveillés par le OpenTelemetry collecteur ou l'agent CloudWatch

  • Permet des configurations d'exportation personnalisées

Traitement et transmission des traces

X-Ray et OpenTelemetry Supply fournissent des composants pour recevoir, traiter et transmettre les données de suivi.

Traitement des traces X-Ray

Le X-Ray Daemon gère le traitement des traces :

  • Écoute le trafic UDP provenant de X-Ray SDKs

  • Lots, segments et sous-segments

  • Télécharge des lots vers le service X-Ray

OpenTelemetry traitement des traces

Le OpenTelemetry Collector gère le traitement des traces :

  • Reçoit les traces des services instrumentés

  • Traite et modifie éventuellement les données de suivi

  • Envoie les traces traitées à différents backends, y compris X-Ray

Note

L' AWS CloudWatch agent peut également recevoir et envoyer OpenTelemetry des traces à X-Ray. Pour plus d'informations, consultez la section Collecter des métriques et des traces avec OpenTelemetry.

Traitement de l'OpenTelemetryenvergure (concept spécifique)

OpenTelemetry utilise les processeurs Span pour modifier les spans au fur et à mesure de leur création :

  • Permet de lire et de modifier les travées lors de leur création ou de leur achèvement

  • Active une logique personnalisée pour la gestion de l'intervalle

OpenTelemetryBagages (concept spécifique)

OpenTelemetryLa fonction Baggage permet la propagation de données clé-valeur :

  • Permet de transmettre des données arbitraires à côté du contexte de trace

  • Utile pour diffuser des informations spécifiques à une application au-delà des limites des services

Pour plus d'informations sur le OpenTelemetry Collector, voir OpenTelemetry Collector

Pour plus d'informations sur les concepts de X-Ray, voir les concepts de X-Ray dans le X-Ray Developer Guide

Présentation de la migration

Cette section fournit une vue d'ensemble des modifications de code requises pour la migration. La liste ci-dessous contient des instructions spécifiques à la langue et les étapes de migration de X-Ray Daemon.

Important

Pour effectuer une migration complète de l'instrumentation X-Ray vers l' OpenTelemetry instrumentation, vous devez :

  1. Remplacez l'utilisation du SDK X-Ray par une solution OpenTelemetry

  2. Remplacez le daemon X-Ray par l' CloudWatch agent ou le OpenTelemetry collecteur (avec X-Ray Exporter)

Recommandations pour les applications nouvelles et existantes

Pour les applications nouvelles et existantes, il est recommandé d'utiliser les solutions suivantes pour activer le suivi dans vos applications :

Instrumentation

  • OpenTelemetry SDKs

  • AWS Distro pour instrumentation OpenTelemetry

Collecte de données

  • OpenTelemetry Collectionneur

  • CloudWatch Agent

Après la migration vers des solutions OpenTelemetry basées, votre CloudWatch expérience restera la même. Vous pourrez toujours consulter vos traces dans le même format sur les pages Traces et Trace Map de la CloudWatch console, ou récupérer vos données de trace via le X-Ray APIs.

Modification de la configuration du suivi

Vous devez remplacer la configuration X-Ray par une OpenTelemetry configuration.

Comparaison entre X-Ray et OpenTelemetry configuration
Fonctionnalité Kit de développement X-Ray OpenTelemetry
Configurations par défaut

  • Échantillonnage centralisé par rayons X

  • Propagation du contexte X-Ray Trace

  • Exportation de traces vers X-Ray Daemon

  • Exportation de traces vers OpenTelemetry Collector ou CloudWatch Agent (HTTP/GRPC)

  • Propagation du contexte de trace du W3C
Configurations manuelles

  • Règles d'échantillonnage locales

  • Plug-ins de détection de ressources

  • X-Ray Sampling (peut ne pas être disponible dans toutes les langues)

  • Détection des ressources

  • Propagation du contexte X-Ray Trace

Modifications apportées aux instruments de bibliothèque

Mettez à jour votre code pour utiliser OpenTelemetry Library Instrumentation au lieu de X-Ray Library Instrumentation pour le AWS SDK, les clients HTTP, les frameworks Web et d'autres bibliothèques. Cela génère OpenTelemetry des Traces au lieu de X-Ray Traces.

Note

Les modifications de code varient en fonction de la langue et de la bibliothèque. Reportez-vous aux guides de migration spécifiques aux langues pour obtenir des instructions détaillées.

Modifications apportées à l'instrumentation de l'environnement Lambda

Pour l'utiliser OpenTelemetry dans vos fonctions Lambda, choisissez l'une des options de configuration suivantes :

  1. Utilisez une couche Lambda d'auto-instrumentation :

  2. Configuration manuelle OpenTelemetry de votre fonction Lambda :

    • Configurer un processeur Simple Span avec un X-Ray UDP Span Exporter

    • Configuration d'un propagateur X-Ray Lambda

Création manuelle de données de trace

Remplacez les segments et sous-segments de X-Ray par des OpenTelemetry Spans :

  • Utiliser un OpenTelemetry traceur pour créer des spans

  • Ajouter des attributs à Spans (équivalent aux métadonnées et aux annotations de X-Ray)

Important

Lorsqu'il est envoyé à X-Ray :

  • Les étendues de serveurs sont converties en segments X-Ray

  • Les autres spans sont convertis en sous-segments X-Ray

  • Les attributs sont convertis en métadonnées par défaut

Pour convertir un attribut en annotation, ajoutez sa clé à la liste des aws.xray.annotations attributs. Pour plus d'informations, voir Activer les annotations X-Ray personnalisées.

Migration de X-Ray Daemon vers un AWS CloudWatch agent ou un collecteur OpenTelemetry

Vous pouvez utiliser l' CloudWatch agent ou le OpenTelemetry collecteur pour recevoir les traces de vos applications instrumentées et les envoyer à X-Ray.

Note

La version 1.300025.0 et les versions ultérieures de l' CloudWatch agent peuvent collecter des traces. OpenTelemetry L'utilisation de l' CloudWatch agent au lieu du X-Ray Daemon réduit le nombre d'agents à gérer. Pour plus d'informations, consultez la section Collecte de métriques, de journaux et de traces avec l' CloudWatch agent.

Migration sur Amazon EC2 ou sur des serveurs sur site

Important

Arrêtez le processus X-Ray Daemon avant d'utiliser l' CloudWatch agent ou le OpenTelemetry collecteur pour éviter les conflits de ports.

Configuration existante de X-Ray Daemon

Installation du daemon

Votre utilisation actuelle de X-Ray Daemon a été installée à l'aide de l'une des méthodes suivantes :

Installation manuelle

Téléchargez et exécutez le fichier exécutable depuis le bucket Amazon S3 du daemon X-Ray.

Installation automatique

Utilisez ce script pour installer le daemon lors du lancement d'une instance :

#!/bin/bash
curl https://s3.us-east-2.amazonaws.com/aws-xray-assets.us-east-2/xray-daemon/aws-xray-daemon-3.x.rpm \
    -o /home/ec2-user/xray.rpm
yum install -y /home/ec2-user/xray.rpm
Configuration du démon

Votre utilisation actuelle de X-Ray Daemon a été configurée à l'aide de l'une des méthodes suivantes :

  • Arguments de ligne de commande

  • Fichier de configuration (xray-daemon.yaml)

Exemple Utilisation d'un fichier de configuration
./xray -c ~/xray-daemon.yaml
Exécution du démon

Votre utilisation actuelle de X-Ray Daemon a été lancée avec la commande suivante :

~/xray-daemon$ ./xray -o -n us-east-1
Supprimer le daemon

Pour supprimer le Daemon X-Ray de votre EC2 instance Amazon :

  1. Arrêtez le service daemon :

    systemctl stop xray

  2. Supprimez le fichier de configuration :

    rm ~/path/to/xray-daemon.yaml

  3. S'il est configuré, supprimez le fichier journal :

    Note

    L'emplacement du fichier journal dépend de votre configuration :

    • Configuration de la ligne de commande : /var/log/xray-daemon.log

    • Fichier de configuration : Vérifiez le LogPath réglage

Configuration de l' CloudWatch agent

Installation de l'agent

Pour les instructions d'installation, reportez-vous à la section Installation de l' CloudWatch agent sur un serveur local.

Configuration de l'agent

  1. Créez un fichier de configuration pour activer la collecte de traces. Pour plus d'informations, consultez la section Création du fichier de configuration de l' CloudWatch agent.

  2. Configurez les autorisations IAM :

    • Attachez un rôle IAM ou spécifiez les informations d'identification de l'agent. Pour plus d'informations, consultez la section Configuration des rôles IAM.

    • Assurez-vous que le rôle ou les informations d'identification incluent l'xray:PutTraceSegmentsautorisation.

Démarrage de l'agent

Pour obtenir des instructions sur le démarrage de l'agent, reportez-vous à la section Démarrage de l' CloudWatch agent à l'aide de la ligne de commande.

Configuration du OpenTelemetry collecteur

Installation du collecteur

Téléchargez et installez le OpenTelemetry collecteur adapté à votre système d'exploitation. Pour obtenir des instructions, reportez-vous à la section Installation du collecteur.

Configuration du collecteur

Configurez les composants suivants dans votre collecteur :

  • extension awsproxy

    Nécessaire pour l'échantillonnage aux rayons X

  • OTel récepteurs

    Recueille les traces de votre application

  • exportateur de rayons X

    Envoie des traces à X-Ray

Exemple Configuration du collecteur d'échantillons — otel-collector-config .yaml
extensions:
  awsproxy:
    endpoint: 127.0.0.1:2000
  health_check:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 127.0.0.1:4317
      http:
        endpoint: 127.0.0.1:4318

processors:
  batch:

exporters:
  awsxray:
    region: 'us-east-1'

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [awsxray]
  extensions: [awsproxy, health_check]
Important

Configurez AWS les informations d'identification avec l'xray:PutTraceSegmentsautorisation. Pour plus d'informations, consultez la section Spécification des informations d'identification.

Démarrage du collecteur

Lancez le collecteur avec votre fichier de configuration :

otelcol --config=otel-collector-config.yaml

Migration sur Amazon ECS

Important

Votre rôle de tâche doit être xray:PutTraceSegments autorisé pour tous les collecteurs que vous utilisez.

Arrêtez tout conteneur X-Ray Daemon existant avant d'exécuter l' CloudWatch agent ou le conteneur OpenTelemetry collecteur sur le même hôte afin d'éviter les conflits de ports.

Utilisation de l' CloudWatch agent

  1. Obtenez l'image Docker dans la galerie publique Amazon ECR.

  2. Créez un fichier de configuration nommé cw-agent-otel.json :

    {
  "traces": {
    "traces_collected": {
      "xray": {
        "tcp_proxy": {
          "bind_address": "0.0.0.0:2000"
        }
      },
      "otlp": {
        "grpc_endpoint": "0.0.0.0:4317",
        "http_endpoint": "0.0.0.0:4318"
      }
    }
  }
}

  3. Stockez la configuration dans le magasin de paramètres de Systems Manager :

    1. Ouvrez le fichier https://console.aws.amazon.com/systems-manager/

    2. Choisissez Créer un paramètre

    3. Entrez les valeurs suivantes :

      • Nom : /ecs/cwagent/otel-config

      • Niveau : Standard

      • Type : String

      • Type de données : Texte

      • Valeur : [Collez la configuration cw-agent-otel .json ici]

  4. Créez une définition de tâche en utilisant le mode réseau en pont :

    Dans votre définition de tâche, la configuration dépend du mode de mise en réseau que vous utilisez. La mise en réseau par pont est le mode par défaut et peut être utilisé dans votre VPC par défaut. Dans un réseau en pont, définissez la variable d'OTEL_EXPORTER_OTLP_TRACES_ENDPOINTenvironnement pour indiquer au OpenTelemetry SDK quels sont le point de terminaison et le port de l' CloudWatch agent. Vous devez également créer un lien entre le conteneur de votre application et le conteneur Collector pour que les traces soient envoyées depuis le OpenTelemetry SDK de votre application vers le conteneur Collector.

    Exemple CloudWatch définition des tâches de l'agent
    {
    "containerDefinitions": [
        {
            "name": "cwagent",
            "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest",
            "portMappings": [
                {
                    "containerPort": 4318,
                    "hostPort": 4318,
                    "protocol": "tcp"
                },
                {
                    "containerPort": 4317,
                    "hostPort": 4317,
                    "protocol": "tcp"
                },
                {
                    "containerPort": 2000,
                    "hostPort": 2000,
                    "protocol": "tcp"
                }
            ],
            "secrets": [
                {
                    "name": "CW_CONFIG_CONTENT",
                    "valueFrom": "/ecs/cwagent/otel-config"
                }
            ]
        },
        {
            "name": "application",
            "image": "APPLICATION_IMAGE",
            "links": ["cwagent"],
            "environment": [
                {
                    "name": "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
                    "value": "http://cwagent:4318/v1/traces"
                }
            ]
        }
    ]
}

Pour plus d'informations, consultez Déploiement de l' CloudWatch agent pour collecter des métriques EC2 au niveau de l'instance Amazon sur Amazon ECS.

Utilisation du OpenTelemetry collecteur

  1. Obtenez l'image Docker otel/opentelemetry-collector-contrib depuis Docker Hub.

  2. Créez un fichier de configuration appelé otel-collector-config.yaml en utilisant le même contenu que celui indiqué dans la section Amazon sur la EC2 configuration du collecteur, mais mettez à jour les points de terminaison à utiliser 0.0.0.0 au lieu de127.0.0.1.

  3. Pour utiliser cette configuration dans Amazon ECS, vous pouvez la stocker dans le magasin de paramètres Systems Manager. Accédez d'abord à la console Systems Manager Parameter Store, puis choisissez Create new parameter. Créez un nouveau paramètre avec les informations suivantes :

    • Nom :/ecs/otel/config(ce nom sera référencé dans la définition de tâche pour le collecteur)

    • Niveau : Standard

    • Type : String

    • Type de données : Texte

    • Valeur : [Collez la configuration otel-collector-config .yaml ici]

  4. Créez une définition de tâche pour déployer le OpenTelemetry collecteur en utilisant le mode réseau en pont comme exemple.

    Dans la définition de la tâche, la configuration dépend du mode réseau que vous utilisez. La mise en réseau par pont est le mode par défaut et peut être utilisé dans votre VPC par défaut. Dans un réseau en pont, définissez la variable d'OTEL_EXPORTER_OTLP_TRACES_ENDPOINTenvironnement pour indiquer au OpenTelemetry SDK quels sont le point de terminaison et le port du OpenTelemetry collecteur. Vous devez également créer un lien entre le conteneur de votre application et le conteneur Collector pour que les traces soient envoyées depuis le OpenTelemetry SDK de votre application vers le conteneur Collector.

    Exemple OpenTelemetry définition de la tâche du collecteur
    {
    "containerDefinitions": [
        {
            "name": "otel-collector",
            "image": "otel/opentelemetry-collector-contrib",
            "portMappings": [
                {
                    "containerPort": 2000,
                    "hostPort": 2000
                },
                {
                    "containerPort": 4317,
                    "hostPort": 4317
                },
                {
                    "containerPort": 4318,
                    "hostPort": 4318
                }
            ],
            "command": [
                "--config",
                "env:SSM_CONFIG"
            ],
            "secrets": [
                {
                    "name": "SSM_CONFIG",
                    "valueFrom": "/ecs/otel/config"
                }
            ]
        },
        {
            "name": "application",
            "image": "APPLICATION_IMAGE",
            "links": ["otel-collector"],
            "environment": [
                {
                    "name": "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
                    "value": "http://otel-collector:4318/v1/traces"
                }
            ]
        }
    ]
}

Migration sur Elastic Beanstalk

Important

Arrêtez le processus X-Ray Daemon avant d'utiliser l' CloudWatch agent pour éviter les conflits de ports.

Votre intégration X-Ray Daemon existante a été activée à l'aide de la console Elastic Beanstalk ou en configurant X-Ray Daemon dans le code source de votre application à l'aide d'un fichier de configuration.

Utilisation de l' CloudWatch agent

Sur la plateforme Amazon Linux 2, configurez l' CloudWatch agent à l'aide d'un fichier .ebextensions de configuration :

  1. Créez un répertoire nommé .ebextensions à la racine de votre projet

  2. Créez un fichier nommé cloudwatch.config dans le .ebextensions répertoire avec le contenu suivant :

    files:
  "/opt/aws/amazon-cloudwatch-agent/etc/config.json":
    mode: "0644"
    owner: root
    group: root
    content: |
      {
        "traces": {
          "traces_collected": {
            "otlp": {
              "grpc_endpoint": "12.0.0.1:4317",
              "http_endpoint": "12.0.0.1:4318"
            }
          }
        }
      }
container_commands:
  start_agent:
    command: /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a append-config -c file:/opt/aws/amazon-cloudwatch-agent/etc/config.json -s

  3. Incluez le .ebextensions répertoire dans le bundle de sources de votre application lors du déploiement

Pour plus d'informations sur les fichiers de configuration d'Elastic Beanstalk, consultez la section Personnalisation avancée de l'environnement avec les fichiers de configuration.