Publishing messages in RabbitMQ - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

What is the output of this RabbitMQ publish command?

You run the following command to publish a message to a RabbitMQ queue named task_queue. What is the expected output or result?

RabbitMQ

rabbitmqadmin publish routing_key=task_queue payload='Hello World!'

A Message published but returned an error code 500

B Error: Queue 'task_queue' does not exist

C Syntax error: missing exchange parameter

D Message published successfully with no output

💡 Hint

The default exchange is used if no exchange is specified, so the message goes directly to the queue.

When you publish a message with rabbitmqadmin without specifying an exchange, it uses the default exchange which routes messages to the queue named by the routing key. If the queue exists, the message is accepted silently.

🧠 Conceptual

intermediate

Which RabbitMQ exchange type routes messages to all bound queues?

You want to send a message that all queues bound to an exchange will receive. Which exchange type should you use?

A Direct exchange

B Topic exchange

C Fanout exchange

D Headers exchange

💡 Hint

Think of a loudspeaker broadcasting to everyone.

A fanout exchange routes messages to all queues bound to it, ignoring routing keys. This is like broadcasting to all listeners.

❓ Configuration

advanced

Which configuration snippet correctly declares a durable queue and publishes a persistent message?

You want to ensure that your queue survives RabbitMQ restarts and that messages are not lost. Which configuration snippet achieves this?

A

queue_declare(queue='task_queue', durable=False)
publish(exchange='', routing_key='task_queue', body='data', properties={'delivery_mode': 1})

B

queue_declare(queue='task_queue', durable=True)
publish(exchange='', routing_key='task_queue', body='data', properties={'delivery_mode': 2})

C

queue_declare(queue='task_queue')
publish(exchange='', routing_key='task_queue', body='data')

D

queue_declare(queue='task_queue', durable=True)
publish(exchange='', routing_key='task_queue', body='data', properties={'delivery_mode': 1})

💡 Hint

Durable queues and persistent messages require specific flags.

Setting durable=True makes the queue survive restarts. Setting delivery_mode=2 marks messages as persistent so they are saved to disk.

❓ Troubleshoot

advanced

Why does this publish command fail with a channel error?

You run this command: rabbitmqadmin publish exchange=logs routing_key=info payload='Test' But it fails with a channel error. What is the most likely cause?

A The exchange 'logs' does not exist

B The routing key 'info' is invalid syntax

C The payload is missing required headers

D The rabbitmqadmin tool is outdated

💡 Hint

Check if the exchange you are publishing to exists.

Publishing to a non-existent exchange causes a channel error because RabbitMQ cannot route the message.

🔀 Workflow

expert

What is the correct sequence to publish a message with confirmation in RabbitMQ?

Arrange the steps in the correct order to publish a message and confirm it was received by RabbitMQ.

A 1,2,3,4

B 2,1,3,4

C 1,3,2,4

D 2,3,1,4

💡 Hint

You must enable confirms before publishing.

First enable confirms, then publish, then wait for ack/nack, then handle errors if any.

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