BlogRabbitMQ

Les 5 points à superviser pour garantir la santé de votre cluster RabbitMQ sur Kubernetes

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 17 min

Les 5 points à superviser pour garantir la santé de votre cluster RabbitMQ sur Kubernetes
Sur cette page

Exploiter RabbitMQ sur Kubernetes n'a rien à voir avec l'exploiter sur bare metal. Les signaux de supervision qui comptent sur un cluster statique de trois VM ne sont pas ceux qui vous disent si un StatefulSet RabbitMQ est en bonne santé au sein d'un cluster Kubernetes que vous ne maîtrisez peut-être pas entièrement. Et les modes de défaillance diffèrent : évictions de nœuds, replanification de pods, contention d'E/S entre locataires, et la manière particulière dont le consensus Raft interagit avec la pile réseau de Kubernetes peuvent provoquer des pannes que les opérateurs bare metal ne rencontrent jamais.

Nous avons dépanné suffisamment de ces incidents pour que ce qui compte vraiment se détache clairement du bruit. Si vous ne supervisez que cinq choses sur un cluster RabbitMQ sous Kubernetes, supervisez ces cinq-là. Ce sont les métriques qui, d'après notre expérience dans les services financiers, les plateformes SaaS et les déploiements d'entreprise à haut débit, détectent les défaillances avant qu'elles ne deviennent des pannes visibles par les clients.

Pourquoi la supervision de RabbitMQ sur Kubernetes est différente

Un cluster RabbitMQ sur bare metal ou sur des VM dédiées n'a qu'un adversaire principal : sa propre charge de travail. Un cluster RabbitMQ sur Kubernetes en a plusieurs :

  • Ressources de calcul partagées. À moins d'avoir dédié des nœuds, vos pods RabbitMQ se disputent le CPU, la mémoire et les E/S disque avec tout ce que Kubernetes planifie à leurs côtés.
  • Couches d'abstraction réseau. La pile réseau de Kubernetes ajoute de la latence entre pods, le surcoût du CNI et une couche de heartbeats avec laquelle le consensus Raft doit partager la bande passante.
  • Sémantique des StatefulSets. RabbitMQ sur Kubernetes est déployé en StatefulSet par le Cluster Operator, et les pods d'un StatefulSet ne sont pas automatiquement replanifiés lorsqu'un nœud tombe, ce qui surprend les opérateurs au pire moment.
  • Couplage avec les volumes persistants. Avec un stockage local-path ou local au nœud, un pod replanifié peut ne pas retrouver son état précédent. Le stockage réseau introduit quant à lui sa propre variabilité d'E/S.

Chacun de ces facteurs ajoute une catégorie de défaillances impossible sur une infrastructure dédiée. Votre supervision doit tous les prendre en compte.

1. Santé de la réplication Raft sur les quorum queues

Si vous utilisez des quorum queues (et en 2026, sur RabbitMQ 4.x, vous devriez), la santé de la réplication Raft est la métrique la plus importante de votre tableau de bord. Si ce n'est pas encore fait, consultez notre guide sur la migration vers les quorum queues. Les quorum queues fonctionnent avec un leader et des followers qui participent au consensus Raft, chaque message étant écrit sur une majorité de nœuds avant d'être acquitté auprès du producteur. Quand Raft se dégrade, tout ce qui en dépend se dégrade avec lui.

Sur Kubernetes en particulier, la pression sur Raft s'accumule vite. Le protocole de consensus exige une communication fiable et à faible latence entre les nœuds, des performances d'écriture disque constantes et suffisamment de marge CPU pour traiter les entrées de log. Dès que l'une de ces contraintes se resserre (et sur Kubernetes, cela arrive plus souvent que sur bare metal), Raft prend du retard et les files commencent à ne plus répondre.

Ce qu'il faut réellement superviser

  • rabbitmq_queue_messages ventilé selon l'état leader ou follower.
  • rabbitmq_raft_log_commit_index et rabbitmq_raft_log_last_applied : l'écart entre les deux correspond à votre retard Raft.
  • La fréquence des élections de leader. Un cluster sain a des leaders stables ; si les leaders basculent sans cesse, un élément en amont (réseau, disque, CPU) est en mauvaise santé.
  • L'état Raft par file via l'API de management : statut des followers, index du snapshot, utilisation du disque.

