Work queue for task distribution in RabbitMQ - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

RabbitMQ Work Queue: Message Acknowledgment Behavior

Consider a RabbitMQ work queue where a worker receives a message but crashes before sending an acknowledgment. What happens to the message in the queue?

A The message remains unacknowledged and is requeued for another worker.

B The message is lost and removed from the queue.

C The message is acknowledged automatically by RabbitMQ.

D The message is duplicated and sent to all workers.

💡 Hint

Think about how RabbitMQ ensures tasks are not lost if a worker fails.

RabbitMQ requires explicit acknowledgments from workers. If a worker crashes before acknowledging, RabbitMQ requeues the message so another worker can process it.

❓ Configuration

intermediate

Configuring RabbitMQ Prefetch Count for Fair Dispatch

Which configuration setting ensures that a RabbitMQ worker receives only one unacknowledged message at a time to balance load fairly?

A Set auto_ack to true when consuming messages

B Set prefetch_count to 0 to allow unlimited messages

C Set durable flag to true on the queue

D Set prefetch_count to 1 using channel.basic_qos(prefetch_count=1)

💡 Hint

This setting limits how many messages a worker can hold without acknowledging.

Setting prefetch_count to 1 tells RabbitMQ to send only one message at a time to a worker until it acknowledges the previous one, enabling fair task distribution.

🔀 Workflow

advanced

RabbitMQ Work Queue: Task Distribution Workflow

Arrange the steps in the correct order for a RabbitMQ work queue where tasks are distributed fairly and reliably to workers.

A 1,3,2,4

B 1,2,3,4

C 2,1,3,4

D 3,1,2,4

💡 Hint

Think about queue setup, message publishing, worker configuration, then processing.

The correct workflow is to first declare a durable queue, then publish persistent messages, configure workers with prefetch_count=1, and finally consume and acknowledge messages.

❓ Troubleshoot

advanced

Troubleshooting RabbitMQ Work Queue: Messages Not Being Redelivered

A worker crashes while processing a message but the message is not redelivered to other workers. What is the most likely cause?

A The queue is not durable, so messages are lost on worker crash.

B The prefetch_count is set to 1, limiting message delivery.

C The worker is using auto_ack=True, so messages are acknowledged immediately.

D The message was published as non-persistent.

💡 Hint

Check how message acknowledgments are handled by the worker.

If auto_ack is true, RabbitMQ considers messages acknowledged as soon as sent, so if a worker crashes, messages are lost and not redelivered.

✅ Best Practice

expert

Best Practice for Ensuring Reliable Task Processing in RabbitMQ Work Queues

Which practice best ensures that tasks are not lost and are fairly distributed among workers in a RabbitMQ work queue?

A Declare durable queues, publish persistent messages, use manual acknowledgments, and set prefetch_count=1.

B Use non-durable queues with auto_ack=True for faster processing.

C Publish messages without persistence and rely on worker retries.

D Set prefetch_count to 0 and use auto_ack=False for unlimited message delivery.

💡 Hint

Think about durability, acknowledgments, and fair load distribution.

Durable queues and persistent messages prevent loss on broker restart. Manual acknowledgments ensure tasks are processed fully. Prefetch_count=1 balances load fairly.