Tus pods envían trazas de OpenTelemetry, pero en Dynatrace llegan sin nombre de pod, sin namespace, sin nodo. Es imposible relacionar una latencia con un despliegue concreto, y el MTTR se alarga. Desplegar un Collector de OpenTelemetry en Kubernetes, enriquecido con el processor k8sattributes, resuelve el problema en el origen.
Objetivo de este tutorial: instalar un Collector en el clúster con Helm (o con el OpenTelemetry Operator), añadir los metadatos de Kubernetes a cada span, métrica y log, y exportarlo todo en OTLP hacia Dynatrace. El contenido sirve para Dynatrace SaaS y Dynatrace Managed; solo cambia la URL de ingesta.
Si descubres ahora el Collector, empieza por el Collector de OpenTelemetry hacia Dynatrace, que detalla el pipeline receivers → processors → exporters fuera de Kubernetes.
Requisitos previos
- Un clúster de Kubernetes 1.26 o superior,
kubectly Helm 3. - Un token de API de Dynatrace con los scopes
openTelemetryTrace.ingest,metrics.ingestylogs.ingest. - La URL OTLP de tu entorno:
- SaaS:
https://<env-id>.live.dynatrace.com/api/v2/otlp; - Managed:
https://<votre-domaine>/e/<env-id>/api/v2/otlp(o mediante un ActiveGate de entorno).
- SaaS:
- Aplicaciones ya instrumentadas con un SDK o un agente de OpenTelemetry (por ejemplo el agente de OpenTelemetry para Java).
¿Qué modo de despliegue elegir?
- DaemonSet: un Collector por nodo. Los pods envían su telemetría al Collector local. Es el modo recomendado para
k8sattributes, porque el Collector solo vigila los pods de su nodo. - Deployment: un pool de Collectors detrás de un Service. Útil como pasarela central, por ejemplo para el muestreo.
- Dynatrace Operator: gestiona OneAgent y ActiveGate. No lo confundas con el OpenTelemetry Operator, que gestiona Collectors y la autoinstrumentación. Ambos pueden convivir en el mismo clúster.
Este tutorial usa un DaemonSet. Si OneAgent también se ejecuta en el clúster, lee cómo evitar los spans duplicados antes de activar los dos.
Instalar el Collector de OpenTelemetry en Kubernetes con Helm
Paso 1: crear el namespace y el secreto
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'
El token se queda en un Secret, nunca en el archivo de valores versionado.
Paso 2: escribir el archivo 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]
Las líneas críticas:
image.repository: la imagen contrib contienek8sattributesycumulative_to_delta. Dynatrace publica también su propia distribución del Collector; comprueba en docs.dynatrace.com la imagen y los componentes que incluye.presets.kubernetesAttributes: el chart añade el processor y crea el ClusterRole que le permite leer pods, namespaces y ReplicaSets.cumulative_to_delta: Dynatrace espera métricas OTLP con temporalidad delta. El detalle está en la temporalidad de las métricas OTLP.memory_limiteren primer lugar: protege el nodo si Dynatrace se ralentiza.
En las versiones recientes del Collector contrib, el processor k8sattributes se llama k8s_attributes (y cumulativetodelta pasa a ser cumulative_to_delta); los nombres antiguos siguen aceptándose como alias obsoletos. El chart, que reescribe por defecto esos nombres antiguos (rewriteDeprecatedComponentNames), coloca él mismo k8s_attributes en los pipelines con el preset; escribirlo de forma explícita, como aquí, hace visible el orden. Si el chart señala un duplicado en tu versión, quítalo de la lista.
Paso 3: instalar el 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
Paso 4: apuntar las aplicaciones al Collector del nodo
Cada pod de aplicación envía su telemetría a la IP de su nodo, gracias a 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"
Según la versión del chart, el puerto de host 4318 se expone por defecto en modo DaemonSet; comprueba la sección ports de tus valores. Si no, usa el Service que crea el chart.
Variante: el OpenTelemetry Operator
El Operator declara el Collector como un recurso de Kubernetes. Sus webhooks necesitan un certificado TLS: cert-manager por defecto, o un certificado autofirmado generado por el chart de Helm (admissionWebhooks.autoGenerateCert). Tras la instalación (chart open-telemetry/opentelemetry-operator), la misma configuración se escribe así:
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]
Aquí gestionas tú mismo tres puntos que el preset de Helm resolvía: la variable K8S_NODE_NAME (que se inyecta con la Downward API spec.nodeName), el ClusterRole y su binding al ServiceAccount del Collector. En producción, fija una versión de imagen concreta en lugar de latest.
Cómo comprobar que funciona
- Los pods del DaemonSet están en marcha, uno por nodo:
kubectl -n observability get pods -o wide kubectl -n observability logs ds/otel-node-opentelemetry-collector | grep -iE "error|refused|401|403"Un
401o403apunta al token o a sus scopes; un errorforbiddensobre los pods apunta al RBAC dek8sattributes. - En SaaS, abre un Notebook y lanza:
fetch spans, from: now() - 30m | filter isNotNull(k8s.pod.name) | summarize spans = count(), by: {k8s.namespace.name, k8s.deployment.name} | sort spans descSi la consulta no devuelve nada aunque existan spans, faltan los atributos de Kubernetes: revisa
pod_association. - En Managed, abre la vista de trazas distribuidas, selecciona una traza y comprueba que los atributos
k8s.*aparecen en el recurso. Según la versión, algunos atributos deben autorizarse en los ajustes de captura de atributos de OpenTelemetry: consulta la documentación de tu versión.
Si no llega nada en absoluto, sigue el método de diagnóstico de las trazas de OpenTelemetry ausentes.
Buenas prácticas
- Define límites de recursos en el DaemonSet (
resources.limits.memory) y alineamemory_limitercon ellos. - Extrae solo las etiquetas útiles: cada atributo añade volumen y coste de ingesta.
- Separa los roles: DaemonSet para el enriquecimiento, Deployment como pasarela para el muestreo (consulta el tail sampling de OpenTelemetry).
- Monitoriza el propio Collector: sus métricas internas (cola de exportación, rechazos) son tu primer SLI de pipeline.
- Versiona values.yaml y despliégalo con GitOps para reducir el toil.
Preguntas frecuentes
¿Hace falta un Collector si OneAgent ya está desplegado?
No necesariamente. OneAgent puede capturar los spans de OpenTelemetry de algunos runtimes. El Collector resulta útil para las cargas de trabajo sin OneAgent, para filtrar o enriquecer, o para una estrategia 100 % OpenTelemetry.
¿DaemonSet o sidecar?
El DaemonSet consume menos recursos y se gestiona en un único lugar. El sidecar aísla cada aplicación, pero multiplica los Collectors. Empieza por el DaemonSet.
¿Los logs de los contenedores pasan por este Collector?
Solo los que se envían en OTLP. Para leer los archivos de logs de los contenedores hace falta el receiver filelog (preset logsCollection del chart); es el tema de el artículo sobre los logs de OpenTelemetry.
Conclusión
Un Collector de OpenTelemetry en Kubernetes como DaemonSet, con k8sattributes, convierte spans anónimos en datos asociados a un pod, un despliegue y un nodo. El diagnóstico se acelera y tus SLO pueden desglosarse por servicio. Empieza por un namespace de pruebas, valida la consulta DQL y generaliza después.
span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión. Los nombres de opciones y de charts evolucionan: compruébalos en la documentación oficial de Dynatrace y de OpenTelemetry.