Installez le collecteur DDOT en tant que DaemonSet Kubernetes

Docs > OpenTelemetry dans Datadog > Send OpenTelemetry Data to Datadog > Distribution Datadog du Collecteur OpenTelemetry > Install > Installez le collecteur DDOT en tant que DaemonSet Kubernetes

Cette traduction n'est pas à jour. Pour consulter la dernière version en anglais, cliquez ici

Aperçu

Suivez ce guide pour déployer la distribution Datadog du collecteur OpenTelemetry (DDOT) en tant que DaemonSet Kubernetes en utilisant Helm ou l’opérateur Datadog.

Besoin de composants OpenTelemetry supplémentaires ? Si vous avez besoin de composants au-delà de ceux inclus dans le package par défaut, suivez Utilisez des composants OpenTelemetry personnalisés pour étendre les capacités de l'agent Datadog. Pour une liste des composants inclus par défaut, consultez Composants du collecteur OpenTelemetry.

Exigences

Pour compléter ce guide, vous avez besoin des éléments suivants :

Compte Datadog :

Créez un compte Datadog si vous n’en avez pas.
Trouvez ou créez votre clé API Datadog.

Logiciel : Installez et configurez ce qui suit sur votre machine :

Un cluster Kubernetes (v1.29+)
Helm (v3+)
kubectl

Réseau : When using the Datadog SDK with OpenTelemetry API support, telemetry is routed to different components depending on the signal source. Ensure the following ports are accessible on your Datadog Agent or Collector:

Signal Source	Protocol	Port	Destination Component
OTel Metrics and Logs API	OTLP (gRPC/HTTP)	4317 / 4318	Datadog Agent OTLP Receiver or DDOT Collector
Datadog Tracing	Datadog trace intake	8126 (TCP)	Datadog Trace Agent
Runtime Metrics	DogStatsD	8125 (UDP)	DogStatsD Server

Installez l’agent Datadog avec le collecteur OpenTelemetry

Cette installation est requise pour les configurations Datadog SDK + DDOT et OpenTelemetry SDK + DDOT. Bien que le SDK Datadog implémente l'API OpenTelemetry, il nécessite toujours le collecteur DDOT pour traiter et transférer les métriques et les journaux OTLP.

Sélectionnez la méthode d’installation

Choisissez l’une des méthodes d’installation suivantes :

Opérateur Datadog : Une approche native à Kubernetes qui réconcilie et maintient automatiquement votre configuration Datadog. Il rapporte l’état de déploiement, la santé et les erreurs dans son statut de ressource personnalisée, et il limite le risque de mauvaise configuration grâce à des options de configuration de niveau supérieur.
Helm chart : Un moyen simple de déployer l’Agent Datadog. Il fournit des capacités de versionnage, de rollback et de templating, rendant les déploiements cohérents et plus faciles à reproduire.

Installez l’Opérateur Datadog

Vous pouvez installer l’Opérateur Datadog dans votre cluster en utilisant le Datadog Operator Helm chart :

helm repo add datadog https://helm.datadoghq.com
helm repo update
helm install datadog-operator datadog/datadog-operator

Ajoutez le dépôt Helm de Datadog

Pour ajouter le dépôt Datadog à vos dépôts Helm :

helm repo add datadog https://helm.datadoghq.com
helm repo update

Configurez la clé API Datadog

Obtenez la clé API Datadog.
Stockez la clé API en tant que secret Kubernetes :
```
kubectl create secret generic datadog-secret \
  --from-literal api-key=<DD_API_KEY>
```
Remplacez <DD_API_KEY> par votre véritable clé API Datadog.

Configurez l’Agent Datadog

Après avoir déployé l’Opérateur Datadog, créez la ressource DatadogAgent qui déclenche le déploiement de l’Agent Datadog, de l’Agent de Cluster et des Runners de Vérifications de Cluster (si utilisés) dans votre cluster Kubernetes. L’Agent Datadog se déploie en tant que DaemonSet, exécutant un pod sur chaque nœud de votre cluster.

