Monitorear RabbitMQ alojado en Kubernetes con OpenTelemetry

Monitoree RabbitMQ que se ejecuta en clústeres de Kubernetes utilizando el OpenTelemetry Collector con descubrimiento automático de pods. Esta guía le explica cómo desplegar el colector mediante Helm con detección dinámica de brokers basada en el observador de Kubernetes.

Sugerencia

¿Ejecuta RabbitMQ en hosts Linux? Consulte la guía de instalación autohospedada para implementaciones en máquinas virtuales o bare metal.

Cómo funciona la integración

Esta implementación nativa de Kubernetes proporciona descubrimiento y monitoreo automáticos:

Componentes clave:

Observador de Kubernetes: Observa continuamente los pods de RabbitMQ basándose en selectores de etiquetas
Creador de receptores: Crea dinámicamente receptores de RabbitMQ para cada pod descubierto
Atribución de recursos: Enriquece automáticamente las métricas con metadatos de Kubernetes:
- k8s.cluster.name - Su identificador de clúster
- k8s.namespace.name - Espacio de nombres del pod
- k8s.pod.name - Nombre del pod individual
- rabbitmq.deployment.name - Derivado del nombre del pod

Modelo de despliegue: El recopilador se ejecuta como un despliegue de Kubernetes (réplica única) con permisos RBAC para listar y observar pods en todos los espacios de nombres. Cuando se crean nuevos pods de RabbitMQ o se eliminan los existentes, el observador actualiza automáticamente la configuración del colector.

Importante

El recopilador requiere permisos de get, list y watch en los pods para descubrir instancias de RabbitMQ automáticamente.

Pasos de instalación

Siga estos pasos para desplegar el OpenTelemetry Collector con monitoreo de RabbitMQ.

Antes de que empieces

Asegúrese de que su entorno cumpla con estos requisitos:

Verificar el punto de conexión de gestión

Asegúrese de que los pods de RabbitMQ tengan habilitado el plugin de administración:

bash

$kubectl exec deploy/<your-rabbitmq-deployment> -n <rabbitmq-namespace> -- curl -I -u admin:password http://localhost:15672/api/overview

Debería ver HTTP/1.1 200 OK en la respuesta.

Crear archivo de valores de Helm

Cree un archivo llamado otel-collector-values.yaml. Esta configuración utiliza el receiver_creator con k8s_observer para descubrir automáticamente pods de RabbitMQ.

Actualice estos marcadores de posición:

my-rabbitmq-cluster: Nombre de su clúster de Kubernetes
rabbitmq: El valor de la etiqueta app para sus pods de RabbitMQ
admin/password: Sus credenciales de RabbitMQ

15672: El puerto de la API de gestión

