Monitorer RabbitMQ hébergé sur Kubernetes avec OpenTelemetry

Monitorez RabbitMQ exécuté dans des clusters Kubernetes à l'aide de l'OpenTelemetry Collector avec découverte automatique des pods. Ce guide vous accompagne dans le déploiement du collecteur via Helm avec la détection dynamique des brokers assurée par l'observateur Kubernetes.

Conseil

Vous exécutez RabbitMQ sur des hôtes Linux ? Consultez le guide d'installation auto-hébergée pour les déploiements sur machine virtuelle ou bare metal.

Fonctionnement de l'intégration

Ce déploiement natif Kubernetes fournit une découverte et un monitoring automatiques :

Composants clés :

Observateur Kubernetes: surveille en continu les pods RabbitMQ basés sur des sélecteurs de labels
Créateur de récepteurs: Crée dynamiquement des récepteurs RabbitMQ pour chaque pod découvert
Attribution des ressources: enrichit automatiquement les métriques avec les métadonnées Kubernetes :
- k8s.cluster.name - Votre identifiant de cluster
- k8s.namespace.name - Espace de noms du pod
- k8s.pod.name - Nom du pod individuel
- rabbitmq.deployment.name - Dérivé du nom du pod

Modèle de déploiement : Le collecteur s'exécute en tant que déploiement Kubernetes (réplica unique) avec des permissions RBAC pour lister et surveiller les pods dans les espaces de noms. Lorsque de nouveaux pods RabbitMQ sont créés ou que des pods existants sont supprimés, l'observateur met automatiquement à jour la configuration du collecteur.

Important

Le collecteur nécessite les permissions get, list et watch sur les pods pour découvrir automatiquement les instances RabbitMQ.

Étapes d'installation

Suivez ces étapes pour déployer le collecteur OpenTelemetry avec le monitoring de RabbitMQ.

Avant de commencer

Assurez-vous que votre environnement répond à ces exigences :

Vérifier le point de terminaison de gestion

Assurez-vous que le plugin de gestion est activé sur les pods RabbitMQ :

bash

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

Vous devriez voir HTTP/1.1 200 OK dans la réponse.

Créer un fichier de valeurs Helm

Créez un fichier nommé otel-collector-values.yaml. Cette configuration utilise le receiver_creator avec k8s_observer pour découvrir automatiquement les pods RabbitMQ.

Mettez à jour ces espaces réservés :

my-rabbitmq-cluster: Votre nom de cluster Kubernetes
rabbitmq: La valeur de l'étiquette app pour vos pods RabbitMQ
admin/password: Vos identifiants RabbitMQ

15672: Le port de l'API de gestion

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]

Conseil

Personnalisation du sélecteur d'étiquettes : Si vos pods RabbitMQ utilisent des étiquettes différentes, mettez à jour la ligne rule. Par exemple :

Pods StatefulSet : type == "pod" && labels["app.kubernetes.io/name"] == "rabbitmq"
Déploiements d'opérateurs : type == "pod" && labels["app.kubernetes.io/component"] == "rabbitmq"
Exécutez kubectl get pods --show-labels -n <namespace> pour afficher les labels de vos pods.

Créer un secret Kubernetes

Stockez vos identifiants New Relic dans un secret Kubernetes.

