Publishing messages in RabbitMQ - Commands & Configuration

Introduction

Publishing messages means sending data from one program to a message broker so other programs can receive and process it. This helps different parts of a system talk to each other without being directly connected.

When you want to send a task to a worker program to process later.

When you need to notify multiple services about an event, like a new user signup.

When you want to decouple parts of your system so they can work independently.

When you want to handle spikes in requests by queuing messages.

When you want to ensure messages are not lost even if a service is temporarily down.

Config File - publish_message.py

publish_message.py

import pika

# Connect to RabbitMQ server on localhost
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# Declare a queue named 'task_queue' to send messages to
channel.queue_declare(queue='task_queue', durable=True)

# The message to send
message = 'Hello RabbitMQ!'

# Publish the message to the queue
channel.basic_publish(
    exchange='',
    routing_key='task_queue',
    body=message,
    properties=pika.BasicProperties(
        delivery_mode=2  # make message persistent
    ))
print(" [x] Sent 'Hello RabbitMQ!'")

# Close the connection
connection.close()

This Python script connects to a RabbitMQ server running locally.

It declares a queue named task_queue to ensure it exists before sending messages.

The message Hello RabbitMQ! is sent to the queue with persistence enabled so it won't be lost if RabbitMQ restarts.

Finally, the connection is closed cleanly.

Commands

Run the Python script to connect to RabbitMQ and send a message to the 'task_queue'. This starts the publishing process.

Terminal

python3 publish_message.py

Expected Output

 [x] Sent 'Hello RabbitMQ!'

Check the RabbitMQ server to see the list of queues and confirm that 'task_queue' exists and has messages.

Terminal

rabbitmqctl list_queues

Expected Output

Listing queues ...

task_queue	1

Key Concept

If you remember nothing else from this pattern, remember: publishing messages means sending data to a queue so other programs can process it later without direct connection.

Common Mistakes

Not declaring the queue before publishing messages.

If the queue does not exist, the message will be lost or cause an error.

Always declare the queue with the same name and durability settings before sending messages.

Not setting message persistence for important messages.

Messages may be lost if RabbitMQ restarts without persistence.

Set delivery_mode=2 in message properties to make messages persistent.

Closing the connection before the message is fully sent.

The message might not reach the server if the connection closes too early.

Publish the message first, then close the connection.

Summary

Use a client library to connect to RabbitMQ and declare the queue before sending messages.

Publish messages to the queue with persistence if you want them saved on server restarts.

Verify the queue and message count using RabbitMQ management commands.

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