RabbitMQ : Hello World

RabbitMQ & Celery Tutorials

We're going to make two programs:

1. producer for sending a message
2. consumer for receiving the message from the queue (we'll name the queue as "hello") and printing it.

AMQP (Advanced Message Queuing Protocol) has been approved for release as an ISO and IEC International Standard.

"AMQP is an open standard application layer protocol for message-oriented middleware. The defining features of AMQP are message orientation, queuing, routing (including point-to-point and publish-and-subscribe), reliability and security." - wiki.

Since RabbitMQ is based on AMQP, to use Rabbit properly, we need a library that understands it. We'll use pika. It is a pure-Python implementation of the AMQP 0-9-1 protocol that tries to stay fairly independent of the underlying network support library.

Since pika installation depends on git-core packages, we may need to install it first:

$ sudo apt-get install python-pip git-core
$ sudo pip install pika==0.9.13

We'll write our first program send a single message to the queue (send.py). The first thing we need to do is to establish a connection with RabbitMQ server.

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
               'localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')

We're now connected to a broker on the localhost. Since RabbitMQ will just trash the message that's sent to non-existing location, we need to make sure the recipient queue exists. So, we created a queue to which the message will be delivered, and named it "hello". At this point, we're now ready to send a message to our queue. The message will just contain a string "Hello World!".

In RabbitMQ, a message can never be sent directly to the queue, it always needs to go through an exchange as shown in the picture below.

Picture from slides.com.

We're going to use default exchange identified by an empty string though it allows us to specify exactly to which queue the message should go. The queue name needs to be specified in the routing_key parameter:

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print " [x] Sent 'Hello World!'"

Before exiting the program we need to make sure the network buffers were flushed and our message was actually delivered to RabbitMQ by closing the connection.

connection.close()

Here is the final form of send.py:

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
               'localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print " [x] Sent 'Hello World!'"

Output:

$ python send.py
 [x] Sent 'Hello World!'

Our receiving program receive.py will receive messages from the queue and print them on the screen. However, receiving messages from the queue is more complex than sending it. To make it work we need to subscribe a callback function to a queue. This callback function is called by the Pika library when we receive the message, and this callback function will print received message to the screen.

Our receive.py looks like this:

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

print ' [*] Waiting for messages. To exit press CTRL+C'

def callback(ch, method, properties, body):
    print " [x] Received %r" % (body,)

channel.basic_consume(callback,
                      queue='hello',
                      no_ack=True)

channel.start_consuming()

The channel.basic_consume() allows us to tell RabbitMQ that this particular callback function should receive messages from our hello queue.

Note that we have a never-ending loop that waits for data and runs callbacks whenever necessary:

print ' [*] Waiting for messages. To exit press CTRL+C'
...
channel.start_consuming()

If we run the receive.py, we get the following output:

$ python receive.py
 [*] Waiting for messages. To exit press CTRL+C
 [x] Received 'Hello World!'

While the send.py will stop after every run, the receive.py program doesn't exit. It will stay ready to receive further messages, and may be interrupted with Ctrl-C.

We can check what queues RabbitMQ has and how many messages are in them:

$ sudo rabbitmqctl list_queues
Listing queues ...
hello	0
...done.

1. RabbitMQ - Introduction
2. http://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol

RabbitMQ & Celery Tutorials