Consuming messages in RabbitMQ - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to consume a message from the queue.

RabbitMQ

channel.basic_consume(queue='task_queue', on_message_callback=[1], auto_ack=True)

Drag options to blanks, or click blank then click option'

Acallback_function

Bconnect_queue

Csend_message

Ddeclare_queue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function that sends messages instead of processing them.

Passing a queue name instead of a function.

The on_message_callback parameter requires a function that will be called when a message is received. This function processes the message.

2fill in blank

medium

Complete the code to start consuming messages.

RabbitMQ

channel.[1]()

Drag options to blanks, or click blank then click option'

Aqueue_declare

Bbasic_publish

Cstop_consuming

Dstart_consuming

Attempts:

3 left

💡 Hint

Common Mistakes

Using basic_publish which sends messages instead of receiving.

Calling stop_consuming which stops the consumer.

The start_consuming() method tells the channel to begin waiting for messages and call the callback when messages arrive.

3fill in blank

hard

Fix the error in the callback function to acknowledge the message.

RabbitMQ

def callback(ch, method, properties, body):
    print(f"Received {body}")
    ch.basic_ack(delivery_tag=[1])

Drag options to blanks, or click blank then click option'

Amethod.delivery_tag

Bbody

Cproperties.delivery_tag

Dch.delivery_tag

Attempts:

3 left

💡 Hint

Common Mistakes

Using the message body as the delivery tag.

Trying to access delivery_tag from the wrong parameter.

The delivery_tag is part of the method parameter and is used to acknowledge the specific message.

4fill in blank

hard

Fill both blanks to consume messages with manual acknowledgment.

RabbitMQ

channel.basic_consume(queue=[1], on_message_callback=[2], auto_ack=False)

Drag options to blanks, or click blank then click option'

A'task_queue'

Bcallback

C'logs'

Dsend_message

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong queue name.

Passing a function that does not process messages.

The queue name must be the one declared earlier, and the callback function processes the messages. Setting auto_ack=False means you manually acknowledge messages.

5fill in blank

hard

Fill all three blanks to set up a consumer with a callback and start consuming.

RabbitMQ

channel.basic_consume(queue=[1], on_message_callback=[2], auto_ack=[3])
channel.start_consuming()

Drag options to blanks, or click blank then click option'

A'task_queue'

Bcallback

CFalse

DTrue

Attempts:

3 left

💡 Hint

Common Mistakes

Setting auto_ack to True when manual ack is needed.

Using wrong queue or callback names.

This sets up consuming from the 'task_queue' with the callback function and manual acknowledgment (auto_ack=False), then starts the consumer loop.

Practice

1. What is the main purpose of consuming messages in RabbitMQ?

easy

A. To delete messages from the queue without processing

B. To send messages to other applications

C. To receive and process messages sent by other applications

D. To create new queues automatically

Solution

1. Step 1: Understand message consumption

   Consuming messages means receiving data sent by other apps to react or process it.

2. Step 2: Identify the purpose

   The main goal is to get messages and handle them, not to send or delete them.

3. Final Answer:

   To receive and process messages sent by other applications -> Option C

4. Quick Check:

   Consuming = receiving messages [OK]

Hint: Consuming means receiving messages to process them [OK]

Common Mistakes:

• Confusing consuming with sending messages
• Thinking consuming deletes messages without processing
• Believing consuming creates queues

2. Which of the following is the correct way to start consuming messages using the RabbitMQ Python client?

easy

A. channel.basic_consume(queue='task_queue', on_message_callback=callback_function)

B. channel.basic_publish(queue='task_queue', callback=callback_function)

C. channel.consume_messages(queue='task_queue', callback=callback_function)

D. channel.start_consuming(queue='task_queue', callback=callback_function)

Solution

1. Step 1: Recall RabbitMQ consume syntax

   The correct method to consume messages is basic_consume with on_message_callback argument.

2. Step 2: Check options

   channel.basic_consume(queue='task_queue', on_message_callback=callback_function) matches the correct syntax exactly; others use wrong method names or parameters.

