Request-reply pattern in RabbitMQ - Mini Project: Build & Apply

Request-Reply Pattern with RabbitMQ

📖 Scenario: You are building a simple messaging system where a client sends a request message to a server, and the server sends back a reply message. This is a common pattern called the request-reply pattern used in messaging systems like RabbitMQ.Imagine you want to ask a server for the current time, and the server replies with the time.

🎯 Goal: Build a basic RabbitMQ request-reply system in Python. You will create a client that sends a request message to a queue, and a server that listens to that queue, processes the request, and sends back a reply to the client.

📋 What You'll Learn

Use the pika library to connect to RabbitMQ

Create a request queue named rpc_queue

Client sends a request message with a unique correlation_id and a reply_to queue

Server listens on rpc_queue, processes the request, and sends the reply to the reply_to queue with the same correlation_id

Client waits for the reply message with the matching correlation_id and prints the reply

💡 Why This Matters

🌍 Real World

Request-reply messaging is used in microservices to ask for data or trigger actions and wait for results asynchronously.

💼 Career

Understanding request-reply patterns with RabbitMQ is essential for backend developers and DevOps engineers working with distributed systems and messaging queues.

1

Setup RabbitMQ connection and declare rpc_queue

Write code to connect to RabbitMQ on localhost using pika.BlockingConnection and create a channel. Declare a queue named rpc_queue using channel.queue_declare(queue='rpc_queue').

RabbitMQ

# Connect to RabbitMQ and declare the rpc_queue
# Your code here

Hint

Use pika.BlockingConnection with pika.ConnectionParameters('localhost') to connect. Then use channel.queue_declare to create the queue.

2

Create a unique correlation_id and a reply_to queue for the client

Add code to generate a unique correlation_id string using uuid.uuid4(). Declare a new exclusive callback queue for replies using channel.queue_declare(queue='', exclusive=True). Store the callback queue name in callback_queue.

RabbitMQ

import uuid

# Generate a unique correlation_id
correlation_id = str(uuid.uuid4())

# Declare an exclusive callback queue for replies
callback_queue = channel.queue_declare(queue='', exclusive=True).method.queue
# Your code here

Hint

Use the uuid library to create a unique correlation_id. Declare a queue with an empty name and exclusive=True to get a private callback queue.

3

Send a request message with correlation_id and reply_to, and consume the reply

Publish a message with body 'What is the time?' to the rpc_queue with properties correlation_id=correlation_id and reply_to=callback_queue. Set up a consumer on callback_queue that listens for messages with the matching correlation_id and stores the reply in a variable response. Use channel.start_consuming() to wait for the reply.

RabbitMQ

# Send request message with correlation_id and reply_to
channel.basic_publish(
    exchange='',
    routing_key='rpc_queue',
    properties=pika.BasicProperties(correlation_id=correlation_id, reply_to=callback_queue),
    body='What is the time?'
)

response = None

def on_response(ch, method, props, body):
    global response
    if props.correlation_id == correlation_id:
        response = body.decode()
        ch.stop_consuming()

channel.basic_consume(queue=callback_queue, on_message_callback=on_response, auto_ack=True)
channel.start_consuming()
# Your code here

Hint

Use channel.basic_publish with pika.BasicProperties to set correlation_id and reply_to. Then consume messages on the callback queue and check the correlation_id to find the reply.

4

Print the reply message received from the server

Write a print statement to display the response variable which contains the reply message from the server.

RabbitMQ

# Print the reply message stored in response
# Your code here

Hint

Use print(response) to show the reply message received from the server.

Practice

1.

What is the main purpose of the reply_to property in RabbitMQ's request-reply pattern?

easy

A. It identifies the sender of the request message.

B. It tells the receiver where to send the reply message.

C. It encrypts the message content for security.

D. It sets the priority of the message in the queue.

Solution

1. Step 1: Understand the role of reply_to

   The reply_to property specifies the queue where the reply should be sent.

2. Step 2: Differentiate from other properties

   Unlike sender identification or encryption, reply_to directs the response path.

3. Final Answer:

   It tells the receiver where to send the reply message. -> Option B

4. Quick Check:

   reply_to = reply destination [OK]