opentelemetry-collector:
  mode: deployment

  image:
    repository: otel/opentelemetry-collector-contrib
    pullPolicy: IfNotPresent

  command:
    name: otelcol-contrib

  resources:
    limits:
      cpu: 500m
      memory: 300Mi
    requests:
      cpu: 100m
      memory: 100Mi

  extraEnvs:
    - name: NEWRELIC_LICENSE_KEY
      valueFrom:
        secretKeyRef:
          name: newrelic-licenses
          key: NEWRELIC_LICENSE_KEY
    - name: NEWRELIC_OTLP_ENDPOINT
      valueFrom:
        secretKeyRef:
          name: newrelic-licenses
          key: NEWRELIC_OTLP_ENDPOINT
    - name: K8S_NODE_NAME
      valueFrom:
        fieldRef:
          fieldPath: spec.nodeName
    - name: K8S_CLUSTER_NAME
      value: my-rabbitmq-cluster
    - name: RABBITMQ_USERNAME
      value: admin
    - name: RABBITMQ_PASSWORD
      value: password

  clusterRole:
    create: true
    rules:
      - apiGroups: [""]
        resources: ["pods", "nodes", "nodes/stats", "nodes/proxy"]
        verbs: ["get", "list", "watch"]
      - apiGroups: ["apps"]
        resources: ["replicasets", "deployments", "statefulsets"]
        verbs: ["get", "list", "watch"]

  clusterRoleBinding:
    name: ""

  config:
    extensions:
      health_check:
        endpoint: 0.0.0.0:13133

      k8s_observer:
        auth_type: serviceAccount
        observe_pods: true
        observe_nodes: false

    receivers:
      receiver_creator/rabbitmq:
        watch_observers: [k8s_observer]
        receivers:
          rabbitmq:
            # Discover pods with label "app=rabbitmq"
            # Adjust the label selector to match your RabbitMQ pods
            rule: type == "pod" && labels["app"] == "rabbitmq"
            config:
              endpoint: 'http://`endpoint`:15672'
              username: ${env:RABBITMQ_USERNAME}
              password: ${env:RABBITMQ_PASSWORD}
              collection_interval: 30s
              metrics:
                # Queue Metrics (essential for message flow and backlog)
                rabbitmq.consumer.count:
                  enabled: true
                rabbitmq.message.delivered:
                  enabled: true
                rabbitmq.message.published:
                  enabled: true
                rabbitmq.message.acknowledged:
                  enabled: true
                rabbitmq.message.dropped:
                  enabled: true
                rabbitmq.message.current:
                  enabled: true # Crucial for monitoring queue backlog, includes 'ready' and 'unacknowledged' states

                # Node Health Metrics (critical for server resource monitoring)
                rabbitmq.node.disk_free:
                  enabled: true
                rabbitmq.node.disk_free_limit:
                  enabled: true
                rabbitmq.node.disk_free_alarm:
                  enabled: true
                rabbitmq.node.mem_used:
                  enabled: true
                rabbitmq.node.mem_limit:
                  enabled: true
                rabbitmq.node.mem_alarm:
                  enabled: true
                rabbitmq.node.mem_used_details.rate:
                  enabled: true
                rabbitmq.node.fd_used:
                  enabled: true
                rabbitmq.node.fd_total:
                  enabled: true
                rabbitmq.node.sockets_used:
                  enabled: true
                rabbitmq.node.sockets_total:
                  enabled: true
                rabbitmq.node.proc_used:
                  enabled: true
                rabbitmq.node.proc_total:
                  enabled: true
                rabbitmq.node.uptime:
                  enabled: true
                rabbitmq.node.run_queue:
                  enabled: true
                rabbitmq.node.processors:
                  enabled: true
                rabbitmq.node.context_switches_details.rate:
                  enabled: true
                rabbitmq.node.gc_num_details.rate:
                  enabled: true
                rabbitmq.node.gc_bytes_reclaimed_details.rate:
                  enabled: true

                # I/O Metrics (important for understanding disk and network activity)
                rabbitmq.node.io_read_count_details.rate:
                  enabled: true
                rabbitmq.node.io_read_bytes_details.rate:
                  enabled: true
                rabbitmq.node.io_read_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_write_count_details.rate:
                  enabled: true
                rabbitmq.node.io_write_bytes_details.rate:
                  enabled: true
                rabbitmq.node.io_write_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_sync_count_details.rate:
                  enabled: true
                rabbitmq.node.io_sync_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_seek_count_details.rate:
                  enabled: true
                rabbitmq.node.io_seek_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_reopen_count_details.rate:
                  enabled: true

                # Mnesia and Store Metrics (for internal database and message storage)
                rabbitmq.node.mnesia_ram_tx_count_details.rate:
                  enabled: true
                rabbitmq.node.mnesia_disk_tx_count_details.rate:
                  enabled: true
                rabbitmq.node.msg_store_read_count_details.rate:
                  enabled: true
                rabbitmq.node.msg_store_write_count_details.rate:
                  enabled: true
                rabbitmq.node.queue_index_write_count_details.rate:
                  enabled: true
                rabbitmq.node.queue_index_read_count_details.rate:
                  enabled: true

                # Connection/Channel/Queue Lifecycle Metrics
                rabbitmq.node.connection_created_details.rate:
                  enabled: true
                rabbitmq.node.connection_closed_details.rate:
                  enabled: true
                rabbitmq.node.channel_created_details.rate:
                  enabled: true
                rabbitmq.node.channel_closed_details.rate:
                  enabled: true
                rabbitmq.node.queue_declared_details.rate:
                  enabled: true
                rabbitmq.node.queue_created_details.rate:
                  enabled: true
                rabbitmq.node.queue_deleted_details.rate:
                  enabled: true

              resource_attributes:
                rabbitmq.server.endpoint: 'http://`endpoint`:15672'
                rabbitmq.port: '15672'

    processors:
      batch:
        send_batch_size: 1024
        timeout: 30s

      resource/cluster:
        attributes:
          - key: k8s.cluster.name
            value: ${env:K8S_CLUSTER_NAME}
            action: upsert

      transform/rabbitmq:
        metric_statements:
          - context: resource
            statements:
              # Create a display name combining Kubernetes metadata
              - set(attributes["rabbitmq.display.name"], Concat([
                  "server",
                  "k8s",
                  attributes["k8s.cluster.name"],
                  attributes["k8s.namespace.name"],
                  "pod",
                  attributes["k8s.pod.name"],
                  "rabbitmq",
                  attributes["rabbitmq.port"]
                ], ":"))
              # Use pod name as deployment name
              - set(attributes["rabbitmq.deployment.name"], attributes["k8s.pod.name"])

    exporters:
      otlphttp:
        endpoint: "${NEWRELIC_OTLP_ENDPOINT}"
        headers:
          api-key: "${NEWRELIC_LICENSE_KEY}"
        compression: gzip

    service:
      extensions: [health_check, k8s_observer]
      pipelines:
        metrics/rabbitmq:
          receivers: [receiver_creator/rabbitmq]
          processors: [batch, resource/cluster, transform/rabbitmq]
          exporters: [otlphttp]