3. Final Answer:

   channel.basic_consume(queue='task_queue', on_message_callback=callback_function) -> Option A

4. Quick Check:

   Use basic_consume with on_message_callback [OK]

Hint: Use basic_consume with on_message_callback to consume [OK]

Common Mistakes:

• Using basic_publish instead of basic_consume
• Wrong method names like consume_messages
• Passing callback without on_message_callback keyword

3. Given this Python code snippet, what will be printed when a message is received?

def callback(ch, method, properties, body):
    print(f"Received: {body.decode()}")

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)
channel.start_consuming()

medium

A. Received: b'hello world'

B. Received: hello world

C. Received: body.decode()

D. Error: callback function missing parameters

Solution

1. Step 1: Understand callback behavior

   The callback prints the decoded message body as a string using f-string formatting.

2. Step 2: Decode byte message

   body is bytes, decoded to string 'hello world', so output is 'Received: hello world'.

3. Final Answer:

   Received: hello world -> Option B

4. Quick Check:

   Decoded body prints as string [OK]

Hint: Decode message body bytes to string before printing [OK]

Common Mistakes:

• Printing raw bytes without decoding
• Printing the string 'body.decode()' literally
• Missing callback parameters causing errors

4. You wrote this code to consume messages but your callback is never called:

channel.basic_consume(queue='tasks', on_message_callback=callback)
# Missing channel.start_consuming()

What is the most likely reason your callback is not triggered?

medium

A. You forgot to declare the queue before consuming

B. auto_ack must be set to True

C. The callback function has wrong parameters

D. You did not start the consuming loop with start_consuming()

Solution

1. Step 1: Check consuming process

   After basic_consume, you must call start_consuming() to begin receiving messages.

2. Step 2: Identify missing call

   The code lacks channel.start_consuming(), so callback never runs.

3. Final Answer:

   You did not start the consuming loop with start_consuming() -> Option D

4. Quick Check:

   start_consuming() runs the callback loop [OK]

Hint: Always call start_consuming() after basic_consume [OK]

Common Mistakes:

• Forgetting to call start_consuming()
• Assuming auto_ack is required to trigger callback
• Ignoring queue declaration errors

5. You want to consume messages from a queue and ensure each message is acknowledged only after successful processing. Which code snippet correctly implements this behavior?

hard

A. def callback(ch, method, properties, body):
process(body)
ch.basic_ack(delivery_tag=method.delivery_tag)
channel.basic_consume(queue='jobs', on_message_callback=callback, auto_ack=False)
channel.start_consuming()

B. channel.basic_consume(queue='jobs', on_message_callback=lambda ch, method, prop, body: ch.basic_ack(delivery_tag=method.delivery_tag))

C. channel.basic_consume(queue='jobs', on_message_callback=callback, auto_ack=True)
channel.start_consuming()

D. def callback(ch, method, properties, body):
process(body)
channel.basic_consume(queue='jobs', on_message_callback=callback, auto_ack=False)
channel.start_consuming()

Solution

1. Step 1: Understand message acknowledgment

   To acknowledge after processing, auto_ack must be False and manual ack called after process.

2. Step 2: Analyze options

   def callback(ch, method, properties, body): process(body) ch.basic_ack(delivery_tag=method.delivery_tag) channel.basic_consume(queue='jobs', on_message_callback=callback, auto_ack=False) channel.start_consuming() defines a callback that processes the message then calls basic_ack, with auto_ack=False and starts consuming.

3. Final Answer:

   def callback(ch, method, properties, body): process(body) ch.basic_ack(delivery_tag=method.delivery_tag) channel.basic_consume(queue='jobs', on_message_callback=callback, auto_ack=False) channel.start_consuming() -> Option A

4. Quick Check:

   Manual ack after process with auto_ack=False [OK]

Hint: Use auto_ack=False and call basic_ack after processing [OK]

Common Mistakes:

• Setting auto_ack=True disables manual ack
• Not calling basic_ack causes message re-delivery
• Calling basic_ack before processing