Sélectionnez la région qui correspond à votre compte New Relic (vérifiez l'URL de votre navigateur lorsque vous êtes connecté à 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

Remplacez YOUR_LICENSE_KEY par votre clé de licence 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

Remplacez YOUR_LICENSE_KEY par votre clé de licence New Relic.

Déployer avec Helm

Ajouter le dépôt Helm OpenTelemetry :

bash

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

Installer ou mettre à jour le collecteur :

bash

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

Cela crée :

Un déploiement nommé rabbitmq-otel-collector dans l'espace de noms newrelic
Un compte de service avec des permissions RBAC pour surveiller les pods
ConfigMaps contenant la configuration du collecteur

Vérifier le déploiement et le flux de données

Vérifiez que le pod du collecteur est en cours d'exécution :

bash

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

Résultat attendu :

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

Consultez les logs du collecteur pour vérifier la découverte des pods :

bash

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

Recherchez des messages indiquant la réussite de la découverte des pods et de la collecte de métriques :

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

Vérifiez vos données dans New Relic :

Attendez 2 à 3 minutes que les données apparaissent, puis exécutez cette requête dans le générateur de requêtes:

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

Vous devriez voir des métriques de chaque pod RabbitMQ avec des attributs Kubernetes :

k8s.cluster.name - Votre identifiant de cluster
k8s.namespace.name - Espace de noms du pod
k8s.pod.name - Nom du pod individuel
rabbitmq.deployment.name - Dérivé du nom du pod

Conseil

Si vous ne voyez pas de données après 5 minutes, consultez la section de dépannage ci-dessous.

Dépannage

Si les métriques n'apparaissent pas dans New Relic après le déploiement :

1. Vérifier que le plugin de gestion RabbitMQ est activé :

bash

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

Vous devriez voir [E*] rabbitmq_management indiquant qu'il est activé.

2. Vérifier les logs du pod du collecteur :

bash

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

Rechercher :

Messages de découverte de pods
Erreurs d'authentification (identifiants incorrects)
Erreurs de connexion (problèmes réseau)
Erreurs d'analyse (problèmes de configuration)

3. Vérifier que le service RabbitMQ est accessible :

bash

$kubectl get svc -n <rabbitmq-namespace>

Assurez-vous qu'un service expose le port 15672.

4. Tester l'API de gestion depuis le cluster :

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

Devrait renvoyer HTTP/1.1 200 OK.

5. Vérifier les permissions RBAC :

bash

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

Doit renvoyer yes. Sinon, vérifiez le ClusterRole et le ClusterRoleBinding.

Si le collecteur ne découvre pas automatiquement les pods RabbitMQ :

1. Vérifiez que le sélecteur de label correspond à vos pods :

bash

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

Comparez les étiquettes avec le rule dans votre fichier de valeurs Helm.

2. Vérifier les logs de k8s_observer :

bash

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

Recherchez des messages concernant les pods découverts.

3. Tester le sélecteur d'étiquettes :

bash

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

Cela devrait lister vos pods RabbitMQ. S'il est vide, votre sélecteur d'étiquettes est incorrect.

4. Vérifier les permissions du ClusterRole :

bash

$kubectl describe clusterrole rabbitmq-otel-collector

Assurez-vous qu'il dispose des permissions get, list et watch sur les pods.

Motifs d'étiquettes courants :

Déploiements standards : app=rabbitmq
StatefulSets : app.kubernetes.io/name=rabbitmq
Opérateurs : app.kubernetes.io/component=rabbitmq

Si vous constatez des erreurs de connexion dans les logs du collecteur :

Vérifier les points de terminaison du service :

bash

$kubectl get endpoints -n <rabbitmq-namespace>

Vérifiez que des points de terminaison existent pour votre service RabbitMQ.

Vérifiez les stratégies réseau : Assurez-vous que les stratégies réseau autorisent le trafic depuis l'espace de noms newrelic vers votre espace de noms RabbitMQ.

Tester la connectivité :

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

Vérifier la résolution DNS :

bash

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

Si vous voyez des avertissements de cardinalité élevée dans New Relic :

Filtrer sur des files d'attente spécifiques : Si vous monitorez de nombreuses files d'attente, envisagez de filtrer uniquement les critiques.

Augmenter l'intervalle de collecte :

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

Utilisez l'agrégation de métriques : Configurez le processeur de lots pour agréger les métriques avant l'exportation.

Désactiver les métriques moins critiques : Commentez les métriques dont vous n'avez pas besoin dans la configuration du récepteur.

Conseils d'optimisation supplémentaires :

Utilisez des sélecteurs de labels plus spécifiques pour monitorer uniquement les pods de production
Filtrer des files d'attente spécifiques par nom au lieu de monitorer toutes les files d'attente
Augmentez le collection_interval pour réduire les points de données
Envisagez d'utiliser l'agrégation de métriques dans le collecteur

Si le pod du collecteur plante :

Vérifier les limites de ressources :

bash

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

Recherchez le statut OOMKilled. Si c'est le cas, augmentez les limites de mémoire :

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

Examiner les logs de plantage :

bash

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

Vérifiez la syntaxe de la configuration : Assurez-vous que votre configuration YAML est valide et correctement indentée.

Si vous voyez 401 Unauthorized erreurs :

Vérifiez que les identifiants dans les valeurs Helm correspondent à votre configuration RabbitMQ :

bash

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

Vérifiez que l'utilisateur RabbitMQ dispose des privilèges d'administrateur et assurez-vous que les identifiants ne contiennent pas de caractères spéciaux nécessitant un échappement.

Quelle est la prochaine étape ?

Maintenant que vous avez configuré le monitoring de RabbitMQ, vous pouvez améliorer votre observabilité :

Explorez vos données :

Explorer les métriques RabbitMQ - Liste complète des métriques avec des exemples de requêtes NRQL

Améliorer le monitoring :

Créer des alertes - Configurez des alertes pour les profondeurs de file d'attente et la santé des pods
Créer des dashboards - Créez des dashboards personnalisés pour visualiser vos métriques RabbitMQ

Cette traduction automatique est fournie pour votre commodité.

Monitorer RabbitMQ hébergé sur Kubernetes avec OpenTelemetry

Conseil

Fonctionnement de l'intégration

Important

Étapes d'installation

Avant de commencer

Prérequis du cluster Kubernetes

Prérequis RabbitMQ

Exigences New Relic

Vérifier le point de terminaison de gestion

Créer un fichier de valeurs Helm

Conseil

Créer un secret Kubernetes

Déployer avec Helm

Vérifier le déploiement et le flux de données

Conseil

Dépannage

Aucune donnée n'apparaît dans New Relic

La découverte des pods ne fonctionne pas

Erreurs de connexion

Avertissements de haute cardinalité

Pod du Collecteur qui plante ou redémarre

Échecs d'authentification

Quelle est la prochaine étape ?

Cette traduction automatique est fournie pour votre commodité.

Monitorer RabbitMQ hébergé sur Kubernetes avec OpenTelemetry

Conseil

Fonctionnement de l'intégration .css-21sua1{background:none;border:none;width:0;padding:0;}

Important

Étapes d'installation

Avant de commencer

Prérequis RabbitMQ

Exigences New Relic

Vérifier le point de terminaison de gestion

Créer un fichier de valeurs Helm

Conseil

Créer un secret Kubernetes

Déployer avec Helm

Vérifier le déploiement et le flux de données

Conseil

Dépannage

Aucune donnée n'apparaît dans New Relic

La découverte des pods ne fonctionne pas

Erreurs de connexion

Avertissements de haute cardinalité

Pod du Collecteur qui plante ou redémarre

Échecs d'authentification

Quelle est la prochaine étape ?

Fonctionnement de l'intégration