Installez le collecteur DDOT en tant que DaemonSet Kubernetes

Documentation > OpenTelemetry dans Datadog > Envoyer des données OpenTelemetry à Datadog > Distribution Datadog du collecteur OpenTelemetry > Install > Installez le collecteur DDOT en tant que DaemonSet Kubernetes

Présentation

Suivez ce guide pour déployer le collecteur Datadog Distribution of OpenTelemetry (DDOT) en tant que DaemonSet Kubernetes à l’aide de Helm ou de Datadog Operator.

Besoin de composants OpenTelemetry supplémentaires? Si vous avez besoin de composants autres que ceux inclus dans le package par défaut, suivez Use Custom OpenTelemetry Components pour étendre les capacités de Datadog Agent. Pour obtenir une liste des composants inclus par défaut, consultez Composants du collecteur OpenTelemetry.

Prérequis

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é Datadog API.

Logiciels : Installez et configurez les éléments suivants 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

Installer le Datadog Agent avec le Collector 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 Collector DDOT pour traiter et transférer les métriques et logs OTLP.

Sélectionnez la méthode d’installation

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

Datadog Operator : une approche native Kubernetes qui réconcilie et maintient automatiquement votre configuration Datadog. Il signale le statut de déploiement, l’état de santé et les erreurs dans le statut de sa ressource personnalisée, et il limite le risque de mauvaise configuration grâce à des options de configuration de plus haut niveau.
Helm chart : un moyen simple de déployer Datadog Agent. Il offre des capacités de versioning, de restauration et de templating, rendant les déploiements cohérents et plus faciles à répliquer.

Installez Datadog Operator

Vous pouvez installer Datadog Operator dans votre cluster à l’aide du Helm chart de Datadog Operator :

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

Ajoutez le dépôt Helm 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é Datadog API

Obtenez la clé d’API Datadog.
Stockez la clé d’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 clé Datadog API réelle.

Configurez Datadog Agent

Après avoir déployé Datadog Operator, créez la ressource DatadogAgent qui déclenche le déploiement de Datadog Agent, de l’Agent de cluster et des exécuteurs de vérifications de cluster (si utilisés) dans votre cluster Kubernetes. Datadog Agent 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 DATADOG SITE correct est sélectionné sur la droite.)

Activez le collecteur OpenTelemetry :

datadog-agent.yaml

  # Enable Features
  features:
    otelCollector:
      enabled: true

Datadog Operator lie automatiquement le collecteur OpenTelemetry aux ports 4317 (nommés otel-grpc) et 4318 (nommés otel-http) par défaut.

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

L'activation de ces fonctionnalités peut entraîner des frais supplémentaires. Consultez la page de tarification et parlez à votre Customer Success Manager 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 Datadog supplémentaires, utilisez toujours les fichiers de configuration du Collector Datadog ou du Collector 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 d’agent -full.

Lors du remplacement de la balise d’image de l’agent de nœud, utilisez une balise >= 7.67.0 afin que le conteneur OTel soit planifié (l’image ddot-collector n’est prise en charge qu’à partir de >= 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 Helm chart pour le Datadog Agent 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é Datadog API :

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 qu’il pointe vers l’adresse IP du nœud où Datadog Agent est affecté.

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

Supprimez les hostPort 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 de l’Agent :

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

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

L'activation de ces fonctionnalités peut entraîner des frais supplémentaires. Consultez la page de tarification et parlez à votre Customer Success Manager avant de continuer.

datadog-values.yaml

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

(Facultatif) Collectez les étiquettes de pod et utilisez-les comme tags à associer aux métriques, aux traces et aux logs :

Les Custom Metrics peuvent avoir une incidence sur la facturation. Consultez la page de facturation des Custom Metrics pour plus d'informations.

datadog-values.yaml

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

Fichier datadog-values.yaml terminé

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

Comme le collecteur DDOT s’exécute au sein de Datadog Agent, les attributs de nom d’hôte sur la télémétrie entrante peuvent correspondre à un nom différent de celui de l’Agent. Le processeur infraattributes peut appliquer le nom d’hôte de l’Agent à la place. Consultez Hostname and Tagging pour la configuration recommandée.

Datadog Operator fournit un exemple de configuration de collecteur OpenTelemetry que vous pouvez utiliser comme point de départ. Si vous devez modifier cette configuration, Datadog Operator prend en charge deux méthodes pour 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 une ConfigMap : Stockez votre configuration de collecteur dans une ConfigMap et référencez-la 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
            cumulativetodelta:
          connectors:
            datadog/connector:
              traces:
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes, cumulativetodelta]
                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é

