BlogRedis

File de messages Redis : Redis peut-il remplacer un vrai broker ?

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 12 min

File de messages Redis : Redis peut-il remplacer un vrai broker ?
Sur cette page

Oui. Une file de messages Redis est une option réelle, et il existe trois façons d'en construire une : les Lists pour une distribution simple du travail, Pub/Sub pour une diffusion « fire-and-forget » qui ne stocke rien, et les Streams pour des consumer groups avec acquittements et livraison at-least-once. Les Streams sont les seuls à se comporter comme un véritable broker. Ce à quoi vous renoncez dans tous les cas : le routage, le TTL par message, les priorités et le dead-lettering — des fonctionnalités que vous finirez par écrire vous-même.

La question est rarement de savoir si Redis en est capable. Il l'est. La question est de savoir ce qui se passe la première fois que quelque chose tombe en panne.

Lists, Pub/Sub ou Streams

ListsPub/SubStreams
ModèleFile de tâchesDiffusionJournal avec consumer groups
Persisté dans le keyspaceOuiNonOui
Garantie de livraisonAt-most-once par défautAt-most-onceAt-least-once avec les groupes
AcquittementsAucun en natifAucunXACK, avec une liste d'entrées en attente
Consumer groupsNonNonOui
Rejeu de l'historiqueNon : un élément dépilé est perduNonOui, par plage d'ID
Plusieurs lecteurs indépendantsNonOui, chacun reçoit une copieOui, par groupe
Usage typeTâches en arrière-planInvalidation de cache, notificationsTraitement d'événements exigeant de la durabilité

S'il ne fallait retenir qu'une chose de cet article : Pub/Sub perd des messages par conception, et ce n'est pas un bug. La documentation de Redis elle-même le dit sans détour.

Les Lists Redis peuvent-elles servir de file de messages ?

Oui, et c'est le plus ancien modèle de file de messages Redis — toujours la bonne réponse pour une grande partie du traitement des tâches en arrière-plan.

Un producteur pousse avec LPUSH. Un worker se bloque sur BRPOP, qui attend un élément au lieu d'interroger en boucle. Plusieurs workers sur la même clé entrent en concurrence, et chaque élément va à un seul d'entre eux. Voilà une file de tâches en deux commandes, sur une infrastructure que vous exploitez déjà.

LPUSH jobs:email '{"to":"user@example.com","template":"welcome"}'
BRPOP jobs:email 0

Le mode de défaillance est évident. BRPOP retire l'élément et le remet au worker. Si ce worker meurt en cours de traitement, l'élément est perdu : rien ne sait qu'il était en cours de traitement et rien ne le relivrera.

La parade est le modèle de file fiable (reliable queue) : au lieu de dépiler l'élément, on le déplace de façon atomique vers une liste de traitement propre à chaque worker avec BLMOVE (ou l'ancienne BRPOPLPUSH), puis on le supprime de cette liste une fois le travail terminé. Les éléments restés dans une liste de traitement peuvent être récupérés.

Cela fonctionne, et bon nombre de systèmes de production reposent dessus. Mais notez ce que vous avez construit : un mécanisme d'acquittement, un processus de nettoyage pour détecter les listes de traitement abandonnées, et une politique de nouvelles tentatives. Ce sont des fonctionnalités de broker, qui vivent désormais dans votre application, sont maintenues par votre équipe et ne sont testées qu'à la hauteur de vos propres tests.

Redis Pub/Sub garantit-il la livraison ?

Non, et c'est le mécanisme le plus souvent pris pour une file de messages Redis alors qu'il est le moins adapté à cet usage.

SUBSCRIBE enregistre un abonnement à un canal, PUBLISH envoie à tous ceux qui sont abonnés à cet instant. La documentation de Redis est sans ambiguïté sur ce que cela implique :

Le Pub/Sub de Redis présente une sémantique de livraison at-most-once. Comme son nom l'indique, cela signifie qu'un message sera livré une fois, s'il l'est. Une fois le message envoyé par le serveur Redis, il n'a aucune chance d'être renvoyé. Si l'abonné n'est pas en mesure de traiter le message (par exemple à cause d'une erreur ou d'une déconnexion réseau), le message est définitivement perdu.

Rien n'est stocké. Un abonné en cours de redémarrage, de déploiement, brièvement isolé du réseau ou simplement lent manque tout ce qui a été publié pendant ce laps de temps, définitivement, sans aucun signal indiquant que cela s'est produit.