Sugerencia

Personalización del selector de etiquetas: Si sus pods de RabbitMQ utilizan etiquetas diferentes, actualice la línea rule. Por ejemplo:

Pods de StatefulSet: type == "pod" && labels["app.kubernetes.io/name"] == "rabbitmq"
Implementaciones del operador: type == "pod" && labels["app.kubernetes.io/component"] == "rabbitmq"
Ejecute kubectl get pods --show-labels -n <namespace> para ver las etiquetas de su pod.

Crear secreto de Kubernetes

Guarde sus credenciales de New Relic en un secreto de Kubernetes.

Selecciona la región que corresponde a tu cuenta de New Relic (revisa la URL de tu navegador cuando inicies sesión en New Relic):

bash

$kubectl create secret generic newrelic-licenses \
>  --from-literal=NEWRELIC_LICENSE_KEY=YOUR_LICENSE_KEY \
>  --from-literal=NEWRELIC_OTLP_ENDPOINT=https://otlp.nr-data.net:4318 \
>  --namespace newrelic

Reemplaza YOUR_LICENSE_KEY por tu clave de licencia de New Relic.

bash

$kubectl create secret generic newrelic-licenses \
>  --from-literal=NEWRELIC_LICENSE_KEY=YOUR_LICENSE_KEY \
>  --from-literal=NEWRELIC_OTLP_ENDPOINT=https://otlp.eu01.nr-data.net:4318 \
>  --namespace newrelic

Reemplaza YOUR_LICENSE_KEY por tu clave de licencia de New Relic.

Desplegar con Helm

Agregue el repositorio Helm de OpenTelemetry:

bash

$helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
$helm repo update

Instale o actualice el colector:

bash

$helm upgrade --install rabbitmq-otel-collector \
>  open-telemetry/opentelemetry-collector \
>  --namespace newrelic \
>  --create-namespace \
>  --values otel-collector-values.yaml

Esto crea:

Una implementación llamada rabbitmq-otel-collector en el espacio de nombres newrelic
Una cuenta de servicio con permisos RBAC para observar pods
ConfigMaps que contienen la configuración del recopilador

Verifique el despliegue y el flujo de datos

Compruebe que el pod del colector se esté ejecutando:

bash

$kubectl get pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector

Resultado esperado:

NAME                                 READY   STATUS    RESTARTS   AGE
rabbitmq-otel-collector-6d8c5c5d8d-abc12   1/1     Running   0          2m

Vea los logs del recopilador para verificar el descubrimiento de pods:

bash

$kubectl logs deploy/rabbitmq-otel-collector -n newrelic --tail=50

Busque mensajes que indiquen el descubrimiento de pods y la recolección de métricas exitosos:

