Publisher confirms in RabbitMQ - Mini Project: Build & Apply

RabbitMQ Publisher Confirms Basics

📖 Scenario: You are building a simple messaging system where a publisher sends messages to a RabbitMQ queue. To ensure messages are safely received by the broker, you will use Publisher Confirms. This helps you know if your messages were successfully handled.

🎯 Goal: Create a RabbitMQ publisher that sends messages with publisher confirms enabled. You will set up the connection, enable confirms, publish a message, and handle the confirmation callback to print success or failure.

📋 What You'll Learn

Create a connection and channel to RabbitMQ

Enable publisher confirms on the channel

Publish a message to a queue named task_queue

Add a confirmation callback to print Message confirmed on success

Print Message NOT confirmed on failure

💡 Why This Matters

🌍 Real World

Publisher confirms are used in real messaging systems to guarantee that messages are not lost and are safely received by the broker before proceeding.

💼 Career

Understanding publisher confirms is important for DevOps and backend engineers working with message queues to build reliable, fault-tolerant systems.

1

Setup RabbitMQ connection and channel

Create a connection to RabbitMQ on localhost and open a channel named channel.

RabbitMQ

# Your code here to create connection and channel

Hint

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

2

Enable publisher confirms on the channel

Enable publisher confirms on the channel by calling channel.confirm_delivery().

RabbitMQ

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# Enable publisher confirms on the channel
# Your code here

Hint

Call confirm_delivery() on the channel to enable confirms.

3

Publish a message with confirmation handling

Publish the message 'Hello RabbitMQ!' to the queue 'task_queue' using channel.basic_publish. Use a try-except block to catch pika.exceptions.UnroutableError and print 'Message NOT confirmed' if it occurs. Otherwise, print 'Message confirmed' after publishing.

RabbitMQ

import pika

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

# Publish message with confirmation handling
# Your code here

Hint

Use basic_publish with exchange='' and routing_key='task_queue'. Wrap in try-except to catch UnroutableError.

4

Close connection and print final confirmation

Close the connection after publishing and confirmation. The program should print exactly Message confirmed if the message was accepted by RabbitMQ.

RabbitMQ

import pika

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

try:
    channel.basic_publish(exchange='', routing_key='task_queue', body='Hello RabbitMQ!')
    print('Message confirmed')
except pika.exceptions.UnroutableError:
    print('Message NOT confirmed')

# Close the connection
# Your code here

Hint

Call connection.close() to cleanly close the connection.

Practice

1. What does enabling publisher confirms in RabbitMQ do?

easy

A. It automatically retries sending messages on failure.

B. It encrypts messages before sending.

C. It tells you if RabbitMQ accepted your message.

D. It queues messages without sending them.

Solution

1. Step 1: Understand the purpose of publisher confirms

   Publisher confirms notify the sender if the message was accepted by RabbitMQ.

2. Step 2: Compare with other options

   Retrying, encrypting, or queuing without sending are unrelated to confirms.

3. Final Answer:

   It tells you if RabbitMQ accepted your message. -> Option C

4. Quick Check:

   Publisher confirms = message acceptance notification [OK]

Hint: Publisher confirms confirm message acceptance by RabbitMQ [OK]

Common Mistakes:

• Confusing confirms with message encryption
• Thinking confirms retry messages automatically
• Assuming confirms delay message sending

2. Which method must be called on a RabbitMQ channel to enable publisher confirms?

easy

A. enableConfirms()

B. setConfirmMode()

C. startConfirm()

D. confirmSelect()

Solution

1. Step 1: Recall the correct method name

   The method to enable confirms on a channel is confirmSelect().

2. Step 2: Verify other options

   Other method names like enableConfirms() or startConfirm() do not exist in RabbitMQ API.

3. Final Answer:

   confirmSelect() -> Option D

4. Quick Check:

   Enable confirms = confirmSelect() [OK]

Hint: Enable confirms by calling confirmSelect() on the channel [OK]

Common Mistakes:

• Using incorrect method names like enableConfirms()
• Forgetting to call confirmSelect() before publishing
• Confusing confirmSelect() with waitForConfirms()

3. Given this code snippet, what will waitForConfirms() return if the message was accepted?

channel.confirmSelect();
channel.basicPublish(exchange, routingKey, props, body);
boolean confirmed = channel.waitForConfirms();
System.out.println(confirmed);

medium

A. false

B. true

C. null

D. Exception thrown

Solution

1. Step 1: Understand waitForConfirms() behavior

   This method returns true if RabbitMQ accepted the message, false otherwise.

2. Step 2: Given the message was accepted

   The variable confirmed will be true, so printing it outputs 'true'.

3. Final Answer:

   true -> Option B

4. Quick Check:

   Message accepted = waitForConfirms() returns true [OK]

Hint: waitForConfirms() returns true if message accepted [OK]

Common Mistakes:

• Expecting waitForConfirms() to return false on success
• Assuming it returns null or throws exception on success
• Confusing waitForConfirms() with asynchronous callbacks

4. What is wrong with this code snippet for enabling publisher confirms?

channel.basicPublish(exchange, routingKey, props, body);
channel.confirmSelect();
boolean confirmed = channel.waitForConfirms();

medium

A. confirmSelect() must be called before basicPublish()

B. waitForConfirms() cannot be called after publishing

C. basicPublish() requires a callback parameter

D. confirmSelect() should be called after waitForConfirms()

Solution

1. Step 1: Check order of method calls

   confirmSelect() must be called before publishing to enable confirms.

2. Step 2: Identify the error

   In the snippet, confirmSelect() is called after basicPublish(), so confirms are not enabled when publishing.

3. Final Answer:

   confirmSelect() must be called before basicPublish() -> Option A

4. Quick Check:

   Enable confirms before publishing [OK]

Hint: Call confirmSelect() before publishing messages [OK]

Common Mistakes:

• Calling confirmSelect() after publishing
• Thinking waitForConfirms() disables confirms
• Believing basicPublish() needs a callback for confirms

5. You want to ensure your application only proceeds after RabbitMQ confirms message acceptance. Which sequence of calls correctly implements this using publisher confirms?

hard

A. channel.confirmSelect(); channel.basicPublish(...); channel.waitForConfirms();

B. channel.basicPublish(...); channel.waitForConfirms(); channel.confirmSelect();

C. channel.waitForConfirms(); channel.confirmSelect(); channel.basicPublish(...);

D. channel.basicPublish(...); channel.confirmSelect(); channel.waitForConfirms();

Solution

1. Step 1: Enable confirms before publishing

   Call confirmSelect() first to enable confirms on the channel.

2. Step 2: Publish the message and wait for confirmation

   After basicPublish(...), call waitForConfirms() to block until RabbitMQ confirms acceptance.

3. Final Answer:

   channel.confirmSelect(); channel.basicPublish(...); channel.waitForConfirms(); -> Option A

4. Quick Check:

   Enable confirms, publish, then wait [OK]

Hint: Enable confirms, publish, then waitForConfirms() [OK]

Common Mistakes:

• Calling confirmSelect() after publishing
• Waiting for confirms before publishing
• Not calling waitForConfirms() at all