Seuils d'alerte

Alertez si le log Raft d'un follower accuse plus de quelques milliers d'entrées de retard sur le leader pendant plus de 30 secondes. Alertez si les élections de leader surviennent plus d'une fois par heure sur un cluster stable. Et alertez immédiatement si une quorum queue a perdu son quorum : le broker vous le signale dans ses métriques, et vous voulez le savoir en quelques secondes, pas en quelques minutes.

Pourquoi c'est encore plus important sur Kubernetes

Sur Kubernetes, il est tout à fait possible que Raft se retrouve dans un état où la file devient inutilisable et où les procédures de reprise standard ne fonctionnent pas proprement. Un schéma que nous avons observé en production : une quorum queue se bloque, rabbitmqctl delete_queue échoue parce que le broker ne parvient pas à établir le consensus nécessaire pour la supprimer, et le rétablissement du service exige de tuer les pods dans un ordre précis pour forcer une nouvelle élection de leader. Vous ne voulez pas découvrir cette situation par une réclamation client. Vous voulez voir le retard Raft grimper 10 minutes plus tôt.

2. Seuil mémoire et état du contrôle de flux

RabbitMQ dispose d'un mécanisme de protection intégré, le memory high-watermark. Lorsque l'utilisation mémoire d'un broker franchit ce seuil, RabbitMQ bloque les producteurs pour éviter que le nœud ne manque complètement de mémoire. C'est voulu, il s'agit d'une sécurité, mais sur Kubernetes, les réglages par défaut du seuil sont souvent inadaptés.

L'avis de l'expert : régler le seuil mémoire pour Kubernetes

« Sur Kubernetes, il faut faire le test avec un seuil mémoire à 40 % et un net tick time de 60. On laisse davantage de place à Raft pour qu'il puisse travailler, plus une marge pour le réseau. Le réseau, sur RabbitMQ, ce n'est pas seulement celui entre les nœuds : c'est aussi le réseau de Kubernetes et les heartbeats des pods. Vous êtes en concurrence pour les ressources. »— Felipe Gutierrez, ingénieur senior, AceMQ

Le seuil mémoire par défaut de RabbitMQ, 0,4 (40 %), s'explique par le fait que sur Kubernetes, le broker n'est pas le seul à consommer de la mémoire sur le pod ou le nœud. Le kubelet, le plugin CNI, le runtime de conteneurs et les éventuels conteneurs sidecar consomment tous de la mémoire, autour de laquelle Raft et le broker ont besoin de marge. Un seuil pertinent sur une VM dédiée doit souvent être abaissé sur Kubernetes pour préserver une marge suffisante pour les opérations Raft et le réseau entre pods.

Ce qu'il faut réellement superviser

  • rabbitmq_resident_memory_limit_bytes et rabbitmq_process_resident_memory_bytes : le rapport entre les deux indique votre niveau d'utilisation actuel du seuil.
  • rabbitmq_connections_blocked_total : le nombre de connexions de producteurs que RabbitMQ bloque activement.
  • L'état du contrôle de flux par connexion. Si des producteurs passent en contrôle de flux, il y a un problème de pression quelque part dans la chaîne : vérifiez d'abord le réglage du prefetch des consommateurs.
  • L'utilisation mémoire du pod Kubernetes par rapport à sa limite mémoire : atteindre la limite du pod vous vaut un OOMKilled, une défaillance bien plus grave que d'atteindre le seuil mémoire de RabbitMQ.

Seuils d'alerte

Alertez à 80 % du seuil configuré : à ce stade, vous êtes près de bloquer les producteurs. Alertez immédiatement dès qu'une connexion est bloquée. Et alertez à 90 % de la limite mémoire du pod Kubernetes : c'est votre dernier avertissement avant que le kubelet ne tue le pod.

3. Contention des E/S disque et latence d'écriture

C'est sur cette métrique que Kubernetes mord le plus fort. Les quorum queues de RabbitMQ sollicitent fortement le disque par conception : chaque écriture passe par le log Raft avant d'être acquittée. Si le stockage sous-jacent est lent, variable ou saturé, chaque producteur de votre système le ressent.

