Publishing messages in RabbitMQ - Mini Project: Build & Apply

Publishing messages with RabbitMQ

📖 Scenario: You are setting up a simple messaging system using RabbitMQ. Your goal is to send messages to a queue so other services can receive and process them.

🎯 Goal: Learn how to publish messages to a RabbitMQ queue using Python. You will create a connection, declare a queue, send messages, and confirm the output.

📋 What You'll Learn

Use Python with the pika library to connect to RabbitMQ

Create a queue named task_queue

Publish a message with exact content 'Hello RabbitMQ!'

Print confirmation after sending the message

💡 Why This Matters

🌍 Real World

Publishing messages to queues is common in microservices to decouple components and handle tasks asynchronously.

💼 Career

Understanding message publishing with RabbitMQ is essential for roles involving backend development, DevOps, and system integration.

1

Setup RabbitMQ connection and channel

Import the pika library and create a connection to RabbitMQ on localhost. Then create a channel from this connection.

RabbitMQ

# Import pika and create connection and channel
# Your code here

Hint

Use pika.BlockingConnection(pika.ConnectionParameters('localhost')) to connect.

2

Declare the queue

Use the channel to declare a queue named task_queue that is durable.

RabbitMQ

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# Declare a durable queue named 'task_queue'
# Your code here

Hint

Use channel.queue_declare(queue='task_queue', durable=True) to create the queue.

3

Publish the message

Publish the message 'Hello RabbitMQ!' to the task_queue using channel.basic_publish. Set the message property delivery_mode=2 to make it persistent.

RabbitMQ

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True)
# Publish 'Hello RabbitMQ!' message to 'task_queue' with delivery_mode=2
# Your code here

Hint

Use channel.basic_publish(exchange='', routing_key='task_queue', body='Hello RabbitMQ!', properties=pika.BasicProperties(delivery_mode=2)).

4

Print confirmation and close connection

Print '[x] Sent Hello RabbitMQ!' to confirm the message was sent. Then close the connection.

RabbitMQ

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='task_queue', durable=True)
channel.basic_publish(
    exchange='',
    routing_key='task_queue',
    body='Hello RabbitMQ!',
    properties=pika.BasicProperties(delivery_mode=2)
)
# Print confirmation and close connection
# Your code here

Hint

Use print('[x] Sent Hello RabbitMQ!') and connection.close().

Practice

1. What is the main purpose of publishing messages in RabbitMQ?

easy

A. To store data permanently in a database

B. To monitor server performance

C. To create user accounts automatically

D. To send data from one program to another

Solution

1. Step 1: Understand the role of publishing in RabbitMQ

   Publishing messages means sending data from one program to another through RabbitMQ.

2. Step 2: Compare options with the definition

   Only To send data from one program to another matches the purpose of publishing messages in RabbitMQ.

3. Final Answer:

   To send data from one program to another -> Option D

4. Quick Check:

   Publishing messages = sending data [OK]

Hint: Publishing means sending messages between programs [OK]

Common Mistakes:

• Confusing publishing with data storage
• Thinking publishing creates users
• Assuming publishing monitors performance

2. Which of the following is the correct syntax to publish a message using the RabbitMQ Python client?

easy

A. channel.send(exchange='logs', routing_key='info', message='Hello World!')

B. channel.publish_message(exchange='logs', key='info', message='Hello World!')

C. channel.basic_publish(exchange='logs', routing_key='info', body='Hello World!')

D. channel.publish(exchange='logs', routing='info', body='Hello World!')

Solution

1. Step 1: Recall the RabbitMQ Python client method for publishing

   The correct method is basic_publish with parameters exchange, routing_key, and body.

2. Step 2: Match the syntax with the options

   Only channel.basic_publish(exchange='logs', routing_key='info', body='Hello World!') uses basic_publish with correct parameter names and values.

3. Final Answer:

   channel.basic_publish(exchange='logs', routing_key='info', body='Hello World!') -> Option C

