Despliega OpenTelemetry Collector en Kubernetes: Observabilidad Total para tus Aplicaciones

Hoy vamos a desplegar OpenTelemetry Collector en tu clúster de Kubernetes sobre VPS. Si no tienes muy claro qué es OpenTelemetry, piensa en ello como el estándar moderno para obtener métricas, logs y trazas de tus aplicaciones, permitiendo que detectes cuellos de botella, errores y problemas de rendimiento mucho más fácilmente. Prepárate porque con este despliegue, tu infraestructura casera puede igualar a la de los grandes nombres, y con un toque pro: ¡tú tienes el control!

¿Para qué sirve OpenTelemetry Collector?

• Reúne métricas, logs y trazas desde todas tus apps y servicios en Kubernetes.
• Agrega, transforma y exporta los datos a sistemas como Prometheus, Jaeger o Elastic.
• Centraliza la observabilidad sin necesitar agentes específicos para cada lenguaje.
• Facilita el diagnóstico de problemas de rendimiento y permite analizar el comportamiento de apps distribuidas ¡incluyendo microservicios!

Arquitectura: ¿qué vamos a desplegar?

Usaremos los siguientes componentes:

• Un Deployment de OpenTelemetry Collector configurado como gateway (recibe datos de los agentes sidecar o instrumentados en tus apps y los exporta a Prometheus y Jaeger).
• Un Service para hacerlo accesible en el clúster.
• Un ConfigMap con la configuración de pipelines para métricas y trazas.

💡 Puedes adaptar la configuración para enviar los datos a tu stack favorito, pero en este ejemplo cubrimos Prometheus y Jaeger como destinos estándar.

Ficheros YAML necesarios

Aquí tienes todo lo necesario para ponerlo a funcionar. Puedes adaptar los nombres de namespace y endpoints según tu entorno.

1. ConfigMap para la configuración del Collector

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-collector-config
  namespace: observabilidad
data:
  otel-collector-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
          http:
      prometheus:
        config:
          scrape_configs:
            - job_name: 'kubernetes-nodes'
              kubernetes_sd_configs:
                - role: node
            - job_name: 'kubernetes-pods'
              kubernetes_sd_configs:
                - role: pod
    processors:
      batch:
      memory_limiter:
        check_interval: 1s
        limit_mib: 400
        spike_limit_mib: 60
    exporters:
      jaeger:
        endpoint: "jaeger-collector.observabilidad.svc.cluster.local:14250"
        tls:
          insecure: true
      prometheus:
        endpoint: "0.0.0.0:8888"
        namespace: "otel-collector"
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [batch, memory_limiter]
          exporters: [jaeger]
        metrics:
          receivers: [otlp, prometheus]
          processors: [batch]
          exporters: [prometheus]

2. Deployment para OpenTelemetry Collector

apiVersion: apps/v1
kind: Deployment
metadata:
  name: otel-collector
  namespace: observabilidad
spec:
  replicas: 1
  selector:
    matchLabels:
      app: otel-collector
  template:
    metadata:
      labels:
        app: otel-collector
    spec:
      containers:
        - name: otel-collector
          image: otel/opentelemetry-collector:0.96.0
          args:
            - "--config=/conf/otel-collector-config.yaml"
          ports:
            - containerPort: 4317 # OTLP gRPC
            - containerPort: 4318 # OTLP HTTP
            - containerPort: 8888 # Prometheus exporter
          volumeMounts:
            - name: otel-config
              mountPath: /conf
      volumes:
        - name: otel-config
          configMap:
            name: otel-collector-config

3. Service para exponer los endpoints del Collector

apiVersion: v1
kind: Service
metadata:
  name: otel-collector
  namespace: observabilidad
spec:
  selector:
    app: otel-collector
  ports:
    - name: otlp-grpc
      protocol: TCP
      port: 4317
      targetPort: 4317
    - name: otlp-http
      protocol: TCP
      port: 4318
      targetPort: 4318
    - name: prometheus
      protocol: TCP
      port: 8888
      targetPort: 8888

4. (Opcional) Namespace de trabajo

Recomiendo tener los recursos en el namespace observabilidad:

apiVersion: v1
kind: Namespace
metadata:
  name: observabilidad

¿Cómo probarlo?

• Despliega Jaeger (puedes usar jaeger-all-in-one) en el mismo namespace.
• Apunta los SDK OTLP de tus apps o sidecars (instrumentación automática) a otel-collector.observabilidad.svc.cluster.local.
• Prometheus puede recoger métricas en el endpoint http://otel-collector.observabilidad.svc.cluster.local:8888/metrics.
• Lanza alguna petición a tu app y observa las trazas en la UI de Jaeger y las métricas en Prometheus.

Consejos Extra y Troubleshooting

• Depuración básica: Si no ves trazas en Jaeger, mira los logs del pod del collector con kubectl logs para pistas de errores de configuración o conexión.
• Rendimiento: Si procesas grandes volúmenes, escala el deployment y ajusta los límites en memory_limiter.
• Personalización: Prueba a exportar datos también a Elastic, Loki, Tempo… ¡OpenTelemetry collector es muy versátil!
• Utiliza OpenTelemetry Operator para despliegues más complejos o automáticos en todo el clúster.

Como ves, la observabilidad de nueva generación ya no es exclusiva de grandes empresas. ¡Exprímela en tu Kubernetes y lleva tus despliegues caseros a otro nivel!