Hint: Remember: reply_to points to the reply queue [OK]

Common Mistakes:

• Confusing reply_to with sender ID
• Thinking reply_to sets message priority
• Assuming reply_to encrypts messages

2.

Which of the following is the correct way to set the correlation_id in a RabbitMQ message using Python pika library?

channel.basic_publish(exchange='', routing_key='rpc_queue', properties=..., body='Hello')

easy

A. properties=pika.BasicProperties(correlationId='12345')

B. properties=pika.BasicProperties(correlation='12345')

C. properties=pika.BasicProperties(corr_id='12345')

D. properties=pika.BasicProperties(correlation_id='12345')

Solution

1. Step 1: Recall correct property name

   The correct property name for correlation is correlation_id in pika.BasicProperties.

2. Step 2: Match syntax exactly

   properties=pika.BasicProperties(correlation_id='12345') uses the exact correct syntax: correlation_id='12345'.

3. Final Answer:

   properties=pika.BasicProperties(correlation_id='12345') -> Option D

4. Quick Check:

   Correct property name = correlation_id [OK]

Hint: Use exact property names from docs: correlation_id [OK]

Common Mistakes:

• Using incorrect property names like correlation or corr_id
• Capitalizing property names incorrectly
• Omitting properties argument

3.

Given this Python code snippet using pika for request-reply, what will be printed?

import pika

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

channel.queue_declare(queue='rpc_queue')

corr_id = 'abc123'

channel.basic_publish(
    exchange='',
    routing_key='rpc_queue',
    properties=pika.BasicProperties(reply_to='reply_queue', correlation_id=corr_id),
    body='Request')

print(corr_id)

medium

A. abc123

B. Request

C. reply_queue

D. Error: missing callback

Solution

1. Step 1: Identify what is printed

   The code prints the variable corr_id which is set to 'abc123'.

2. Step 2: Understand message sending vs printing

   Sending a message does not affect the print statement; it prints the variable value.

3. Final Answer:

   abc123 -> Option A

4. Quick Check:

   Printed variable = corr_id = abc123 [OK]

Hint: Print shows variable, not message content or errors [OK]

Common Mistakes:

• Confusing printed output with message body
• Expecting error due to missing reply handler
• Thinking reply_to value is printed

4.

In a request-reply setup, a developer notices replies never arrive. Which fix addresses this common error?

channel.basic_publish(exchange='', routing_key='rpc_queue', properties=pika.BasicProperties(), body='Hello')

medium

A. Remove exchange parameter completely.

B. Change routing_key to reply_queue.

C. Add reply_to and correlation_id in properties.

D. Set body to empty string.

Solution

1. Step 1: Identify missing properties

   The message lacks reply_to and correlation_id, needed for replies.

2. Step 2: Add these properties to enable reply routing

   Including reply_to tells where to send replies; correlation_id matches responses.

3. Final Answer:

   Add reply_to and correlation_id in properties. -> Option C

4. Quick Check:

   Missing reply_to/correlation_id blocks replies [OK]

Hint: Always set reply_to and correlation_id for replies [OK]

Common Mistakes:

• Changing routing_key instead of adding properties
• Removing exchange causes unrelated errors
• Setting empty body does not fix reply issues

5.

You want to implement a request-reply pattern where multiple clients send requests and receive replies without mixing responses. Which approach ensures correct matching?

hard

A. Use a unique correlation_id per request and a shared reply queue.

B. Use the same correlation_id for all requests and separate reply queues.

C. Use unique correlation_id per client and unique reply queues per client.

D. Use no correlation_id and a shared reply queue.

Solution

1. Step 1: Understand correlation_id role

   A unique correlation_id lets clients match replies to requests even on a shared reply queue.

2. Step 2: Evaluate reply queue usage

   Using a shared reply queue with unique IDs is efficient and common practice.

3. Final Answer:

   Use a unique correlation_id per request and a shared reply queue. -> Option A

4. Quick Check:

   Unique correlation_id + shared queue = correct matching [OK]

Hint: Unique correlation_id with shared reply queue avoids mix-ups [OK]

Common Mistakes:

• Using same correlation_id causes reply confusion
• Creating many reply queues adds complexity
• Omitting correlation_id breaks matching