Categories: Front-End Web DevelopmentWeb DevelopmentTutorials

RabbitMQ Acknowledgements

3 min read

(For more resources related to this topic, see here.)

Acknowledgements (Intermediate)

This task will examine reliable message delivery from the RabbitMQ server to a consumer.

Getting ready

If a consumer takes a message/order from our queue and the consumer dies, our unprocessed message/order will die with it.

In order to make sure a message is never lost, RabbitMQ supports message acknowledgments or acks. When a consumer has received and processed a message, an acknowledgment is sent to RabbitMQ from the consumer informing RabbitMQ that it is free to delete the message. If a consumer dies without sending an acknowledgment, RabbitMQ will redeliver it to another consumer.

How to do it…

Let’s navigate to our source code examples folder and locate the folder Message-Acknowledgement. Take a look at the consumer.js script and examine the changes we have made to support acks.

We pass to the {ack:true} option to the q.subscribe function, which tells the queue that messages should be acknowledged before being removed:
```
q.subscribe({ack:true}, function(message) {
```
When our message has been processed we call q.shift, which informs RabbitMQ that the message has been processed, and it can now be removed from the queue:
```
q.shift();
```
You can also use the prefetchCount option to increase the window of how many messages the server will send you before you need to send an acknowledgement. {ack:true, prefetchCount:1} is the default and will only send you one message before you acknowledge. Setting prefetchCount to 0 will make that window unlimited. A low value will impact performance, so it may be worth considering a higher value.

Let’s demonstrate this concept.

Edit the consumer.js script located in the folder Message-Acknowledgement. Simply comment out the line q.shift(), which will stop the consumer from acknowledging the messages.
Open a command-line console and start RabbitMQ:
```
rabbitmq-server
```
Now open a command-line console, navigate to our source code examples folder, and locate the folder Message-Acknowledgement. Execute the following command:
```
Message-Acknowledgement> node producer
```
Let the producer create several message/orders; press Ctrl + C while on the command-line console to stop the producer creating orders. Now execute the following to begin consuming messages:
```
Message-Acknowledgement> node consumer
```
Let’s open another command-line console and run list_queues:
```
rabbitmqctl list_queues messages_ready
messages_unacknowledged
```
The response should display our shop queue; details include the name, the number of messages ready to be processed, and one message which has not been acknowledged.
```
Listing queues ...
shop.queue 9 1
...done.
```
If you press Ctrl + C while on the command-line console, the consumer script is stopped, and then list the queues again you will notice the message has returned to the queue.
```
Listing queues ...
shop.queue 10 0
...done.
```

If you edit the change we made to consumer.js script and re-run these steps, the application will work correctly, consuming messages one at a time and sending an acknowledgment to RabbitMQ when each message has been processed.

Summary

This article explained a reliable message delivery process in RabbitMQ using Acknowledgements. It also listed the steps that will give you acknowledegements for a messaging application using scripts in RabbitMQ.