Sur Kubernetes, la question des performances disque se complique d'un mode de défaillance précis que nous voyons régulièrement : RabbitMQ partage un nœud avec une autre charge de travail gourmande en E/S, typiquement PostgreSQL, Kafka ou Elasticsearch. Quand la charge voisine connaît un pic, les écritures du log Raft de RabbitMQ ralentissent, le retard des followers augmente, des leaders sont réélus et le cluster semble se dégrader mystérieusement, pour des raisons que l'opérateur ne parvient pas à identifier immédiatement.

L'avis de l'expert : le schéma de contention des E/S

« Si vous êtes toujours en concurrence avec Postgres sur le même nœud, sachez que Raft, ce n'est pas seulement la mémoire et le quorum : il a aussi besoin du disque. Si Postgres est fortement sollicité au même moment, vous retomberez exactement dans la discussion que j'ai avec vous. Il faut séparer les deux, ou au moins réduire le nombre de nœuds RabbitMQ pour ne pas être en concurrence pour les ressources. »— Felipe Gutierrez, ingénieur senior, AceMQ

Ce qu'il faut réellement superviser

  • rabbitmq_io_write_time_seconds_total et rabbitmq_io_write_bytes_total : l'évolution de la latence d'écriture est votre signal d'alerte précoce.
  • Les histogrammes de latence d'écriture disque au niveau du nœud (fournis par node_exporter sur Kubernetes).
  • Les IOPS consommées par les pods RabbitMQ par rapport à celles consommées par tout le reste sur le même nœud.
  • La profondeur de la file d'attente disque : si elle reste durablement au-dessus de 1 à 2, vous attendez le disque.
  • Le taux de remplissage des volumes persistants : l'utilisation disque des quorum queues croît avec le volume de messages et la rétention des logs.

Seuils d'alerte

Alertez lorsque la latence d'écriture disque au p99 dépasse 50 ms sur un nœud RabbitMQ. Alertez lorsque l'utilisation d'un volume persistant dépasse 75 %. Et alertez lorsque la profondeur de la file d'attente disque reste supérieure à 2 pendant plus d'une minute.

Recommandation d'architecture

Dans la mesure du possible, dédiez des nœuds Kubernetes à RabbitMQ à l'aide de taints et de tolerations. Exécutez les charges de travail stateful gourmandes en E/S sur leur propre node pool. Si ce n'est pas faisable, utilisez des volumes persistants distincts, sur des disques physiques distincts, pour RabbitMQ et pour ses voisins : le coût d'un disque supplémentaire est dérisoire comparé à celui d'une panne de production causée par une contention d'E/S.

4. Planification des pods, nombre de redémarrages et comportement des StatefulSets

Voici le piège propre à Kubernetes qui prend les opérateurs au dépourvu : RabbitMQ est déployé en StatefulSet par le Cluster Operator officiel, et les pods d'un StatefulSet ne sont pas automatiquement replanifiés sur un autre nœud lorsque leur nœud tombe. C'est voulu (un StatefulSet garantit une identité et un stockage stables), mais la conséquence opérationnelle est qu'une panne de nœud peut mettre un pod RabbitMQ hors ligne aussi longtemps que le nœud reste indisponible.

Ce n'est pas une préoccupation théorique. Nous avons accompagné des clients lors d'incidents où un nœud Kubernetes était tombé, le pod du StatefulSet RabbitMQ s'était retrouvé bloqué et l'application avait subi une indisponibilité prolongée, parce que l'opérateur s'attendait à une replanification automatique que Kubernetes n'offre tout simplement pas pour les StatefulSets.

Ce qu'il faut réellement superviser

  • Le nombre de redémarrages de chaque pod RabbitMQ, suivi dans le temps. Un pod qui redémarre plus de 10 fois par jour essaie de vous dire quelque chose.
  • L'état de planification des pods : en particulier, tout pod RabbitMQ en Pending, Unschedulable ou ContainerCreating depuis plus de 60 secondes.
  • L'état des nœuds qui hébergent des pods RabbitMQ. Un nœud NotReady, c'est un compte à rebours avant la panne d'un pod.
  • La disponibilité du StatefulSet : combien des réplicas souhaités sont actuellement Ready.
  • Les taux d'échec des sondes de liveness et de readiness. Des échecs de sondes sous charge indiquent généralement que le broker est surchargé avant qu'il ne tombe complètement.