Le datadog-agent.yaml complété avec une configuration de 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
            cumulativetodelta:
          connectors:
            datadog/connector:
              traces:
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes, cumulativetodelta]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog]

Configuration du collecteur basée sur une ConfigMap

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

Créez une ConfigMap contenant votre configuration de collecteur :

configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-agent-config-map
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
      cumulativetodelta:
    connectors:
      datadog/connector:
        traces:
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes, cumulativetodelta]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog]

Le champ pour la configuration du collecteur dans la ConfigMap doit être nommé otel-config.yaml.

Référencez la 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 la ConfigMap dans le DaemonSet du collecteur OpenTelemetry de l’Agent.

Fichier datadog-agent.yaml complété avec la configuration du collecteur dans la 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
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
      cumulativetodelta:
    connectors:
      datadog/connector:
        traces:
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes, cumulativetodelta]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog]

Le Helm chart Datadog fournit un exemple de configuration de collecteur OpenTelemetry 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
  cumulativetodelta:
connectors:
  datadog/connector:
    traces:
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [infraattributes]
      exporters: [datadog, datadog/connector]
    metrics:
      receivers: [otlp, datadog/connector, prometheus]
      processors: [infraattributes, cumulativetodelta]
      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 illustrant le modèle de déploiement de l'Agent

Datadog connector

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

otel-config.yaml

connectors:
  datadog/connector:
    traces:

Datadog Exporter

L’exportateur Datadog exporte les traces, les métriques et les logs 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 défini sur un secret, ou si site n’est pas spécifié, le système utilise les valeurs de la configuration principale de l’Agent. Par défaut, l’Agent principal définit le site sur datadoghq.com (US1).

Prometheus receiver

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 Datadog Agent avec le fichier de configuration :

kubectl apply -f datadog-agent.yaml

Ceci déploie Datadog Agent en tant que DaemonSet avec le collecteur OpenTelemetry DDOT. Le collecteur s’exécute sur le même hôte que votre application, en suivant le modèle de déploiement de l’Agent. Pour le modèle de déploiement de passerelle, suivez le guide d’installation de la passerelle Kubernetes DDOT.

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

Pour une configuration par défaut du collecteur OpenTelemetry :

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

Pour une 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 pourriez voir des avertissements pendant le processus de déploiement. Ces avertissements peuvent être ignorés.

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

Diagramme de déploiement

Envoyez votre 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

À titre d’exemple, vous pouvez utiliser l’exemple d’application Calendar qui est déjà instrumenté 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. Comme le Collector s’exécute en tant que DaemonSet, vous devez spécifier l’hôte local comme endpoint 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 Unified service tagging relie les données d’observabilité dans Datadog afin que vous puissiez naviguer entre les métriques, les traces et les logs avec des tags cohérents.

Dans les environnements conteneurisés, définissez env, service et version à l’aide des variables d’environnement des attributs de ressource OpenTelemetry. Le collecteur DDOT détecte cette configuration de marquage 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 unified service tagging. N'utilisez pas les deux approches, car cela crée des étiquettes 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 unified service tagging sera entièrement activé pour vos métriques, traces et logs.

Explorez les données d’observabilité dans Datadog

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

Automatisation du parc

Explorez la configuration de votre Agent et de votre Collector Datadog.

Examinez la configuration de votre Agent et du Collector depuis la page Fleet Automation.

Surveillance des conteneurs en temps réel

Surveillez l’état de vos conteneurs à l’aide des fonctionnalités de Live Container Monitoring.

Surveillez l'état de vos conteneurs depuis la page Containers.

État de santé des nœuds d’infrastructure

Affichez les métriques d’exécution et d’infrastructure pour visualiser, surveiller et mesurer les performances de vos nœuds.

Affichez les métriques d'exécution et d'infrastructure depuis la liste des hosts.

Logs

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

Traces

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