RabbitMQ 4.0 (opens in new tab)

I've used both and NATS is definitely what I'd pick starting out. RabbitMQ is great too, but its heavier and harder to configure. Federation is the killer feature of RabbitMQ that NATS doesn't really have (afaik?).

Big corps choose these bloated and complex tools because this way they can justify charging their customers premium and also that their customers won't be able to service such software on their own.

It's nothing to do with these apps being superior in any way - often it is the opposite - like reasonable faults and glitches can add more hours to bill the customers for "fixing".

nats looks more like a more friendly version of rabbitmq or zeromq than of kafka from these docs: https://docs.nats.io/reference/reference-protocols/nats-prot...

So how about NATS compared to RabbitMQ? If building from scratch, what would drive a design or team towards NATS?

I agree. NATS is much more simplistic to use and deploy. Easy to run locally for development. Jetstream offers useful features like persistent streams, and kv and object stores.

https://nsq.io/ is also very reliable, stable, lightweight, and easy to use.

Maybe because in typical developer fashion their website is absolutely dog-crap at explaining what it does, instead only throwing words here and there

"Key value", "pub-sub", "microservices can live anywhere" And?

Why do I care? What does "microservices can live anywhere" even mean and what does it have to do with NATS?

I find RabbitMQ sometimes inscrutable but I think even their website is better

We switched from a redis backed queue (bullmq) to rabbit at our company (https://github.com/laudspeaker/laudspeaker) when we hit speed issues . We found bull had a much lower throughput, after a lot of tuning compared even to rabbit out of the box.

We needed features like job priorities, and complex routing logic and on top of that our software needs to send millions of messages a minute. What we miss is a nice UI to see the state of jobs, and monitor for problems more easily like: https://taskforce.sh/

At my current place, using Redis with celery is becoming bottleneck for number of concurrent connections it can hold. We are using 1000 workers and start seeing issues (ceiling is 10k connections in Redis); apparently Celery creates huge number of connections. We are considering moving to RabbitMQ for same reason.

Been a while since I last used, but IIRC Rabbit is much more featureful than Redis, and has built-in much of what you'd get from Redis + Sidekiq. Their concepts[1] docs provides a good overview. This may be too broad a stroke but what I liked best about it was we used it for our centralized pub sub system, and although we had services in multiple languages / frameworks, they connected to each other through Rabbit, which saved us from having to setup a bunch of different / incompatible job processing systems. Like Redis its battle tested so you know what you are getting complexity / scale wise. At my current gig we use the typical Rails / Sidekiq setup and though it works fine I definitely find myself missing Rabbit. (But in my head Redis / Rabbit have only some overlap, and seeing both at the same company would seem totally normal)

[1]: https://www.rabbitmq.com/tutorials/amqp-concepts

Redis is slow and doesn't scale out well. Couchbase used to be a decent choice but it went commercial pseudo-FOSS.

> what are the benefits of this over just processing incomplete records straight out of my database? i.e. using MySQL as a queue

Mainly throughput and latency. I haven’t used MySQL recently so some of this may apply more to Postgres.

Postgres has LISTEN/NOTIFY which helps with latency. I don’t think MySQL has LISTEN/NOTIFY, which means you’d have to resort to polling.

You have to use the `SELECT … FOR UPDATE SKIP LOCKED LIMIT 1` features to grab a message from the queue table, so multiple consumers don’t pull the same message.

The biggest issue, if you’re trying to achieve decent throughput, is dealing with bloat (empty pages still sitting on the disk that haven’t been cleaned up yet). You can run vacuum but an online vacuum will only mark the pages as available for reuse (doesn’t free up the disk space). And if you run a full vacuum (which will free the disk space) it locks the entire database while it runs the vacuum. This can compound if you’re using indexes.

One way of dealing with this is setting up partitioning by message timestamp, so that as old messages roll out, you can just drop those partitions and not have to deal with vacuum.

It can work if your queue needs are low throughput or can tolerate higher latency, but there are some things to manage, and realistically setting up a Redis instance is probably less complex than trying to work around the database-specific quirks, unless you’re already very familiar with your database’s inner workings.

Be careful with it, it will segfault randomly and there hasn't been a fix. After hitting my own posts on the Google groups while sleepily debugging the segfault at wee hours of the morning and getting falsely excited about the possibility of a fix, I gave up and wrote a replacement: https://github.com/chronomq/chronomq Have been running it for years without it falling over, submillisecond operations on average, and has processed billions of messages without failing.

It's the polar opposite of RabbitMQ. It's a single binary written in C, you start it, you send text messages via TCP so writing a client or tooling is dead simple.

It's supported natively by Rails ActiveJob too!

I only used it on one project years ago and it was a pleasure, dead easy to get up and running and rock solid.

I agree, but there are a lot of footguns with RMQ. A great example of one is that you'll slow down your cluster by adding more RMQ servers (something that's bit us in the past). Which is a forgivable mistake as most people would expect that more cores == faster RMQ. (For RMQ, that doesn't work because Durable messages need to be replicated to the other nodes in the cluster. More nodes == more replication)

The ideal RMQ cluster has 3 servers and is dedicated to just a few apps.

AMQP and MQTT are both industry standard protocols. Also, RabbitMQ allows you to abuse the limits set by these standards.

Its unfortunate your team ran into performance issues, as Erlang can be inefficient in some situations. Were you using static routes on the DNS load balanced parallel consumers, or relying on the disk caching mechanisms?

I have found it to be more trouble than it is worth, as well

Yes, a stream queue type [0] is available where you can set retention, and replay messages.

[0] https://www.rabbitmq.com/stream.html

RabbiMQ also graciously maintains a very nice Erlang repository for Debian.

Reminds me, I'll have to check if they have a working donation link someplace. =3

Probably better said as "BEAM is a secret weapon".

BEAM languages (including Elixir and Gleam) share the benefits Erlang enjoys by also being part of the ecosystem.

Clients creating server topologies does scale very well with the new Khepri metadata store in RabbitMQ 4.0. Applications having an intimate relationship with their middleware (RabbitMQ) and creating flexible routing topologies is one of main strengths of RabbitMQ! RabbitMQ also allows operators to import (exchange, queue, and binding) definitions on boot. Server topologies can nowadays even be declared via YAML files in Kubernetes (https://github.com/rabbitmq/messaging-topology-operator). This way all the desired state is in one single place and the Kubernetes operator reconciles such that this declaratively declared desired schema is created within RabbitMQ.

People will be surprised on how far you can get NSQ. It doesn't come with any fancy guarantee like only-once or even ordered, this forced developer to think how to design better on the application side. Not saying it's ideal tho.

RabbitMQ in Depth https://www.manning.com/books/rabbitmq-in-depth The author is hanging out here, too.

When you said that number, I had a completely different reaction. 20 messages per second is absolutely nothing, $0.50 per day for that is dreadful. A $5 per month ($0.16 per day) VPS can deliver many thousands of messages per second.

There are some limitations when using Quorum Queues, this was only patched recently - https://github.com/celery/celery/issues/9149