Seuils d'alerte

Alertez immédiatement dès que le nombre de réplicas d'un StatefulSet RabbitMQ passe sous le nombre souhaité. Alertez sur tout redémarrage de pod. Alertez dès qu'un nœud hébergeant un pod RabbitMQ passe en NotReady. Ce sont toutes des situations qui appellent une action : vous voulez qu'un humain s'en occupe, pas un mécanisme d'auto-réparation qui fonctionnera peut-être, ou peut-être pas, sur des StatefulSets.

Note d'architecture

Si vous avez besoin d'une reprise automatique après une panne de nœud plus rapide que ce qu'offre le comportement par défaut des StatefulSets, plusieurs options s'offrent à vous : utiliser des pod disruption budgets combinés à une automatisation du drain des nœuds, déployer RabbitMQ sur plusieurs zones de disponibilité Kubernetes pour qu'une panne de zone ne fasse pas tomber le cluster ou, dans certains cas, exécuter le broker sur des VM dédiées entièrement en dehors de Kubernetes. Le bon choix dépend de votre objectif de temps de reprise et de votre maturité opérationnelle sur Kubernetes.

5. Heartbeats réseau et latence entre nœuds

Les nœuds RabbitMQ communiquent entre eux via la distribution Erlang, et la santé de cette communication détermine si le cluster reste un cluster. Sur Kubernetes, la couche réseau introduit une variabilité de latence supplémentaire qui peut provoquer de fausses détections de panne : le broker croit qu'un pair est tombé parce qu'un heartbeat a manqué sa fenêtre, alors qu'en réalité le CNI de Kubernetes a simplement été lent un instant.

La valeur par défaut de net_ticktime d'Erlang, 60 secondes, est souvent trop agressive pour les environnements Kubernetes, en particulier ceux qui utilisent des réseaux overlay ou du trafic inter-zones. La régler fait partie des premières choses que nous faisons pour durcir un cluster RabbitMQ sous Kubernetes avant la production.