Pub/Sub est donc excellent pour un éventail restreint d'usages : invalidation de cache, mises à jour de tableaux de bord en direct, notifications de présence — tout ce pour quoi le message suivant rend le message manqué sans importance. Il est en revanche inadapté au traitement des commandes, aux paiements ou à tout ce dont on vous demandera un jour de rendre compte.

Deux détails utiles. Pub/Sub est indépendant du keyspace : un message publié sur la base 10 atteint un abonné de la base 1 ; préfixez vos canaux si vous avez besoin de cloisonner par environnement. Et dans les déploiements en cluster, le Pub/Sub shardé (SSUBSCRIBE, SPUBLISH) confine les messages à un seul shard au lieu de les propager sur le bus du cluster, ce qui permet de le faire monter en charge horizontalement.

Les Redis Streams font-ils de Redis une vraie file de messages ?

C'est ce qui s'en rapproche le plus. Avec les Streams, Redis cesse d'être une structure de données que l'on détourne pour en faire une file d'attente et devient un outil sur lequel on peut raisonnablement faire tourner un pipeline de traitement.

XADD ajoute une entrée et renvoie un ID ordonné dans le temps, au format <milliseconds>-<sequence>. Les entrées sont conservées dans le keyspace. XREAD peut se bloquer en attendant de nouvelles entrées. Les consommateurs peuvent lire des plages historiques avec XRANGE.

Les consumer groups sont la vraie fonctionnalité :

XGROUP CREATE events mygroup $
XREADGROUP GROUP mygroup consumer1 STREAMS events >
XACK events mygroup 1692632086370-0

Chaque entrée va à un seul consommateur au sein d'un groupe, et plusieurs groupes peuvent consommer le même stream indépendamment. Une entrée livrée reste dans la Pending Entries List de ce groupe jusqu'à ce qu'elle soit acquittée avec XACK. Inspectez l'arriéré avec XPENDING. Si un consommateur meurt avec des entrées en suspens, un autre peut en reprendre la propriété avec XCLAIM ou XAUTOCLAIM et terminer le travail.

Cette combinaison offre une livraison at-least-once : rien n'est perdu quand un consommateur tombe, mais une entrée traitée juste avant un plantage peut être relivrée. Vos consommateurs doivent donc être idempotents. C'est la même exigence que celle de n'importe quel broker at-least-once — pas une faiblesse de Redis, juste un point que l'on oublie jusqu'au jour où apparaissent des débits en double.

Les Streams grossissent indéfiniment si vous ne les plafonnez pas. XADD accepte MAXLEN, et XTRIM s'en charge après coup ; la forme ~ tronque de façon approximative et coûte nettement moins cher qu'une troncature exacte. MINID tronque selon l'ID des entrées plutôt que leur nombre, ce qui convient à une rétention fondée sur le temps. Choisissez dès la conception. Un stream non borné dans un data store en mémoire, c'est un incident d'épuisement de la mémoire à retardement.

À quoi renoncez-vous par rapport à un vrai broker ?

Les Redis Streams comblent l'écart sur les garanties de livraison. Pas sur le reste.

  • Le routage. RabbitMQ place un exchange entre les producteurs et les files. Les exchanges direct, topic, fanout et headers décident, par configuration, où atterrit un message en fonction des clés de routage et des attributs. Redis n'a pas d'équivalent : un producteur écrit dans une clé nommée. Tout routage fondé sur le contenu est du code que vous écrivez, et il devient un élément de plus à maintenir en phase avec votre topologie.
  • Le TTL par message. RabbitMQ prend en charge un TTL par message via la propriété expiration et un TTL par file, en retenant le plus faible des deux lorsque les deux sont définis. Sa documentation signale même honnêtement l'écueil : « Les messages expirés ne sont réellement supprimés que lorsqu'ils atteignent la tête d'une file. » Les TTL de Redis s'appliquent à des clés entières, pas à des éléments de liste ni à des entrées de stream individuels. Faire expirer un message sans toucher à ses voisins, Redis ne sait pas le faire.
  • Les priorités. RabbitMQ prend en charge les files prioritaires. Redis n'a aucune notion de priorité pour les éléments de liste ou les entrées de stream. La simuler suppose plusieurs clés et des workers qui les consultent dans l'ordre, ce qui réintroduit des problèmes de famine que les brokers ont déjà résolus.
  • Le dead-lettering. RabbitMQ envoie automatiquement en dead-letter en cas de rejet, d'expiration du TTL, de limite de longueur de file ou de dépassement de la delivery limit d'une quorum queue. Les Redis Streams vous donnent la matière première — XPENDING montre ce qui est bloqué et le nombre de livraisons est suivi — mais router les messages empoisonnés vers un stream de quarantaine, plafonner les nouvelles tentatives et alerter dessus relève entièrement de votre code.
  • Le comptage des livraisons et la politique de nouvelles tentatives. Un point lié, mais qui mérite d'être distingué : un broker vous offre une delivery limit sous forme de paramètre. Avec Redis, vous lisez le compteur et décidez quoi en faire, partout, de façon cohérente, pour toujours.