INFO    k8sobserver/extension.go:150    Discovered pod {"kind": "pod", "name": "rabbitmq-0", "namespace": "default"}
INFO    RabbitmqReceiver                Successfully scraped rabbitmq metrics from pod rabbitmq-0

Verifique sus datos en New Relic:

Espere de 2 a 3 minutos para que aparezcan los datos, luego ejecute esta consulta en el generador de consultas:

SELECT count(*)
FROM Metric
WHERE metricName LIKE 'rabbitmq.%'
  AND instrumentation.provider = 'opentelemetry'
  AND k8s.cluster.name = 'my-rabbitmq-cluster'
FACET k8s.pod.name, metricName
SINCE 10 minutes ago

Debería ver métricas de cada pod de RabbitMQ con atributos de Kubernetes:

k8s.cluster.name - Su identificador de clúster
k8s.namespace.name - Espacio de nombres del pod
k8s.pod.name - Nombre del pod individual
rabbitmq.deployment.name - Derivado del nombre del pod

Sugerencia

Si no ve datos después de 5 minutos, consulte la sección de solución de problemas a continuación.

Resolución de problemas

Si las métricas no aparecen en New Relic después del despliegue:

1. Verifique que el plugin de administración de RabbitMQ esté habilitado:

bash

$kubectl exec <rabbitmq-pod> -n <namespace> -- rabbitmq-plugins list | grep management

Debería ver [E*] rabbitmq_management que indica que está habilitado.

2. Revise los logs del pod del colector:

bash

$kubectl logs deploy/rabbitmq-otel-collector -n newrelic --tail=100

Buscar:

Mensajes de descubrimiento de pods
Errores de autenticación (credenciales incorrectas)
Errores de conexión (problemas de red)
Errores de análisis (problemas de configuración)

3. Verifique que el servicio RabbitMQ esté accesible:

bash

$kubectl get svc -n <rabbitmq-namespace>

Asegúrese de que haya un servicio que exponga el puerto 15672.

4. Pruebe la API de gestión desde dentro del clúster:

bash

$kubectl run test-pod --image=curlimages/curl:latest --rm -it --restart=Never -- \
>  curl -I -u admin:password http://<rabbitmq-service>.<namespace>.svc.cluster.local:15672/api/overview

Debería devolver HTTP/1.1 200 OK.

5. Verifique los permisos RBAC:

bash

$kubectl auth can-i list pods --as=system:serviceaccount:newrelic:rabbitmq-otel-collector -n <rabbitmq-namespace>

Debería devolver yes. Si no, verifique el ClusterRole y el ClusterRoleBinding.

Si el colector no descubre los pods de RabbitMQ automáticamente:

1. Verifique que el selector de etiquetas coincida con sus pods:

bash

$kubectl get pods --show-labels -n <rabbitmq-namespace>

Compare las etiquetas con el rule en su archivo de valores de Helm.

2. Verifique los logs de k8s_observer:

bash

$kubectl logs deploy/rabbitmq-otel-collector -n newrelic | grep k8sobserver

Busque mensajes sobre pods descubiertos.

3. Pruebe el selector de etiquetas:

bash

$kubectl get pods -l app=rabbitmq --all-namespaces

Esto debería listar sus pods de RabbitMQ. Si está vacío, su selector de etiquetas es incorrecto.

4. Verificar los permisos de ClusterRole:

bash

$kubectl describe clusterrole rabbitmq-otel-collector

Asegúrese de que tenga permisos de get, list y watch en los pods.

Patrones de etiquetas comunes:

Implementaciones estándar: app=rabbitmq
StatefulSets: app.kubernetes.io/name=rabbitmq
Operadores: app.kubernetes.io/component=rabbitmq

Si ve errores de conexión en los logs del colector:

Verificar los endpoints del servicio:

bash

$kubectl get endpoints -n <rabbitmq-namespace>

Verifique que existan endpoints para su servicio de RabbitMQ.

Verifique las políticas de red: Asegúrese de que las políticas de red permitan el tráfico desde el espacio de nombres newrelic hacia su espacio de nombres de RabbitMQ.

Probar conectividad:

bash

