RabbitMQ comes with a nice .NET client called, appropriately enough, ‘RabbitMQ DotNet Client’. It does a good job of implementing the AMQP protocol in .NET and comes with excellent documentation, which is good because there are some interesting subtleties in its usage. This is because AMQP is designed with flexibility in mind and supports a mind boggling array of possible messaging patterns. But as with any API, with flexibility comes complexity.
The aim of EasyNetQ, my simple messaging API for RabbitMQ on .NET, is to hide much of this complexity and provide a very simple to use interface. But in order to make it simple I have had to take away much of the flexibility of AMQP and instead provide a strongly opinionated view of one way of using RabbitMQ with .NET.
Today I’m going to discuss how Subscriptions work with the RabbitMQ DotNet Client (RDC) and some of the choices that I’ve made in EasyNetQ.
You create a subscription using the RDC with the AMQP command ‘basic consume’. You pass in the name of the queue you want to consume from.
channel.BasicConsume(ackNackQueue, noAck, consumer);
If you use the default QueueingBasicConsumer, the RabbitMQ server then takes messages from the queue you specified and sends them over the network to the RDC. The RDC has a dedicated worker thread that listens to a TCP socket and pulls the messages off as they arrive and places them on a shared thread-safe queue. The client application, in my case EasyNetQ, pulls messages off the shared queue on its own thread and processes them as required. Once it has processed the message it can acknowledge that it has completed by sending an AMQP ‘basic ack’ command. At that point the RabbitMQ server removes the message from its queue.
Now, what happens if messages are arriving faster than the user application can process them? The shared queue will gradually fill up with messages and eventually the process will run out of memory. That’s a bad thing. To fix this, you can limit the number of messages that RabbitMQ will send to the RDC before they are acknowledged with the Quality of Service prefetchCount setting.
channel.BasicQos(0, prefetchCount, false);
The default value for prefetchCount is zero, which means that there is no limit. If you set prefetchCount to any other positive value, that will be the maximum number of messages that the RDC’s queue will hold at any one time. Setting the prefectchCount to a reasonably high number will allow RabbitMQ to more efficiently stream messages across the network.
What happens if the shared queue is full of messages and my client application crashes? Won’t all the messages be lost? No, because messages are only removed from the RabbitMQ queue when the user application sends the basic ack message. The messages queued in the RDC’s shared queue are not acknowledged and so will not yet have been removed from the RabbitMQ queue.
However, if when you call ‘basic consume’ you pass in true for ‘noAck’ then the messages will be removed from the RabbitMQ queue as they are transmitted across the network. You would use this setting if you’re not worried about loosing some messages, but need them to be transmitted as efficiently as possible.
For EasyNetQ, I’ve made the default settings as follows: 1000 messages for the prefetchCount and noAck to be false. I’m assuming that most users will value reliability over performance. Eventually I hope to provide some dial with setting like ‘high throughput, low reliability’, ‘low throughput, high reliability’, but for now I’m going for reliability.
I’d be very interested to hear from anyone who’s using RabbitMQ with .NET and how they have configured these settings.
That's great. I think we are going to use RabbitMQ and I realized how many settings you need to be aware of when developing something using the default client.ReplyDelete
The default settings you've chosen are sensible and conform to our scenario. We want reliability more than throughput.
Even in systems which I've had a high number of messages passing though, it's often better to scale out with RabbitMQ federation instead of ignoring the ACKs with consumption.ReplyDelete
Use Spring AMPQ. As for the actual settings, I am not sure. We value reliability over speed (cause that is why one uses a queue) so we dumped RabbitMQ and went back to JMS (using ActiveMQ for .NET clients).ReplyDelete