Rien de tout cela ne fait de Redis un mauvais choix. Cela en fait un compromis : vous acceptez d'assumer des fonctionnalités offertes ailleurs, en échange de ne pas exploiter un système de plus.

Quelles sont les limites de la persistance ?

Redis est un data store en mémoire qui écrit sur disque. Ce que vous perdez lors d'un crash est une décision de configuration, et il vaut la peine de connaître les chiffres que Redis publie lui-même.

  • RDB prend des snapshots ponctuels aux points de sauvegarde configurés. La documentation de Redis est franche sur l'exposition : « vous créerez généralement un snapshot RDB toutes les cinq minutes ou plus ; si Redis cesse de fonctionner sans arrêt correct, pour quelque raison que ce soit, vous devez donc être prêt à perdre les dernières minutes de données ». Le snapshot fait aussi un fork du processus, et sur un jeu de données volumineux ce fork peut bloquer brièvement le serveur — un effet opérationnel bien réel que nous traitons, avec les autres modes de défaillance, dans nos travaux sur la haute disponibilité Redis.
  • AOF journalise chaque commande d'écriture, avec trois politiques de fsync. appendfsync always est la plus sûre et la plus lente. appendfsync everysec est le réglage par défaut recommandé, et Redis indique que vous « pouvez perdre 1 seconde de données en cas de sinistre ». appendfsync no laisse la main au noyau.

Redis recommande d'activer les deux si vous voulez une durabilité comparable à celle d'une base de données relationnelle. Deux conséquences pour les files d'attente :

  1. Un message acquitté auprès d'un producteur n'est pas forcément sur disque. Avec everysec, il peut y avoir à tout moment jusqu'à une seconde de travail accepté mais non écrit.
  2. La réplication est asynchrone. La panne d'un primaire peut faire perdre des écritures acquittées mais pas encore répliquées — le même compromis que Redis fait partout au profit de la vitesse.

Si votre exigence est « ce message ne peut pas être perdu », Redis peut être configuré pour s'en approcher, mais vous le payez en latence, et vous devez vérifier la configuration plutôt que la supposer.

Quand Redis est-il vraiment le bon choix ?

Utilisez Redis pour vos files d'attente quand :

  • Redis fait déjà partie de votre architecture et ajouter un broker revient à ajouter une charge d'exploitation
  • La topologie est simple : des producteurs vers un seul pool de workers, sans routage fondé sur le contenu
  • La latence compte davantage que les garanties de livraison, et relancer un job perdu est acceptable
  • Le volume est élevé et les messages ont une durée de vie courte, ce pour quoi un data store en mémoire est conçu
  • L'équipe est à l'aise pour assumer dans le code applicatif la logique d'acquittement, de nouvelles tentatives et de dead-letter

Utilisez RabbitMQ quand :

  • Le routage n'est pas trivial et vous préférez le configurer plutôt que le coder
  • Vous avez besoin du TTL par message, des priorités ou du dead-lettering en tant que fonctionnalités du broker
  • Les garanties de livraison figurent dans un document de conformité ou un contrat client
  • Différents consommateurs ont besoin de sous-ensembles différents des messages d'un même producteur
  • Vous voulez des outils d'exploitation — interface de management, métriques par file, politiques — sans avoir à les construire

Ces options ne s'excluent pas, et en pratique les architectures les plus solides utilisent les deux : Redis pour le cache, la limitation de débit, l'état éphémère et la diffusion rapide en interne, RabbitMQ pour les messages assortis de garanties. Nous avons détaillé cette répartition dans utiliser Redis et RabbitMQ ensemble.

Deux autres comparaisons méritent d'être gardées en tête. Si la charge est un journal d'événements en ajout seul que de nombreux consommateurs indépendants rejouent à leur propre rythme, les Redis Streams comme RabbitMQ n'ont pas la bonne forme — voir RabbitMQ Streams ou Apache Kafka. Et si vous hésitez entre un broker open source et un broker commercial pour une livraison garantie, IBM MQ ou RabbitMQ traite cette question.

