Collector de OpenTelemetry en Kubernetes hacia Dynatrace: Helm, Operator y k8sattributes

Collector de OpenTelemetry en Kubernetes: despliégalo como DaemonSet con Helm o el Operator, enriquece con k8sattributes y exporta a Dynatrace.
Collector OpenTelemetry Kubernetes vers Dynatrace : Helm, Operator et k8sattributes

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, kubectl y Helm 3.
  • Un token de API de Dynatrace con los scopes openTelemetryTrace.ingest, metrics.ingest y logs.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).
  • 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 contiene k8sattributes y cumulative_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_limiter en 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

  1. 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 401 o 403 apunta al token o a sus scopes; un error forbidden sobre los pods apunta al RBAC de k8sattributes.

  2. 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 desc

    Si la consulta no devuelve nada aunque existan spans, faltan los atributos de Kubernetes: revisa pod_association.

  3. 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 alinea memory_limiter con 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.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

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

Temporalidad de las métricas OTLP hacia Dynatrace: delta o cumulative, el error que hace desaparecer tus contadores

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

Logs de OpenTelemetry en Dynatrace: correlación entre logs y trazas por trace_id

Related Posts