How To Register On Pika Network

Introduction

Prerequisites

This tutorial assumes RabbitMQ is installed and running on localhost on the standard port (5672). In instance you use a unlike host, port or credentials, connections settings would require adjusting.

Where to become help

If you're having trouble going through this tutorial yous can contact us through the mailing list or RabbitMQ community Slack.

RabbitMQ is a message broker: information technology accepts and forrard letters. You can think near it equally a mail office: when you put the mail that you desire posting in a post box, you tin can be certain that the letter of the alphabet carrier volition somewhen evangelize the post to your recipient. In this analogy, RabbitMQ is a post box, a post office, and a alphabetic character carrier.

The major difference between RabbitMQ and the post office is that it doesn't deal with paper, instead it accepts, stores, and forrad binary blobs of data ‒ letters.

RabbitMQ, and messaging in full general, uses some jargon.

Producing means nix more than sending. A program that sends messages is a producer :

digraph { bgcolor=transparent; truecolor=true; rankdir=LR; node [style="filled"]; // P1 [characterization="P", fillcolor="#00ffff"]; }
A queue is the name for a mail service box which lives within RabbitMQ. Although messages flow through RabbitMQ and your applications, they can only be stored within a queue. A queue is just bound past the host'southward retentiveness & disk limits, it'due south substantially a large message buffer. Many producers tin can transport messages that go to one queue, and many consumers can endeavour to receive information from i queue. This is how we represent a queue:

digraph { bgcolor=transparent; truecolor=true; rankdir=LR; node [fashion="filled"]; // subgraph cluster_Q1 { label="queue_name"; colour=transparent; Q1 [characterization="{||||}", fillcolor="red", shape="record"]; }; }
Consuming has a similar meaning to receiving. A consumer is a program that mostly waits to receive letters:

digraph { bgcolor=transparent; truecolor=true; rankdir=LR; node [style="filled"]; // C1 [characterization="C", fillcolor="#33ccff"]; }

Annotation that the producer, consumer, and broker do not take to reside on the same host; indeed in nearly applications they don't. An awarding can be both a producer and consumer, likewise.

Hello Globe!

(using the Pika Python customer)

In this part of the tutorial we'll write two pocket-size programs in Python; a producer (sender) that sends a unmarried message, and a consumer (receiver) that receives messages and prints them out. It's a "Hello World" of messaging.

In the diagram below, "P" is our producer and "C" is our consumer. The box in the middle is a queue - a message buffer that RabbitMQ keeps on behalf of the consumer.

Our overall design will look similar:

digraph Yard { bgcolor=transparent; truecolor=true; rankdir=LR; node [style="filled"]; // P1 [characterization="P", fillcolor="#00ffff"]; subgraph cluster_Q1 { label="hello"; color=transparent; Q1 [label="{||||}", fillcolor="reddish", shape="tape"]; }; C1 [characterization="C", fillcolor="#33ccff"]; // P1 -> Q1 -> C1; }

Producer sends letters to the "hello" queue. The consumer receives letters from that queue.

RabbitMQ libraries

RabbitMQ speaks multiple protocols. This tutorial uses AMQP 0-9-1, which is an open, general-purpose protocol for messaging. There are a number of clients for RabbitMQ in many dissimilar languages. In this tutorial series we're going to use Pika 1.0.0, which is the Python client recommended by the RabbitMQ team. To install it you tin can use the pip package management tool:
python -thousand pip install pika --upgrade          

At present we have Pika installed, we can write some code.

Sending

digraph { bgcolor=transparent; truecolor=true; rankdir=LR; node [way="filled"]; // P1 [label="P", fillcolor="#00ffff"]; subgraph cluster_Q1 { label="hello"; color=transparent; Q1 [label="{||||}", fillcolor="red", shape="record"]; }; // P1 -> Q1; }

Our kickoff program transport.py will send a unmarried message to the queue. The first thing nosotros need to do is to establish a connexion with RabbitMQ server.

#!/usr/bin/env python import pika  connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) aqueduct = connection.channel()

We're connected now, to a broker on the local machine - hence the localhost. If we wanted to connect to a broker on a different auto we'd just specify its proper name or IP address hither.

Next, before sending nosotros need to make sure the recipient queue exists. If we send a message to non-existing location, RabbitMQ volition just drop the message. Permit's create a hi queue to which the message will be delivered:

channel.queue_declare(queue='hello')

At this signal we're ready to send a message. Our first message will just contain a string Hello Globe! and we desire to transport it to our hello queue.

In RabbitMQ a message tin never be sent direct to the queue, it always needs to go through an commutation. But permit'south not get dragged down by the details ‒ you can read more about exchanges in the 3rd part of this tutorial. All we demand to know now is how to utilise a default substitution identified by an empty string. This substitution is special ‒ information technology allows the states to specify exactly to which queue the bulletin should become. The queue name needs to be specified in the routing_key parameter:

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

Before exiting the program nosotros need to brand sure the network buffers were flushed and our message was actually delivered to RabbitMQ. We can do information technology by gently endmost the connection.

connection.close()

Sending doesn't work!

If this is your first time using RabbitMQ and you don't see the "Sent" message and then you may be left scratching your head wondering what could exist wrong. Mayhap the broker was started without enough free deejay infinite (by default it needs at to the lowest degree 200 MB free) and is therefore refusing to take messages. Check the broker logfile to confirm and reduce the limit if necessary. The configuration file documentation will show you lot how to set disk_free_limit.

Receiving

digraph { bgcolor=transparent; truecolor=true; rankdir=LR; node [manner="filled"]; // subgraph cluster_Q1 { characterization="hello"; colour=transparent; Q1 [label="{||||}", fillcolor="ruby-red", shape="record"]; }; C1 [label="C", fillcolor="#33ccff"]; // Q1 -> C1; }

Our second program receive.py will receive messages from the queue and print them on the screen.

Again, first we need to connect to RabbitMQ server. The lawmaking responsible for connecting to Rabbit is the same as previously.

The next step, only similar before, is to brand sure that the queue exists. Creating a queue using queue_declare is idempotent ‒ we can run the command as many times as nosotros like, and just ane will be created.

aqueduct.queue_declare(queue='hello')

Y'all may enquire why nosotros declare the queue again ‒ nosotros have already declared information technology in our previous code. Nosotros could avoid that if we were sure that the queue already exists. For case if ship.py plan was run before. Merely we're not yet certain which programme to run first. In such cases it's a proficient practice to repeat declaring the queue in both programs.

Listing queues

You may wish to encounter what queues RabbitMQ has and how many letters are in them. You lot can do it (equally a privileged user) using the rabbitmqctl tool:
sudo rabbitmqctl list_queues          
On Windows, omit the sudo:
rabbitmqctl.bat list_queues          

Receiving letters from the queue is more than circuitous. It works by subscribing a callback function to a queue. Whenever we receive a message, this callback role is called by the Pika library. In our instance this function will impress on the screen the contents of the message.

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

Next, we need to tell RabbitMQ that this particular callback function should receive messages from our hello queue:

aqueduct.basic_consume(queue='hello',                       auto_ack=Truthful,                       on_message_callback=callback)

For that command to succeed we must exist certain that a queue which we want to subscribe to exists. Fortunately we're confident about that ‒ we've created a queue above ‒ using queue_declare.

The auto_ack parameter will be described subsequently on.

And finally, we enter a never-ending loop that waits for data and runs callbacks whenever necessary, and catch KeyboardInterrupt during program shutdown.

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

if __name__ == '__main__':     try:         main()     except KeyboardInterrupt:         impress('Interrupted')         attempt:             sys.get out(0)         except SystemExit:             bone._exit(0)

Putting it all together

send.py (source)

#!/usr/bin/env python import pika  connection = pika.BlockingConnection(     pika.ConnectionParameters(host='localhost')) aqueduct = connection.channel()  channel.queue_declare(queue='hello')  channel.basic_publish(commutation='', routing_key='hello', torso='Howdy World!') print(" [x] Sent 'Hello World!'") connectedness.shut()

receive.py (source)

#!/usr/bin/env python import pika, sys, os  def main():     connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))     aqueduct = connection.aqueduct()      channel.queue_declare(queue='hello')      def callback(ch, method, properties, torso):         impress(" [ten] Received %r" % body)      aqueduct.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)      impress(' [*] Waiting for messages. To exit press CTRL+C')     channel.start_consuming()  if __name__ == '__main__':     effort:         master()     except KeyboardInterrupt:         impress('Interrupted')         endeavor:             sys.exit(0)         except SystemExit:             os._exit(0)

Now we can try out our programs in a terminal. First, let's kickoff a consumer, which volition run continuously waiting for deliveries:

python receive.py # => [*] Waiting for messages. To exit press CTRL+C # => [x] Received 'Hello Earth!'

Now offset the producer. The producer program volition stop after every run:

python send.py # => [x] Sent 'Hello World!'

Hurray! Nosotros were able to send our offset message through RabbitMQ. As you might have noticed, the receive.py plan doesn't exit. It volition stay set to receive further messages, and may exist interrupted with Ctrl-C.

Endeavor to run transport.py once again in a new last.

We've learned how to send and receive a bulletin from a named queue. It's fourth dimension to move on to role 2 and build a elementary work queue.

Production [Non-]Suitability Disclaimer

Please go along in mind that this and other tutorials are, well, tutorials. They demonstrate one new concept at a time and may intentionally oversimplify some things and leave out others. For example topics such as connexion management, error handling, connexion recovery, concurrency and metric collection are largely omitted for the sake of brevity. Such simplified code should not exist considered production set up.

Please accept a look at the residuum of the documentation before going live with your app. Nosotros peculiarly recommend the following guides: Publisher Confirms and Consumer Acknowledgements, Production Checklist and Monitoring.

Getting Help and Providing Feedback

If you take questions most the contents of this tutorial or whatever other topic related to RabbitMQ, don't hesitate to ask them on the RabbitMQ mailing list.

Help Us Meliorate the Docs <3

If y'all'd like to contribute an improvement to the site, its source is available on GitHub. Simply fork the repository and submit a pull request. Give thanks y'all!