Utilisez le fichier datadog-agent.yaml pour spécifier votre configuration de déploiement DatadogAgent.

datadog-agent.yaml

   apiVersion: datadoghq.com/v2alpha1
   kind: DatadogAgent
   metadata:
     name: datadog
   spec:
     global:
       clusterName: <CLUSTER_NAME>
       site: <DATADOG_SITE>
       credentials:
         apiSecret:
           secretName: datadog-secret
           keyName: api-key

Remplacez <CLUSTER_NAME> par un nom pour votre cluster.
Remplacez <DATADOG_SITE> par votre site Datadog. Votre site est (Assurez-vous que le bon SITE DATADOG est sélectionné à droite.)

Activez le Collecteur OpenTelemetry :

datadog-agent.yaml

  # Enable Features
  features:
    otelCollector:
      enabled: true

L’Opérateur Datadog lie automatiquement le Collecteur OpenTelemetry aux ports 4317 (nommé otel-grpc) et 4318 (nommé otel-http) par défaut.

(Optionnel) Activez des fonctionnalités supplémentaires de Datadog :

L'activation de ces fonctionnalités peut entraîner des frais supplémentaires. Examinez la page de tarification et parlez à votre Responsable du Succès Client avant de continuer.

datadog-agent.yaml

  # Enable Features
  features:
  ...
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true

Lors de l’activation de fonctionnalités supplémentaires de Datadog, utilisez toujours les fichiers de configuration de Datadog ou du Collecteur OpenTelemetry au lieu de vous fier aux variables d’environnement Datadog.

Remarque : À partir de l’opérateur v1.22.0, le conteneur DDOT utilise l’image ddot-collector au lieu de l’image de l’agent -full.

Lorsque vous remplacez le tag de l’image de l’agent de nœud, utilisez un tag >= 7.67.0 afin que le conteneur OTel soit programmé (l’image ddot-collector n’est prise en charge que dans >= 7.67.0).
L’image ddot-collector n’a pas de variante -full. Si vous avez besoin d’une image -full, définissez spec.override.nodeAgent.image.name sur une image d’agent complète (par exemple, registry.datadoghq.com/agent:7.72.1-full).

Utilisez un fichier YAML pour spécifier les paramètres du Datadog Agent Helm chart.

Créez un fichier datadog-values.yaml vide :

touch datadog-values.yaml

Les paramètres non spécifiés utilisent les valeurs par défaut de values.yaml.

Configurez le secret de la clé API Datadog :

datadog-values.yaml

datadog:
  site: <DATADOG_SITE>
  apiKeyExistingSecret: datadog-secret

Définissez <DATADOG_SITE> sur votre site Datadog. Sinon, il utilise par défaut datadoghq.com, le site US1.

Activez le Collecteur OpenTelemetry et configurez les ports essentiels :

datadog-values.yaml

datadog:
  ...
  otelCollector:
    enabled: true
    ports:
      - containerPort: "4317" # default port for OpenTelemetry gRPC receiver.
        hostPort: "4317"
        name: otel-grpc
      - containerPort: "4318" # default port for OpenTelemetry HTTP receiver
        hostPort: "4318"
        name: otel-http

Définissez le hostPort pour exposer le port du conteneur au réseau externe. Cela permet de configurer l’exportateur OTLP pour pointer vers l’adresse IP du nœud où l’Agent Datadog est assigné.

Si vous ne souhaitez pas exposer le port, vous pouvez utiliser le service Agent à la place :

Supprimez le hostPort les entrées de votre datadog-values.yaml fichier.

Dans le fichier de déploiement de votre application (deployment.yaml), configurez l’exportateur OTLP pour utiliser le service Agent :

env:
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: 'http://<SERVICE_NAME>.<SERVICE_NAMESPACE>.svc.cluster.local'
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: 'grpc'

