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,
kubectlet Helm 3. - Un token d’API Dynatrace avec les scopes
openTelemetryTrace.ingest,metrics.ingestetlogs.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).
- SaaS :
- 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 contientk8sattributesetcumulative_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_limiteren 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
- 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
401ou403pointe vers le token ou ses scopes ; une erreurforbiddensur les pods pointe vers le RBAC dek8sattributes. - 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 descSi la requête ne renvoie rien alors que des spans existent, les attributs Kubernetes manquent : revoyez
pod_association. - 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 alignezmemory_limiterdessus. - 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.