Why integration patterns connect systems in RabbitMQ - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a RabbitMQ queue named 'task_queue'.

RabbitMQ

channel.queue_declare(queue=[1])

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

A'connection'

B'exchange'

C'routing_key'

D'task_queue'

Attempts:

3 left

💡 Hint

Common Mistakes

Using exchange or routing_key instead of queue name.

The queue_declare method needs the queue name as a string. Here, 'task_queue' is the correct queue name.

2fill in blank

medium

Complete the code to publish a message 'Hello World!' to the default exchange with routing key 'task_queue'.

RabbitMQ

channel.basic_publish(exchange='', routing_key=[1], body='Hello World!')

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

A'default'

B'hello'

C'task_queue'

D'message_queue'

Attempts:

3 left

💡 Hint

Common Mistakes

Using exchange name or unrelated strings as routing key.

The routing key should be the queue name 'task_queue' to send the message to that queue.

3fill in blank

hard

Fix the error in the code to consume messages from 'task_queue' with a callback function named 'callback'.

RabbitMQ

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

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

A'task_queue'

B'consume'

C'queue'

D'callback'

Attempts:

3 left

💡 Hint

Common Mistakes

Putting the callback function name instead of the queue name.

The queue parameter must be the name of the queue to consume from, which is 'task_queue'.

4fill in blank

hard

Fill both blanks to declare a durable queue and publish a persistent message to it.

RabbitMQ

channel.queue_declare(queue=[1], durable=[2])
channel.basic_publish(exchange='', routing_key=[1], body='Important task', properties=pika.BasicProperties(delivery_mode=2))

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

A'task_queue'

BTrue

CFalse

D'temp_queue'

Attempts:

3 left

💡 Hint

Common Mistakes

Using different queue names or setting durable to False.

Durable queues survive server restarts, so durable=True is needed. The queue name must be consistent in both places.

5fill in blank

hard

Fill all three blanks to create a direct exchange, bind a queue to it with a routing key, and publish a message.

RabbitMQ

channel.exchange_declare(exchange=[1], exchange_type=[2])
channel.queue_bind(queue=[3], exchange=[1], routing_key='info')
channel.basic_publish(exchange=[1], routing_key='info', body='Log message')

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

A'logs'

B'direct'

C'log_queue'

D'fanout'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong exchange types or mismatched queue/exchange names.

A direct exchange routes messages with a specific routing key. The queue 'log_queue' is bound to the 'logs' exchange with routing key 'info'.

Practice

1. What is the main purpose of integration patterns in systems like RabbitMQ?

easy

A. To create user interfaces for applications

B. To organize how messages flow between different systems

C. To speed up the hardware performance

D. To store large amounts of data permanently

Solution

1. Step 1: Understand integration patterns

   Integration patterns define how messages move and connect systems for communication.

2. Step 2: Identify RabbitMQ role

   RabbitMQ uses these patterns to manage message flow between producers and consumers.

3. Final Answer:

   To organize how messages flow between different systems -> Option B

4. Quick Check:

   Integration patterns = message flow organization [OK]

Hint: Integration patterns = message flow rules [OK]

Common Mistakes:

• Confusing message flow with data storage
• Thinking integration patterns improve hardware
• Mixing UI creation with messaging

2. Which RabbitMQ component is responsible for routing messages to queues?

easy

A. Exchange

B. Queue

C. Binding

D. Consumer

Solution

1. Step 1: Identify RabbitMQ components

   RabbitMQ has exchanges, queues, bindings, and consumers as main parts.

2. Step 2: Understand routing role

   Exchanges receive messages and route them to queues based on rules.

3. Final Answer:

   Exchange -> Option A

4. Quick Check:

   Exchanges route messages to queues [OK]

Hint: Exchanges route, queues store [OK]

Common Mistakes:

• Thinking queues route messages
• Confusing bindings with routing
• Assuming consumers route messages

3. Given this RabbitMQ setup:

exchange: logs (type: fanout)
queue1 bound to logs
queue2 bound to logs
Producer sends message to logs exchange

What happens to the message?

medium

A. Message is discarded

B. Message is sent to queue2 only

C. Message is sent to queue1 only

D. Message is sent to both queue1 and queue2

Solution

1. Step 1: Understand fanout exchange behavior

   A fanout exchange sends messages to all queues bound to it without filtering.

2. Step 2: Apply to given queues

   Both queue1 and queue2 are bound to the logs exchange, so both receive the message.

3. Final Answer:

   Message is sent to both queue1 and queue2 -> Option D

4. Quick Check:

   Fanout exchange = broadcast to all queues [OK]

Hint: Fanout sends to all bound queues [OK]

Common Mistakes:

• Assuming message goes to only one queue
• Confusing fanout with direct exchange
• Thinking message is discarded

4. You wrote this RabbitMQ binding code but messages are not delivered:

channel.queue_bind(queue='task_queue', exchange='logs', routing_key='task')

What is the likely problem?

medium

A. The queue name is incorrect

B. The routing key 'task' does not match exchange type

C. The exchange 'logs' does not exist

D. The channel is closed

Solution

1. Step 1: Check prerequisites for binding

   RabbitMQ queue_bind requires both the exchange and queue to exist and be declared beforehand.

2. Step 2: Spot the missing declaration

   The code shows only queue_bind with no channel.exchange_declare('logs', exchange_type='fanout') prior. Without declaring the exchange, queue_bind fails (exchange not found), no binding created, messages not delivered.

3. Final Answer:

   The exchange 'logs' does not exist -> Option C

4. Quick Check:

   exchange_declare before queue_bind [OK]

Hint: Declare exchanges before binding [OK]

Common Mistakes:

• Assuming exchange existence without checking
• Ignoring exchange type rules
• Not verifying queue name correctness

5. You want two systems to communicate reliably with flexible routing using RabbitMQ. Which integration pattern should you use?

hard

A. Point-to-point with direct exchange and queues

B. Publish-subscribe with fanout exchange

C. Request-reply with temporary queues

D. Store-and-forward with dead-letter queues

Solution

1. Step 1: Define reliable and flexible routing needs

   Reliable communication means messages must be delivered to a specific receiver; flexible routing means routing keys can direct messages.

2. Step 2: Match pattern to needs

   Point-to-point with direct exchange allows routing messages to specific queues using routing keys, ensuring reliability and flexibility.

3. Final Answer:

   Point-to-point with direct exchange and queues -> Option A

4. Quick Check:

   Direct exchange = reliable, flexible routing [OK]

Hint: Direct exchange for reliable, flexible routing [OK]

Common Mistakes:

• Choosing fanout which broadcasts to all
• Confusing request-reply with routing pattern
• Thinking dead-letter queues handle routing