4. Quick Check:

   basic_publish with exchange, routing_key, body = channel.basic_publish(exchange='logs', routing_key='info', body='Hello World!') [OK]

Hint: Use basic_publish with exchange, routing_key, and body [OK]

Common Mistakes:

• Using wrong method names like publish_message or send
• Incorrect parameter names like key or routing
• Mixing message and body parameters

3. Given this Python code snippet, what will be the output or result?

import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs', exchange_type='fanout')
channel.basic_publish(exchange='logs', routing_key='', body='Test Message')
print('Message sent')

medium

A. Message sent

B. Error: exchange not declared

C. No output, message lost

D. Error: routing key required

Solution

1. Step 1: Check exchange declaration

   The code declares the exchange 'logs' of type 'fanout' before publishing, so no error there.

2. Step 2: Analyze publishing and print statement

   The message is published with empty routing key (valid for fanout), then 'Message sent' is printed.

3. Final Answer:

   Message sent -> Option A

4. Quick Check:

   Exchange declared + publish success = 'Message sent' [OK]

Hint: Fanout exchange allows empty routing key [OK]

Common Mistakes:

• Assuming routing key is mandatory for fanout
• Forgetting to declare exchange before publishing
• Expecting no output after publish

4. You run this code but get an error: channel.basic_publish(exchange='logs', routing_key='info', body='Hello'). What is the most likely cause?

medium

A. The routing key 'info' is invalid syntax

B. The exchange 'logs' was not declared before publishing

C. The body parameter must be a dictionary, not a string

D. The connection to RabbitMQ server is missing

Solution

1. Step 1: Understand error cause in publishing

   Publishing to an undeclared exchange causes an error in RabbitMQ.

2. Step 2: Evaluate other options

   Routing key syntax is valid, body can be string, and connection is assumed established.

3. Final Answer:

   The exchange 'logs' was not declared before publishing -> Option B

4. Quick Check:

   Undeclared exchange causes publish error [OK]

Hint: Always declare exchange before publishing [OK]

Common Mistakes:

• Assuming routing key syntax causes error
• Thinking body must be dictionary
• Ignoring exchange declaration step

5. You want to publish messages to different queues based on severity (info, warning, error) using a direct exchange named 'logs_direct'. Which code snippet correctly publishes a message with severity 'error'?

hard

A. channel.exchange_declare(exchange='logs_direct', exchange_type='direct')\nchannel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred')

B. channel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred')
channel.exchange_declare(exchange='logs_direct', exchange_type='direct')

C. channel.exchange_declare(exchange='logs_direct', exchange_type='fanout')\nchannel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred')

D. channel.exchange_declare(exchange='logs_direct', exchange_type='topic')\nchannel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred')

Solution

1. Step 1: Declare the direct exchange before publishing

   Exchange must be declared before publishing; channel.exchange_declare(exchange='logs_direct', exchange_type='direct')\nchannel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred') declares 'logs_direct' as direct first.

2. Step 2: Publish with routing key matching severity

   channel.exchange_declare(exchange='logs_direct', exchange_type='direct')\nchannel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred') uses routing_key='error' which matches the severity for direct exchange routing.

3. Step 3: Check other options for errors

   Other options have issues: fanout exchange ignores routing key, publishing before declaring the exchange is wrong order, topic exchange uses patterns instead of exact routing keys.

4. Final Answer:

   Declare direct exchange then publish with routing_key='error' -> Option A

5. Quick Check:

   Declare direct exchange first + correct routing key = channel.exchange_declare(exchange='logs_direct', exchange_type='direct')\nchannel.basic_publish(exchange='logs_direct', routing_key='error', body='Error occurred') [OK]

Hint: Declare exchange before publish; direct exchange uses routing_key [OK]

Common Mistakes:

• Publishing before declaring exchange
• Using fanout exchange when routing key matters
• Confusing topic and direct exchange types