(Optionnel) Activez des fonctionnalités Datadog supplémentaires :

L'activation de ces fonctionnalités peut entraîner des frais supplémentaires. Examinez la page de tarification et parlez à votre Responsable du Succès Client avant de continuer.

datadog-values.yaml

datadog:
  ...
  apm:
    portEnabled: true
    peer_service_aggregation: true
  orchestratorExplorer:
    enabled: true
  processAgent:
    enabled: true
    processCollection: true

(Optionnel) Collectez les étiquettes de pod et utilisez-les comme tags à attacher aux métriques, traces et journaux :

Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d'informations.

datadog-values.yaml

datadog:
  ...
  podLabelsAsTags:
    app: kube_app
    release: helm_release

Fichier datadog-values.yaml complété

Votre fichier datadog-values.yaml devrait ressembler à ceci :

datadog-values.yaml

datadog:
  site: datadoghq.com
  apiKeyExistingSecret: datadog-secret

  otelCollector:
    enabled: true
    ports:
      - containerPort: "4317"
        hostPort: "4317"
        name: otel-grpc
      - containerPort: "4318"
        hostPort: "4318"
        name: otel-http
  apm:
    portEnabled: true
    peer_service_aggregation: true
  orchestratorExplorer:
    enabled: true
  processAgent:
    enabled: true
    processCollection: true

  podLabelsAsTags:
    app: kube_app
    release: helm_release
   

Configurez le Collecteur OpenTelemetry

L’Opérateur Datadog fournit une configuration d’exemple du Collecteur OpenTelemetry que vous pouvez utiliser comme point de départ. Si vous devez modifier cette configuration, l’Opérateur Datadog prend en charge deux façons de fournir une configuration de Collecteur personnalisée :

Configuration en ligne : Ajoutez votre configuration de Collecteur personnalisée directement dans le champ features.otelCollector.conf.configData.
Configuration basée sur ConfigMap : Stockez votre configuration de Collecteur dans un ConfigMap et référencez-le dans le champ features.otelCollector.conf.configMap. Cette approche vous permet de garder la configuration du Collecteur découplée de la ressource DatadogAgent.

Configuration du collecteur en ligne

Dans l’extrait ci-dessous, la configuration du Collecteur est placée directement sous le paramètre features.otelCollector.conf.configData :

datadog-agent.yaml

  ...
  # Enable Features
  features:
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configData: |-
          receivers:
            prometheus:
              config:
                scrape_configs:
                  - job_name: "otelcol"
                    scrape_interval: 10s
                    static_configs:
                      - targets:
                          - 0.0.0.0:8888
            otlp:
              protocols:
                grpc:
                  endpoint: 0.0.0.0:4317
                http:
                  endpoint: 0.0.0.0:4318
          exporters:
            debug:
              verbosity: detailed
            datadog:
              api:
                key: ${env:DD_API_KEY}
                site: ${env:DD_SITE}
              sending_queue:
                batch:
                  flush_timeout: 10s
          processors:
            infraattributes:
              cardinality: 2
          connectors:
            datadog/connector:
              traces:
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog]

For the infraattributes processor to add Kubernetes tags, your telemetry must include the container.id resource attribute. This is often, but not always, added by OTel SDK auto-instrumentation.

If your tags are missing, see the troubleshooting guide for details on how to add this attribute.

Lorsque vous appliquez le fichier datadog-agent.yaml contenant cette ressource DatadogAgent, l’Opérateur monte automatiquement la configuration du Collecteur dans le DaemonSet de l’Agent.

Fichier datadog-agent.yaml complété avec la configuration du Collecteur en ligne

Le datadog-agent.yaml complété avec la configuration du Collecteur en ligne devrait ressembler à ceci :