L'échec que nous constatons le plus souvent n'est pas d'avoir choisi Redis. C'est d'avoir choisi Redis Pub/Sub pour un travail qui exigeait les Streams, ou d'avoir choisi les Lists pour découvrir ensuite trois ans de logique d'acquittement accumulée à laquelle personne ne veut toucher. Choisissez le mécanisme qui correspond à la garantie dont vous avez réellement besoin, et consignez par écrit celui que vous avez retenu.

Parlez de Redis et de RabbitMQ avec AceMQ

Vous vous demandez si Redis porte plus de responsabilités de file d'attente qu'il ne le devrait ? AceMQ intervient des deux côtés : support et conseil Redis et conseil RabbitMQ. Échangez avec un ingénieur AceMQ.

FAQ

Peut-on utiliser Redis comme file de messages ?

Oui. Redis propose trois mécanismes : les Lists pour de simples files de tâches, Pub/Sub pour une diffusion « fire-and-forget », et les Streams pour des consumer groups avec une livraison at-least-once. Ce sont les Streams qui se comportent le plus comme un broker. Reste à savoir si cela suffit, selon ce dont vous avez besoin au-delà de la livraison.

Redis est-il un broker de messages ?

Pas au sens où l'est RabbitMQ. Redis fournit des structures de données sur lesquelles on peut construire des files d'attente. Il n'a ni routage par exchanges, ni TTL par message sur le travail en file, ni files prioritaires, ni mécanisme de dead-letter intégré. Ce sont des fonctionnalités de broker, et avec Redis elles deviennent du code applicatif.

Quelle différence entre Redis Pub/Sub et Redis Streams ?

Pub/Sub est at-most-once et ne stocke rien. La documentation de Redis elle-même précise que si un abonné ne peut pas traiter un message, « le message est définitivement perdu ». Les Streams conservent les entrées dans le keyspace, prennent en charge les consumer groups avec acquittements et offrent une livraison at-least-once. Si perdre un message pose problème, cette différence tranche à elle seule la question.

Redis Pub/Sub conserve-t-il les messages ?

Non. Les messages publiés vont à ceux qui sont abonnés à cet instant, puis disparaissent. Un abonné déconnecté, en cours de redémarrage ou brièvement surchargé manque tout ce qui a été publié pendant ce laps de temps, sans aucun moyen de le récupérer.

Comment fonctionnent les consumer groups des Redis Streams ?

Créez un groupe avec XGROUP CREATE, puis chaque consommateur lit avec XREADGROUP en utilisant l'ID spécial > pour les nouvelles entrées. Les entrées livrées mais non acquittées restent dans la Pending Entries List jusqu'au XACK. Si un consommateur tombe, un autre peut reprendre ses entrées en attente avec XCLAIM ou XAUTOCLAIM. C'est ce qui rend l'at-least-once possible.

Redis peut-il perdre des messages ?

Oui, et l'ampleur dépend de la configuration de la persistance. Les snapshots RDB sont ponctuels : la documentation de Redis prévient donc qu'il faut être prêt à perdre les dernières minutes de données après un arrêt non propre. Avec l'AOF et le réglage par défaut appendfsync everysec, Redis indique que vous pouvez perdre une seconde de données. Les messages Pub/Sub, eux, ne sont pas persistés du tout.

Redis est-il plus rapide que RabbitMQ ?

Pour des opérations brutes en mémoire, en général oui : c'est la raison d'être d'un data store en mémoire. Mais la comparaison est trompeuse, car on compare le plus souvent un push en mémoire non acquitté à une livraison durable, routée et acquittée. Dès qu'on ajoute la persistance et l'acquittement pour les rendre équivalents, l'écart se réduit considérablement.

Quand utiliser Redis plutôt que RabbitMQ pour les files d'attente ?

Quand le travail se résume à une simple distribution vers des workers, que Redis fait déjà partie de votre stack, que le routage va d'un producteur vers un seul pool de consommateurs, et qu'un job perdu en cas de panne peut être rattrapé en le relançant. Tournez-vous vers RabbitMQ quand vous avez besoin de règles de routage, de TTL par message, de priorités, de dead-lettering ou de garanties de livraison que vous pouvez inscrire dans un document de conformité.

Sources

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 Redis ?

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 déploiement Redis

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