Collector OpenTelemetry Kubernetes vers Dynatrace : Helm, Operator et k8sattributes

Collector OpenTelemetry Kubernetes : déployez-le en DaemonSet avec Helm ou l’Operator, enrichissez avec k8sattributes et exportez vers Dynatrace.
Collector OpenTelemetry Kubernetes vers Dynatrace : Helm, Operator et k8sattributes

Vos pods envoient des traces OpenTelemetry, mais dans Dynatrace elles arrivent sans nom de pod, sans namespace, sans nœud. Impossible de relier une latence à un déploiement précis, et le MTTR s’allonge. Déployer un collector OpenTelemetry Kubernetes, enrichi par le processeur k8sattributes, règle ce problème à la source.

Objectif de ce tutoriel : installer un Collector dans le cluster avec Helm (ou avec l’OpenTelemetry Operator), ajouter les métadonnées Kubernetes à chaque span, métrique et log, puis exporter le tout en OTLP vers Dynatrace. Le contenu vaut pour Dynatrace SaaS et Dynatrace Managed ; seule l’URL d’ingestion change.

Si vous découvrez le Collector, commencez par le collector OpenTelemetry vers Dynatrace, qui détaille le pipeline receivers → processors → exporters hors Kubernetes.

Prérequis

  • Un cluster Kubernetes 1.26 ou plus récent, kubectl et Helm 3.
  • Un token d’API Dynatrace avec les scopes openTelemetryTrace.ingest, metrics.ingest et logs.ingest.
  • L’URL OTLP de votre environnement :
    • SaaS : https://<env-id>.live.dynatrace.com/api/v2/otlp ;
    • Managed : https://<votre-domaine>/e/<env-id>/api/v2/otlp (ou via un ActiveGate d’environnement).
  • Des applications déjà instrumentées avec un SDK ou un agent OpenTelemetry (par exemple l’agent OpenTelemetry Java).

Quel mode de déploiement choisir ?

  • DaemonSet : un Collector par nœud. Les pods envoient leur télémétrie au Collector local. C’est le mode recommandé pour k8sattributes, car le Collector ne surveille que les pods de son nœud.
  • Deployment : un pool de Collectors derrière un Service. Utile comme passerelle centrale, par exemple pour l’échantillonnage.
  • Dynatrace Operator : il gère OneAgent et ActiveGate. Ne le confondez pas avec l’OpenTelemetry Operator, qui gère des Collectors et l’auto-instrumentation. Les deux peuvent cohabiter dans le même cluster.

Ce tutoriel utilise un DaemonSet. Si OneAgent tourne aussi dans le cluster, lisez comment éviter les spans en double avant d’activer les deux.

Installer le collector OpenTelemetry Kubernetes avec Helm

Étape 1 : créer le namespace et le secret

kubectl create namespace observability
kubectl -n observability create secret generic dynatrace-otlp \
  --from-literal=DT_ENDPOINT='https://<env-id>.live.dynatrace.com/api/v2/otlp' \
  --from-literal=DT_API_TOKEN='dt0c01.XXXX'

Le token reste dans un Secret, jamais dans le fichier de valeurs versionné.

Étape 2 : écrire le fichier values.yaml

mode: daemonset

image:
  repository: otel/opentelemetry-collector-contrib
command:
  name: otelcol-contrib

presets:
  kubernetesAttributes:
    enabled: true          # ajoute k8sattributes + RBAC
    extractAllPodLabels: false

extraEnvsFrom:
  - secretRef:
      name: dynatrace-otlp

config:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: ${env:MY_POD_IP}:4317
        http:
          endpoint: ${env:MY_POD_IP}:4318
  processors:
    memory_limiter:
      check_interval: 1s
      limit_percentage: 80
      spike_limit_percentage: 25
    cumulative_to_delta: {}
    batch:
      send_batch_size: 1000
      timeout: 5s
  exporters:
    otlphttp/dynatrace:
      endpoint: ${env:DT_ENDPOINT}
      headers:
        Authorization: "Api-Token ${env:DT_API_TOKEN}"
  service:
    pipelines:
      traces:
        receivers: [otlp]
        processors: [memory_limiter, k8s_attributes, batch]
        exporters: [otlphttp/dynatrace]
      metrics:
        receivers: [otlp]
        processors: [memory_limiter, k8s_attributes, cumulative_to_delta, batch]
        exporters: [otlphttp/dynatrace]
      logs:
        receivers: [otlp]
        processors: [memory_limiter, k8s_attributes, batch]
        exporters: [otlphttp/dynatrace]

Les lignes critiques :

  • image.repository : l’image contrib contient k8sattributes et cumulative_to_delta. Dynatrace publie aussi sa propre distribution du Collector ; vérifiez sur docs.dynatrace.com l’image et les composants qu’elle inclut.
  • presets.kubernetesAttributes : le chart ajoute le processeur et crée le ClusterRole qui lui permet de lire pods, namespaces et ReplicaSets.
  • cumulative_to_delta : Dynatrace attend des métriques OTLP en temporalité delta. Le détail est dans la temporalité des métriques OTLP.
  • memory_limiter en premier : il protège le nœud si Dynatrace ralentit.

Dans les versions récentes du Collector contrib, le processeur k8sattributes s’appelle k8s_attributes (et cumulativetodelta devient cumulative_to_delta) ; les anciens noms restent acceptés comme alias dépréciés. Le chart, qui réécrit par défaut ces anciens noms (rewriteDeprecatedComponentNames), place lui-même k8s_attributes dans les pipelines avec le preset ; l’écrire explicitement, comme ici, rend l’ordre visible. Si le chart signale un doublon dans votre version, retirez-le de la liste.