datadog-agent.yaml

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    clusterName: <CLUSTER_NAME>
    site: <DATADOG_SITE>
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  # Enable Features
  features:
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configData: |-
          receivers:
            prometheus:
              config:
                scrape_configs:
                  - job_name: "datadog-agent"
                    scrape_interval: 10s
                    static_configs:
                      - targets:
                          - 0.0.0.0:8888
            otlp:
              protocols:
                grpc:
                  endpoint: 0.0.0.0:4317
                http:
                  endpoint: 0.0.0.0:4318
          exporters:
            debug:
              verbosity: detailed
            datadog:
              api:
                key: ${env:DD_API_KEY}
                site: ${env:DD_SITE}
              sending_queue:
                batch:
                  flush_timeout: 10s
          processors:
            infraattributes:
              cardinality: 2
          connectors:
            datadog/connector:
              traces:
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog]

Configuration du collecteur basée sur ConfigMap

Pour des configurations plus complexes ou fréquemment mises à jour, stocker la configuration du Collecteur dans un ConfigMap peut simplifier le contrôle de version.

Créez un ConfigMap qui contient votre configuration de Collecteur :

configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-agent-config-map
  namespace: system
data:
  # must be named otel-config.yaml
  otel-config.yaml: |-
    receivers:
      prometheus:
        config:
          scrape_configs:
            - job_name: "datadog-agent"
              scrape_interval: 10s
              static_configs:
                - targets:
                    - 0.0.0.0:8888
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318
    exporters:
      debug:
        verbosity: detailed
      datadog:
        api:
          key: ${env:DD_API_KEY}
          site: ${env:DD_SITE}
        sending_queue:
          batch:
            flush_timeout: 10s
    processors:
      infraattributes:
        cardinality: 2
    connectors:
      datadog/connector:
        traces:
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog]

Le champ pour la configuration du Collecteur dans le ConfigMap doit s'appeler otel-config.yaml.

Référencez le ConfigMap otel-agent-config-map dans votre ressource DatadogAgent en utilisant le paramètre features.otelCollector.conf.configMap :

datadog-agent.yaml

  ...
  # Enable Features
  features:
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configMap:
          name: otel-agent-config-map

L’Opérateur monte automatiquement otel-config.yaml depuis le ConfigMap dans le DaemonSet OpenTelemetry Collector de l’Agent.

Fichier datadog-agent.yaml complété avec la configuration du Collecteur dans le ConfigMap

Le datadog-agent.yaml complété avec la configuration du Collecteur définie comme ConfigMap devrait ressembler à ceci :

datadog-agent.yaml

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    clusterName: <CLUSTER_NAME>
    site: <DATADOG_SITE>
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  # Enable Features
  features:
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configMap:
          name: otel-agent-config-map
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-agent-config-map
  namespace: system
data:
  # must be named otel-config.yaml
  otel-config.yaml: |-
    receivers:
      prometheus:
        config:
          scrape_configs:
            - job_name: "datadog-agent"
              scrape_interval: 10s
              static_configs:
                - targets:
                    - 0.0.0.0:8888
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318
    exporters:
      debug:
        verbosity: detailed
      datadog:
        api:
          key: ${env:DD_API_KEY}
          site: ${env:DD_SITE}
        sending_queue:
          batch:
            flush_timeout: 10s
    processors:
      infraattributes:
        cardinality: 2
    connectors:
      datadog/connector:
        traces:
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog]

Le Datadog Helm chart fournit un exemple de configuration OpenTelemetry Collector que vous pouvez utiliser comme point de départ. Cette section vous guide à travers les pipelines prédéfinis et les composants OpenTelemetry inclus.

Voici la configuration complète du Collecteur OpenTelemetry dans otel-config.yaml :

otel-config.yaml

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: "otelcol"
          scrape_interval: 10s
          static_configs:
            - targets: ["0.0.0.0:8888"]
  otlp:
    protocols:
      grpc:
         endpoint: 0.0.0.0:4317
      http:
         endpoint: 0.0.0.0:4318
