Publier/Souscrire une messagerie fiable: Redis VS RabbitMQ
Contexte
Je crée une application typique de publication/abonnement dans laquelle un éditeur envoie des messages à un consommateur.
L'éditeur et le consommateur sont sur des machines différentes et la connexion entre eux peut parfois être interrompue.
Objectif
Le but ici est de s’assurer que peu importe ce qui arrive à la connexion, ou aux machines elles-mêmes, un message envoyé par un éditeur est toujours reçu par le consommateur.
La commande de messages n'est pas un must.
Problème
Selon mes recherches, RabbitMQ est le bon choix pour ce scénario:
Cependant, bien que RabbitMQ ait un tutoriel sur publish and subscriber ce tutoriel ne nous présente pas les files d'attente persistantes ni ne mentionne confirme , ce qui, à mon avis, est la clé pour s'assurer que les messages sont remis.
D'autre part, Redis est également capable de le faire:
mais je ne pouvais pas trouver de didacticiels officiels ni d'exemples et mon sous-estimation actuelle m'amène à croire que nous devons faire les files d'attente persistantes et les confirmations de messages, car Redis est principalement un magasin de données en mémoire plutôt qu'un courtier de messages comme RabbitMQ.
Des questions
- Pour ce cas d'utilisation, quelle solution serait la plus facile à mettre en œuvre? (Solution de Redis ou solution RabbitMQ?)
- Veuillez fournir un lien vers un exemple avec ce que vous pensez être le meilleur!
Contexte
À l'origine, je souhaitais publier et souscrire avec la persistance des messages et des files d'attente.
Ceci en théorie, ne correspond pas exactement à publier et s'abonner:
- ce modèle ne s'inquiète pas si les messages sont reçus ou non. L'éditeur diffuse simplement des messages et, s'il y a des abonnés à l'écoute, tant mieux, sinon cela ne le dérange pas.
En effet, si je considérais mes besoins, il me faudrait davantage un modèle de file d’attente, voire même un modèle RPC.
Une analyse
Les gens disent que les deux devraient être faciles, mais c'est vraiment subjectif.
RabbitMQ a globalement une meilleure documentation officielle avec des exemples clairs dans la plupart des langues, tandis que l’information Redis se trouve principalement dans des blogs de tiers et dans des pensions rares de github - ce qui rend la recherche beaucoup plus difficile.
En ce qui concerne les exemples, RabbitMQ a deux exemples qui répondent clairement à mes questions:
En mélangeant les deux, un éditeur a pu envoyer à plusieurs consommateurs des messages fiables, même si l'un d'eux échouait. Les messages ne sont ni perdus ni oubliés.
Chute de lapinMQ:
- Le plus gros problème de cette approche est que si un consommateur/travailleur se bloque, vous devez définir vous-même la logique pour vous assurer que les tâches ne sont pas perdues. Cela est dû au fait qu'une fois la tâche terminée, en suivant le modèle RPC avec des files d'attente durables issues de files d'attente de travail, le serveur continue d'envoyer des messages à l'agent jusqu'à sa prochaine restauration. Mais le travailleur ne sait pas s'il a déjà lu la réponse du serveur ou pas, il faudra donc plusieurs ACK du serveur. Pour résoudre ce problème, chaque message de travail doit avoir un identifiant que vous enregistrez sur le disque (en cas d’échec) ou les requêtes doivent être idempotentes.
- Un autre problème est que si la connexion est perdue, les clients explosent avec des erreurs car ils ne peuvent pas se connecter. C'est aussi quelque chose que vous devez préparer à l'avance.
Quant à redis, il contient un bon exemple de files d'attente durables dans ce blog:
Ce qui suit le fonctionnaire recommandation . Vous pouvez consulter le github repo pour plus d'informations.
Chute de Redis:
- Comme avec rabbitmq, vous devez également gérer vous-même les accidents de travail, sans quoi les tâches en cours seront perdues.
- Vous devez faire un sondage. Chaque consommateur doit demander au producteur s’il ya des nouvelles toutes les X secondes.
Ceci est, à mon avis, un pire lapin.
Conclusion
Je finis par aller avec rabbitmq pour les raisons suivantes:
- Documentation en ligne officielle plus robuste, avec exemples.
- Pas besoin de consommateurs pour interroger le producteur.
- La gestion des erreurs est aussi simple que dans Redis.
Gardant cela à l’esprit, dans ce cas précis, j’ai confiance de dire que Redis est le pire rabbitmq de ce scénario.
J'espère que ça aide.
En ce qui concerne la mise en œuvre, ils devraient tous les deux être faciles - ils ont tous les deux des bibliothèques dans différentes langues. Vérifiez ici redis et ici rabbitmq . Soyons honnêtes: je n'utilise pas de javascript, donc je ne sais pas comment les bibliothèques respectées sont implémentées ou prises en charge.
En ce qui concerne ce que vous n'avez pas trouvé dans le tutoriel (ou peut-être manqué dans le second où il y a quelques mots sur les files d'attente durables, les messages persistants et les accusés de réception), voici quelques explications bien expliquées:
- à propos de la persistance
- about confirme (même lien que celui que vous avez fourni dans la question, il suffit de le lister ici pour plus de clarté)
- sur la fiabilité
L'éditeur confirme que le didacticiel ne figure pas dans le didacticiel, mais il existe un exemple sur github dans le référentiel de amqp.node .
Avec le lapin, le message mq se déplace (dans la plupart des cas) comme ceci publisher -> exchange -> queue -> consumer
et à chacun de ces arrêts, il y a une sorte de persistance à atteindre. De plus, si vous utilisez les clusters et la mise en miroir des files d'attente, vous obtiendrez une fiabilité encore meilleure (et une disponibilité bien sûr).
je pense qu’ils sont faciles à utiliser car de nombreuses bibliothèques ont été développées pour eux deux.
Il y a quelques noms à nommer tels que disque, taureau, kue, amqplib, etc ...
Les documentations pour eux sont très bonnes. Vous pouvez simplement copier et coller et le faire fonctionner en quelques minutes.
J'utilise seneca et seneca amqp est un très bon exemple