Étape 3 : installer le chart

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm repo update
helm upgrade --install otel-node open-telemetry/opentelemetry-collector \
  -n observability -f values.yaml

Étape 4 : pointer les applications vers le Collector du nœud

Chaque pod applicatif envoie sa télémétrie à l’IP de son nœud, grâce à la Downward API :

env:
  - name: NODE_IP
    valueFrom:
      fieldRef:
        fieldPath: status.hostIP
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: "http://$(NODE_IP):4318"
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: "http/protobuf"

Selon la version du chart, le port hôte 4318 est exposé par défaut en mode DaemonSet ; vérifiez la section ports de vos valeurs. Sinon, utilisez le Service créé par le chart.

Variante : l’OpenTelemetry Operator

L’Operator déclare le Collector comme une ressource Kubernetes. Ses webhooks ont besoin d’un certificat TLS : cert-manager par défaut, ou un certificat autosigné généré par le chart Helm (admissionWebhooks.autoGenerateCert). Après installation (chart open-telemetry/opentelemetry-operator), la même configuration s’écrit ainsi :

apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
  name: otel-node
  namespace: observability
spec:
  mode: daemonset
  image: otel/opentelemetry-collector-contrib:latest
  envFrom:
    - secretRef:
        name: dynatrace-otlp
  config:
    receivers:
      otlp:
        protocols:
          grpc: {}
          http: {}
    processors:
      k8s_attributes:
        auth_type: serviceAccount
        filter:
          node_from_env_var: K8S_NODE_NAME
        extract:
          metadata:
            - k8s.namespace.name
            - k8s.pod.name
            - k8s.deployment.name
            - k8s.node.name
        pod_association:
          - sources:
              - from: connection
      batch: {}
    exporters:
      otlphttp/dynatrace:
        endpoint: ${env:DT_ENDPOINT}
        headers:
          Authorization: "Api-Token ${env:DT_API_TOKEN}"
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [k8s_attributes, batch]
          exporters: [otlphttp/dynatrace]

Ici, vous gérez vous-même trois points que le preset Helm faisait : la variable K8S_NODE_NAME (à injecter via la Downward API spec.nodeName), le ClusterRole et son binding sur le ServiceAccount du Collector. En production, épinglez une version d’image précise plutôt que latest.

Comment vérifier que ça fonctionne

  1. Les pods du DaemonSet tournent, un par nœud :
    kubectl -n observability get pods -o wide
    kubectl -n observability logs ds/otel-node-opentelemetry-collector | grep -iE "error|refused|401|403"

    Un 401 ou 403 pointe vers le token ou ses scopes ; une erreur forbidden sur les pods pointe vers le RBAC de k8sattributes.

  2. En SaaS, ouvrez un Notebook et lancez :
    fetch spans, from: now() - 30m
    | filter isNotNull(k8s.pod.name)
    | summarize spans = count(), by: {k8s.namespace.name, k8s.deployment.name}
    | sort spans desc

    Si la requête ne renvoie rien alors que des spans existent, les attributs Kubernetes manquent : revoyez pod_association.

  3. En Managed, ouvrez la vue des traces distribuées, sélectionnez une trace et vérifiez que les attributs k8s.* apparaissent sur la ressource. Selon la version, certains attributs doivent être autorisés dans les réglages de capture des attributs OpenTelemetry : consultez la documentation de votre version.

Si rien n’arrive du tout, suivez la méthode de diagnostic des traces OpenTelemetry absentes.

Bonnes pratiques

  • Posez des limites de ressources sur le DaemonSet (resources.limits.memory) et alignez memory_limiter dessus.
  • N’extrayez que les labels utiles : chaque attribut ajoute du volume et du coût d’ingestion.
  • Séparez les rôles : DaemonSet pour l’enrichissement, Deployment passerelle pour l’échantillonnage (voir le tail sampling OpenTelemetry).
  • Surveillez le Collector lui-même : ses métriques internes (file d’export, rejets) sont votre premier SLI de pipeline.
  • Versionnez values.yaml et déployez-le par GitOps pour réduire le toil.

Questions fréquentes

Faut-il un Collector si OneAgent est déjà déployé ?

Pas forcément. OneAgent peut capter les spans OpenTelemetry de certains runtimes. Le Collector devient utile pour les workloads sans OneAgent, pour filtrer ou enrichir, ou pour une stratégie 100 % OpenTelemetry.

DaemonSet ou sidecar ?

Le DaemonSet consomme moins de ressources et se gère en un seul endroit. Le sidecar isole chaque application mais multiplie les Collectors. Commencez par le DaemonSet.

Les logs des conteneurs passent-ils par ce Collector ?

Seulement ceux envoyés en OTLP. Pour lire les fichiers de logs des conteneurs, il faut le receiver filelog (preset logsCollection du chart) ; c’est l’objet de l’article sur les logs OpenTelemetry.

Conclusion

Un collector OpenTelemetry Kubernetes en DaemonSet, avec k8sattributes, transforme des spans anonymes en données rattachées à un pod, un déploiement et un nœud. Le diagnostic devient plus rapide et vos SLO peuvent être découpés par service. Commencez par un namespace de test, validez la requête DQL, puis généralisez.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de Dynatrace LLC. Les noms d’options et de charts évoluent : vérifiez-les dans la documentation officielle de Dynatrace et d’OpenTelemetry.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Temporalité métriques OTLP vers Dynatrace : delta ou cumulative, l'erreur qui fait disparaître vos compteurs

Temporalité métriques OTLP vers Dynatrace : delta ou cumulative, l’erreur qui fait disparaître vos compteurs

Next Post
Logs OpenTelemetry : Dynatrace et la corrélation logs-traces par trace_id

Logs OpenTelemetry : Dynatrace et la corrélation logs-traces par trace_id

Related Posts