exporters:
  debug:
    verbosity: detailed
  datadog:
    api:
      key: ${env:DD_API_KEY}
      site: ${env:DD_SITE}
    sending_queue:
      batch:
        flush_timeout: 10s
processors:
  infraattributes:
    cardinality: 2
connectors:
  datadog/connector:
    traces:
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [infraattributes]
      exporters: [datadog, datadog/connector]
    metrics:
      receivers: [otlp, datadog/connector, prometheus]
      processors: [infraattributes]
      exporters: [datadog]
    logs:
      receivers: [otlp]
      processors: [infraattributes]
      exporters: [datadog]

For the infraattributes processor to add Kubernetes tags, your telemetry must include the container.id resource attribute. This is often, but not always, added by OTel SDK auto-instrumentation.

If your tags are missing, see the troubleshooting guide for details on how to add this attribute.

Composants clés

Pour envoyer des données de télémétrie à Datadog, les composants suivants sont définis dans la configuration :

Diagramme représentant le modèle de déploiement de l'Agent

Connecteur Datadog

Le connecteur Datadog calcule les métriques de trace APM de Datadog.

otel-config.yaml

connectors:
  datadog/connector:
    traces:

Exportateur Datadog

L’exportateur Datadog exporte les traces, les métriques et les journaux vers Datadog.

otel-config.yaml

exporters:
  datadog:
    api:
      key: ${env:DD_API_KEY}
      site: ${env:DD_SITE}
    sending_queue:
      batch:
        flush_timeout: 10s

Remarque : Si key n’est pas spécifié ou est défini comme un secret, ou si site n’est pas spécifié, le système utilise les valeurs de la configuration de base de l’Agent. Par défaut, l’Agent de base définit le site sur datadoghq.com (US1).

Récepteur Prometheus

Le récepteur Prometheus collecte les métriques de santé du Collecteur OpenTelemetry pour le pipeline de métriques.

otel-config.yaml

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: "otelcol"
          scrape_interval: 10s
          static_configs:
            - targets: ["0.0.0.0:8888"]

Pour plus d’informations, consultez la documentation sur les Métriques de santé du Collecteur.

Déployez l’Agent avec le Collecteur OpenTelemetry

Déployez l’Agent Datadog avec le fichier de configuration :

kubectl apply -f datadog-agent.yaml

Cela déploie l’Agent Datadog en tant que DaemonSet avec le Collecteur OpenTelemetry DDOT. Le Collecteur s’exécute sur le même hôte que votre application, suivant le modèle de déploiement de l’Agent. Le modèle de déploiement de la passerelle est en aperçu ; pour les instructions d’installation, suivez le guide d’installation de la passerelle Kubernetes DDOT.

Pour installer ou mettre à niveau l’Agent Datadog avec le Collecteur OpenTelemetry dans votre environnement Kubernetes, utilisez l’une des commandes Helm suivantes :

Pour la configuration par défaut du Collecteur OpenTelemetry :

helm upgrade -i <RELEASE_NAME> datadog/datadog -f datadog-values.yaml

Pour la configuration personnalisée du Collecteur OpenTelemetry :

helm upgrade -i <RELEASE_NAME> datadog/datadog \
  -f datadog-values.yaml \
  --set-file datadog.otelCollector.config=otel-config.yaml

Cette commande vous permet de spécifier votre propre fichier otel-config.yaml.

Remplacez <RELEASE_NAME> par le nom de la release Helm que vous utilisez.

Vous pouvez voir des avertissements pendant le processus de déploiement. Ces avertissements peuvent être ignorés.

Ce chart Helm déploie l’Agent Datadog avec le Collecteur OpenTelemetry en tant que DaemonSet. Le Collecteur est déployé sur le même hôte que votre application, suivant le modèle de déploiement de l’Agent. Le modèle de déploiement de la passerelle est en aperçu ; pour les instructions d’installation, suivez le guide d’installation de la passerelle Kubernetes DDOT.