$kubectl run test-pod --image=curlimages/curl:latest --rm -it --restart=Never -n newrelic -- \
>  curl http://<rabbitmq-service>.<namespace>.svc.cluster.local:15672/api/overview

Verificar la resolución de DNS:

bash

$kubectl run test-pod --image=busybox:latest --rm -it --restart=Never -n newrelic -- \
>  nslookup <rabbitmq-service>.<namespace>.svc.cluster.local

Si ve advertencias de alta cardinalidad en New Relic:

Filtrar por colas específicas: Si monitorea muchas colas, considere filtrar solo las críticas.

Aumentar el intervalo de recolección:

receivers:
  receiver_creator/rabbitmq:
    receivers:
      rabbitmq:
        config:
          collection_interval: 60s # Increased from 30s

Use la agregación de métricas: Configure el procesador por lotes para agregar métricas antes de exportar.

Deshabilite las métricas menos críticas: Comente las métricas que no necesite en la configuración del receptor.

Consejos adicionales de optimización:

Utilice selectores de etiquetas más específicos para monitorear solo los pods de producción
Filtre colas específicas por nombre en lugar de monitorear todas las colas
Aumente el collection_interval para reducir los puntos de datos
Considere usar la agregación de métricas en el colector

Si el pod del colector está fallando:

Verificar los límites de recursos:

bash

$kubectl describe pod -n newrelic -l app.kubernetes.io/name=opentelemetry-collector

Busque el estado OOMKilled. Si es así, aumente los límites de memoria:

resources:
  limits:
    memory: 512Mi # Increased from 300Mi

Revisar los logs de fallos:

bash

$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector --previous

Verifique la sintaxis de configuración: Asegúrese de que su configuración YAML sea válida y esté correctamente indentada.

Si ve errores 401 Unauthorized:

Verifique que las credenciales en los valores de Helm coincidan con su configuración de RabbitMQ:

bash

$kubectl exec <rabbitmq-pod> -n <namespace> -- rabbitmqctl list_users

Verifique que el usuario de RabbitMQ tenga privilegios de administrador y asegúrese de que las credenciales no contengan caracteres especiales que requieran escape.

¿Que sigue?

Ahora que tiene configurado el monitoreo de RabbitMQ, puede mejorar su observabilidad:

Explore sus datos:

Explora las métricas de RabbitMQ - Lista completa de métricas con ejemplos de consultas NRQL

Mejorar el monitoreo:

Crear alertas - Configura alertas para la profundidad de las colas y la salud de los pods
Crear paneles - Cree paneles personalizados para visualizar sus métricas de RabbitMQ

Te ofrecemos esta traducción automática para facilitar la lectura.

Monitorear RabbitMQ alojado en Kubernetes con OpenTelemetry

Sugerencia

Cómo funciona la integración

Importante

Pasos de instalación

Antes de que empieces

Requisitos del clúster de Kubernetes

Requisitos de RabbitMQ

Requisitos de New Relic

Verificar el punto de conexión de gestión

Crear archivo de valores de Helm

Sugerencia

Crear secreto de Kubernetes

Desplegar con Helm

Verifique el despliegue y el flujo de datos

Sugerencia

Resolución de problemas

No aparecen datos en New Relic

El descubrimiento de pods no funciona

Errores de conexión

Advertencias de alta cardinalidad

Pod del Collector fallando o reiniciándose

Fallas de autenticación

¿Que sigue?

Te ofrecemos esta traducción automática para facilitar la lectura.

Monitorear RabbitMQ alojado en Kubernetes con OpenTelemetry

Sugerencia

Cómo funciona la integración .css-21sua1{background:none;border:none;width:0;padding:0;}

Importante

Pasos de instalación

Antes de que empieces

Requisitos de RabbitMQ

Requisitos de New Relic

Verificar el punto de conexión de gestión

Crear archivo de valores de Helm

Sugerencia

Crear secreto de Kubernetes

Desplegar con Helm

Verifique el despliegue y el flujo de datos

Sugerencia

Resolución de problemas

No aparecen datos en New Relic

El descubrimiento de pods no funciona

Errores de conexión

Advertencias de alta cardinalidad

Pod del Collector fallando o reiniciándose

Fallas de autenticación

¿Que sigue?

Cómo funciona la integración