Ce qu'il faut réellement superviser

  • Les événements de partition réseau : RabbitMQ les consigne dans ses logs, et ils doivent déclencher une alerte immédiate.
  • La latence entre les pods RabbitMQ (mesurable via un simple sidecar de ping ou les métriques d'un service mesh).
  • L'utilisation du buffer de distribution Erlang : rabbitmq_erlang_distribution_buffer_busy vous indique quand la communication entre nœuds s'engorge.
  • La répartition des états des connexions TCP au niveau du nœud. Un nombre croissant de connexions en TIME_WAIT ou CLOSE_WAIT peut signaler des problèmes réseau latents.
  • Les métriques du CNI si elles sont disponibles (Calico, Cilium, etc.) : les pertes de paquets entre pods RabbitMQ sont un signal d'alerte précoce.

Seuils d'alerte

Alertez sur tout événement de partition réseau. Alertez lorsque la latence au p99 entre pods RabbitMQ dépasse 10 ms. Alertez lorsque l'utilisation du buffer de distribution Erlang dépasse 50 %.

Recommandation de réglage

Sur Kubernetes, portez net_ticktime de 60 secondes par défaut à 120 secondes comme base de départ. Cela laisse plus de latitude à la couche CNI et réduit considérablement les fausses partitions de cluster en cas de gigue réseau normale. Un tick time plus long ralentit légèrement la détection des nœuds réellement en panne, mais le compromis penche très largement en faveur de la stabilité dans les environnements Kubernetes.

Synthèse : votre philosophie d'alerting

Superviser ces cinq domaines ne consiste pas à créer plus d'alertes, mais à créer les bonnes. D'après notre expérience, les opérateurs les moins réveillés par l'astreinte ne sont pas ceux qui supervisent le moins, mais ceux qui supervisent les bonnes choses avec les bons seuils.

Une hiérarchisation raisonnable pour un cluster RabbitMQ sous Kubernetes :

  • P1 (astreinte immédiate) : perte de quorum sur une file. Nœud NotReady. Réplicas du StatefulSet sous le nombre souhaité. Connexion de producteur bloquée. Partition réseau détectée.
  • P2 (alerte aux heures ouvrées) : retard persistant et croissant d'un follower Raft. Seuil mémoire au-dessus de 80 %. Latence disque au p99 au-dessus de 50 ms. Redémarrage de pod. Élections de leader à répétition.
  • P3 (tableau de bord uniquement, revue hebdomadaire) : tendances de capacité. Taux de remplissage du disque. Croissance du nombre de connexions. Croissance de la profondeur des files.

Tout le reste n'est que du bruit. Si votre équipe d'astreinte est sollicitée pour des choses qui ne relèvent ni de P1 ni de P2, vos alertes sont décalées par rapport à ce qui compte réellement.

À retenir en pratique

Kubernetes est une très bonne plateforme pour RabbitMQ, à condition de superviser ce que Kubernetes change. Les réflexes de supervision hérités du bare metal ne se transposent pas tels quels. Les cinq catégories de métriques ci-dessus sont celles que nous supervisons sur chaque mission RabbitMQ sous Kubernetes que nous prenons en charge, et celles que nous recommandons à toute équipe exploitant RabbitMQ sur Kubernetes d'instrumenter dès le premier jour.

Si vous héritez d'un cluster RabbitMQ sous Kubernetes et souhaitez évaluer rapidement sa supervision, vérifiez ces cinq points dans l'ordre :

  • La santé de la réplication Raft est-elle visible file par file ? Sinon, vous pilotez à l'aveugle sur le quorum.
  • Le seuil mémoire est-il réglé pour Kubernetes (plus proche de 0,4 que de 0,8) ? Sinon, un seul pic de trafic vous sépare de producteurs bloqués.
  • La latence disque de chaque nœud RabbitMQ est-elle supervisée et alertée ? Sinon, vous ne pourrez pas diagnostiquer une contention d'E/S lorsqu'elle survient.
  • Le nombre de réplicas du StatefulSet et l'état de planification des pods déclenchent-ils des alertes ? Sinon, une panne de nœud vous prendra par surprise.
  • net_ticktime est-il réglé pour votre environnement Kubernetes ? S'il est toujours à sa valeur par défaut, vous subissez de fausses partitions.

Tout cluster qui répond « non » à deux de ces questions ou plus n'est qu'à un incident d'exploitation de découvrir pourquoi la réponse aurait dû être « oui ».

La checklist de supervision RabbitMQ pour les SRE

Si vous ne deviez lire qu'une section de cet article, ce serait celle-ci. Tout ce qui précède explique pourquoi chaque signal compte ; voici la liste à mettre dans votre runbook. Activez le plugin rabbitmq_prometheus (intégré depuis la 3.8), scrapez chaque nœud et importez les tableaux de bord Grafana officiels. Surveillez ensuite quatre groupes de métriques.

Cluster. Chaque nœud remonte bien ses métriques (up sur chaque cible de scraping), aucune partition (health check de l'API de management ou rabbitmqctl cluster_status, voir la section sur les partitions réseau ci-dessus), stabilité des leaders Raft sur les quorum queues (rabbitmq_raft_term_total doit rester stable : un term qui augmente signifie que des élections ont lieu), et aucune des deux alarmes de ressources active (rabbitmq_alarms_memory_used_watermark et rabbitmq_alarms_free_disk_space_watermark doivent valoir 0). Suivez aussi la marge brute : rabbitmq_disk_space_available_bytes, et rabbitmq_process_resident_memory_bytes par rapport à rabbitmq_resident_memory_limit_bytes.

Files. Profondeur (rabbitmq_queue_messages_ready), messages non acquittés (rabbitmq_queue_messages_unacked), nombre de consommateurs (rabbitmq_queue_consumers) et taux d'utilisation des consommateurs (rabbitmq_queue_consumer_utilisation : une valeur faible signifie que les consommateurs sont inactifs et attendent le broker, une valeur proche de 1 que le broker attend les consommateurs), taux de relivraison (rabbitmq_queue_messages_redelivered_total) et taux de dead-lettering. La profondeur seule n'est pas un problème ; une profondeur qui ne cesse de croître alors que le nombre de consommateurs est stable en est un.

Débit et latence. Taux de publication et de livraison (rabbitmq_queue_messages_published_total et rabbitmq_queue_messages_delivered_total, calculés en taux sur une fenêtre) et latence des publisher confirms. Le broker n'exporte pas directement la latence des confirmations : mesurez-la dans l'application qui publie ou avec un producteur canary. Un écart entre taux de publication et taux de livraison qui ne se résorbe pas est le signal de capacité le plus précoce dont vous disposerez.

Plateforme. Redémarrages de pods (kube_pod_container_status_restarts_total pour le StatefulSet RabbitMQ), latence des volumes persistants fournie par votre storage class ou par node exporter, et throttling CPU (container_cpu_cfs_throttled_periods_total par rapport à container_cpu_cfs_periods_total). Un throttling supérieur à quelques pour cent sur un pod de broker se traduit par une latence des confirmations bien avant que quoi que ce soit ne paraisse anormal dans RabbitMQ lui-même. Les sections sur la planification des pods et les E/S disque ci-dessus en expliquent les mécanismes.

Les huit alertes que nous jugeons indispensables, avec des seuils de départ. Adaptez-les à votre charge de travail : l'idée est de recevoir un avertissement avant l'alerte critique.

MétriqueAvertissementAstreinte
Nœud indisponible (up == 0)1 nœud pendant 2 min2 nœuds ou plus, ou 1 nœud pendant 10 min
Partition réseau détectéetoute partition, immédiatementtoute partition qui dure 5 min
Taux de rabbitmq_raft_term_totalplus d'1 élection en 10 minplus de 3 en 10 min
rabbitmq_alarms_memory_used_watermarkmémoire au-dessus de 70 % de la limitealarme active (producteurs bloqués)
rabbitmq_disk_space_available_bytesmoins de 20 % d'espace libremoins de 2 × la limite d'espace disque libre
rabbitmq_queue_messages_readyen hausse pendant 15 minau-dessus de la profondeur maximale convenue pendant 5 min
rabbitmq_queue_consumer_utilisationinférieur à 0,6 pendant 10 mininférieur à 0,3 avec une profondeur en hausse
Redémarrages de pods1 en 1 heure3 en 1 heure, ou CrashLoopBackOff

Deux points que ce tableau ne couvre pas. D'abord, des messages non acquittés en hausse avec un nombre de consommateurs stable signifient généralement qu'un consommateur est bloqué ou que le prefetch est trop élevé : alertez file critique par file critique plutôt que globalement. Ensuite, le taux de dead-lettering dépend de la charge de travail : alertez sur un écart par rapport à la référence plutôt que sur une valeur fixe.

Envoyez le niveau d'avertissement sur un canal que quelqu'un consulte en journée, et le niveau critique vers l'astreinte. Si vous construisez le cluster de zéro, notre playbook de déploiement sur Kubernetes couvre les requests de ressources, les storage classes et les règles d'anti-affinité qui maintiennent la plupart de ces alertes au silence. Quand l'une d'elles se déclenche malgré tout, le guide de dépannage associe chaque symptôme à un correctif.

Besoin d'aide pour durcir votre cluster RabbitMQ sous Kubernetes ?

AceMQ exploite RabbitMQ en production sur Kubernetes pour des clients grands comptes dans les services financiers, le SaaS, la santé et des organisations du Fortune 1000. Nous construisons la stack de supervision, réglons le broker en fonction des modes de défaillance propres à Kubernetes, validons vos procédures de bascule et restons engagés tout au long de la production pour gérer les incidents que vous espérez ne jamais voir.

Si votre équipe peine à stabiliser RabbitMQ sur Kubernetes, ou prépare un nouveau déploiement Kubernetes et veut une supervision juste dès le départ, parlez à notre équipe d'une évaluation de santé RabbitMQ. Nous auditerons votre supervision actuelle, identifierons les lacunes et vous proposerons un plan pour les combler. Si vous avez besoin d'un support commercial RabbitMQ ou de conseil RabbitMQ, c'est précisément notre métier.

FAQ

Comment les SRE doivent-ils superviser les clusters RabbitMQ ?

Activez le plugin rabbitmq_prometheus sur chaque nœud, scrapez-le en même temps que kube-state-metrics et cAdvisor, et importez les tableaux de bord Grafana officiels. Alertez sur quatre groupes : la santé du cluster (nœuds actifs, partitions, changements de term Raft, alarmes mémoire et disque), la santé des files (messages prêts, non acquittés, nombre et taux d'utilisation des consommateurs, relivraisons), le débit (taux de publication et de livraison, latence des confirmations mesurée côté producteur) et la santé de la plateforme (redémarrages de pods, latence des PV, throttling CPU). Prévoyez un niveau d'avertissement envoyé sur un canal et un niveau d'alerte critique qui déclenche l'astreinte. Le tableau ci-dessus donne des seuils de départ pour les huit alertes que nous jugeons indispensables.

Quelles métriques RabbitMQ signalent un problème de capacité ?

Le signal le plus précoce est un taux de publication durablement supérieur au taux de livraison. Vient ensuite rabbitmq_queue_messages_ready qui augmente alors que rabbitmq_queue_consumers reste stable : il vous faut plus de consommateurs, ou des consommateurs plus rapides. Un rabbitmq_queue_consumer_utilisation proche de 1 signifie que les consommateurs sont le goulet d'étranglement ; proche de 0, que c'est le broker. Côté broker, une mémoire résidente qui grimpe vers rabbitmq_resident_memory_limit_bytes, un rabbitmq_disk_space_available_bytes qui baisse et du throttling CPU sur le pod indiquent tous un nœud sous-dimensionné. Si des alarmes mémoire ou disque se déclenchent, vous êtes déjà à court de capacité et les producteurs sont bloqués.

Qu'est-ce qui rend un cluster RabbitMQ instable ?

D'après notre expérience, les causes sont, à peu près dans cet ordre : des partitions réseau dues à la pression sur les nœuds ou à des pod disruption budgets mal configurés ; des alarmes mémoire déclenchées par des files profondes ou un nombre de connexions non borné ; une contention disque sur des volumes persistants partagés qui ralentit suffisamment les écritures Raft pour déclencher des élections de leader ; des pods de StatefulSet replanifiés sur des nœuds où leur volume ne peut pas les suivre ; et des écarts de version entre nœuds pendant une mise à niveau progressive. Presque toutes se manifestent d'abord par une hausse de rabbitmq_raft_term_total ou par un redémarrage de pod, c'est pourquoi ces deux alertes figurent en tête du tableau. Chaque cause fait l'objet de sa propre section ci-dessus.

Faut-il une solution de supervision commerciale pour RabbitMQ ?

Non. Le plugin rabbitmq_prometheus, Prometheus et les tableaux de bord Grafana officiels sont gratuits, bien maintenus et suffisants pour la plupart des environnements, y compris les plus grands. Ce qu'ils ne vous apportent pas, c'est une personne qui les lit à 3 heures du matin, sait laquelle des huit alertes est la vraie quand trois se déclenchent en même temps, et a déjà corrigé le problème sur votre version. C'est ce qu'ajoute un contrat de support. Nous couvrons les versions 3.8.x à 4.x avec des objectifs de réponse à partir de 15 minutes, selon le plan : la valeur est dans l'intervention, pas dans les tableaux de bord. Gardez votre propre supervision ; faites appel à nous pour l'interprétation et le correctif.

La supervision constitue l'étape six sur huit du guide RabbitMQ sur Kubernetes, qui aborde dans l'ordre l'Operator, le stockage, le réseau, les requests et limits, et les mises à jour progressives.

Scott Sternloff

Auteur

Scott SternloffArchitecte d’entreprise senior

Architecte d’entreprise senior chez AceMQ. Il signe ici les contenus techniques : architecture RabbitMQ, Kafka et Redis, clustering et migrations.

Parler à un ingénieur

Besoin d’un coup de main sur RabbitMQ ?

Des ingénieurs seniors qui l’exploitent en production. Demandez un devis ou une consultation gratuite, sans argumentaire commercial.

Consultation gratuite

Un regard expert sur votre cluster RabbitMQ

Que vous deviez résoudre un incident de production, planifier une migration ou obtenir un second avis sur votre architecture, notre équipe est prête. Pas d’argumentaire commercial, seulement des réponses.

Nous écrire