Diagramme de déploiement

Envoyez vos données de télémétrie à Datadog

Pour envoyer vos données de télémétrie à Datadog :

Instrumentez votre application
Configurez l’application
Corrélez les données d’observabilité
Exécutez votre application

Instrumentez l’application

Instrumentez votre application en utilisant l’API OpenTelemetry.

Exemple d'application instrumentée avec l'API OpenTelemetry

Par exemple, vous pouvez utiliser l’application d’exemple Calendar qui est déjà instrumentée pour vous. Le code suivant instrumente la méthode CalendarService.getDate() en utilisant les annotations et l’API OpenTelemetry :

CalendarService.java

@WithSpan(kind = SpanKind.CLIENT)
public String getDate() {
    Span span = Span.current();
    span.setAttribute("peer.service", "random-date-service");
    ...
}

Configurez l’application

Votre conteneur d’application doit envoyer des données au Collecteur DDOT sur le même hôte. Puisque le Collecteur fonctionne en tant que DaemonSet, vous devez spécifier l’hôte local comme point de terminaison OTLP.

Si la variable d’environnement OTEL_EXPORTER_OTLP_ENDPOINT n’est pas déjà définie, ajoutez-la au fichier manifeste de déploiement de votre application :

deployment.yaml

env:
  ...
  - name: HOST_IP
    valueFrom:
     fieldRef:
        fieldPath: status.hostIP
  - name: OTLP_GRPC_PORT
    value: "4317"
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: 'http://$(HOST_IP):$(OTLP_GRPC_PORT)'
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: 'grpc'
   

Corrélez les données d’observabilité

Le balisage de service unifié relie les données d’observabilité dans Datadog afin que vous puissiez naviguer à travers les métriques, les traces et les journaux avec des balises cohérentes.

Dans les environnements conteneurisés, définissez env, service et version en utilisant les variables d’environnement des attributs de ressource OpenTelemetry. Le Collecteur DDOT détecte cette configuration de balisage et l’applique aux données qu’il collecte à partir des conteneurs.

Ajoutez les variables d’environnement suivantes au manifeste de déploiement de votre application :

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <SERVICE>
spec:
  template:
    spec:
      containers:
      - name: <SERVICE>
        env:
          - name: OTEL_SERVICE_NAME
            value: "<SERVICE>"
          - name: OTEL_RESOURCE_ATTRIBUTES
            value: "service.version=<VERSION>,deployment.environment.name=<ENV>"

Alternativement, vous pouvez utiliser des étiquettes Kubernetes spécifiques à Datadog pour configurer le balisage de service unifié. N'utilisez pas les deux approches, car cela crée des balises en double.

Exécutez l’application

Redéployez votre application pour appliquer les modifications apportées au manifeste de déploiement. Une fois la configuration mise à jour active, le balisage de service unifié sera entièrement activé pour vos métriques, traces et journaux.

Explorez les données d’observabilité dans Datadog

Utilisez Datadog pour explorer les données d’observabilité de votre application.

Automatisation de flotte

Explorez la configuration de votre Agent et Collecteur Datadog.

Examinez la configuration de votre Agent et Collecteur depuis la page d'automatisation de la flotte.

Surveillance en direct des conteneurs

Surveillez la santé de vos conteneurs en utilisant les capacités de surveillance en direct des conteneurs.

Surveillez la santé de vos conteneurs depuis la page des conteneurs.

Santé des nœuds d’infrastructure

Consultez les métriques d’exécution et d’infrastructure pour surveiller et mesurer la performance de vos nœuds.

Visualisez les métriques d'exécution et d'infrastructure à partir de la liste des hôtes.

Journaux

Consultez les logs pour surveiller et diagnostiquer les opérations de l’application et du système.

Traces

Visualisez les traces et les spans pour observer l’état et la performance des requêtes traitées par votre application, avec des métriques d’infrastructure corrélées dans la même trace.