Binding keys and routing keys in RabbitMQ - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does a binding key affect message routing in RabbitMQ?

In RabbitMQ, what role does a binding key play when connecting a queue to a topic exchange?

A It changes the message content before routing.

B It encrypts messages before they reach the queue.

C It filters messages so only those with matching routing keys are delivered to the queue.

D It defines the maximum size of the queue.

💡 Hint

Think about how messages are selected for delivery to queues.

The binding key acts like a filter pattern. It tells the exchange to send messages to the queue only if the message's routing key matches the binding key pattern.

💻 Command Output

intermediate

What is the output of binding a queue with '#' binding key?

Given a topic exchange and a queue bound with the binding key '#', which messages will the queue receive?

A Only messages with routing key exactly '#'.

B Only messages with routing keys containing a dot '.' character.

C No messages will be received.

D All messages sent to the exchange regardless of routing key.

💡 Hint

The '#' symbol in binding keys is a wildcard. What does it match?

The '#' wildcard matches zero or more words separated by dots, so it matches all routing keys, meaning the queue receives all messages sent to the exchange.

❓ Configuration

advanced

Identify the correct binding key for routing keys starting with 'logs.'

You want a queue to receive messages with routing keys that start with 'logs.' followed by any words. Which binding key should you use?

A logs.#

B logs.*

C *.logs

D #.logs

💡 Hint

Remember '*' matches exactly one word, '#' matches zero or more words.

'logs.#' matches routing keys starting with 'logs.' and any number of words after. 'logs.*' matches only one word after 'logs.'.

❓ Troubleshoot

advanced

Why does a queue not receive messages despite correct routing key?

A queue is bound to a topic exchange with binding key 'app.*.error'. Messages are published with routing key 'App.service.error' but the queue receives nothing. What is the likely cause?

A The queue is not declared durable.

B The routing key is case-sensitive and does not match.

C The exchange type is incorrect; it should be direct instead of topic.

D The binding key expects exactly one word between 'app' and 'error', but the routing key has two words.

💡 Hint

Check if the routing key matches the binding key pattern exactly, including case.

Routing keys are case-sensitive. If the routing key case does not match the binding key pattern, messages won't be routed.

🔀 Workflow

expert

Order the steps to bind a queue with a routing key in RabbitMQ CLI

Arrange the commands in the correct order to declare a queue, declare a topic exchange, and bind the queue with a binding key 'user.*.update'.

A 2,1,3

B 1,2,3

C 3,2,1

D 1,3,2

💡 Hint

Think about what must exist before you can bind.

You must first declare the exchange, then the queue, then bind the queue to the exchange with the binding key.

Practice

1. What is the main purpose of a binding key in RabbitMQ?

easy

A. To label messages for routing

B. To create a new exchange

C. To connect a queue to an exchange and filter messages

D. To delete a queue

Solution

1. Step 1: Understand the role of binding keys

   Binding keys link queues to exchanges and decide which messages the queue receives.

2. Step 2: Differentiate from routing keys

   Routing keys label messages, but binding keys filter messages for queues.

3. Final Answer:

   To connect a queue to an exchange and filter messages -> Option C

4. Quick Check:

   Binding key = filter for queues [OK]

Hint: Binding keys link queues to exchanges filtering messages [OK]

Common Mistakes:

• Confusing binding keys with routing keys
• Thinking binding keys create exchanges
• Assuming binding keys delete queues

2. Which of the following is the correct syntax to bind a queue named myQueue to an exchange myExchange with a binding key key.* using RabbitMQ CLI?

easy

A. rabbitmqadmin declare binding source=myExchange destination=myQueue routing_key=key.*

B. rabbitmqctl bind_queue myExchange myQueue key.*

C. rabbitmqctl declare binding myQueue myExchange key.*

D. rabbitmqadmin bind myQueue myExchange key.*

Solution

1. Step 1: Identify the correct RabbitMQ CLI command

   The rabbitmqadmin declare binding command is used to create bindings with source, destination, and routing_key parameters.

2. Step 2: Match parameters to syntax

   Source is the exchange, destination is the queue, and routing_key is the binding key pattern.

3. Final Answer:

   rabbitmqadmin declare binding source=myExchange destination=myQueue routing_key=key.* -> Option A

4. Quick Check:

   Use rabbitmqadmin declare binding with source, destination, routing_key [OK]

Hint: Use rabbitmqadmin declare binding with source, destination, routing_key [OK]

Common Mistakes:

• Using rabbitmqctl bind_queue which is not a valid command
• Swapping queue and exchange names
• Omitting routing_key parameter

3. Given a topic exchange with a queue bound using binding key logs.*.error, which routing key will deliver a message to this queue?

medium

A. logs.system.error

B. logs.error.system

C. logs.system.warning

D. error.logs.system

Solution

1. Step 1: Understand the binding key pattern

   The binding key logs.*.error matches routing keys with three words where the first is 'logs', the second can be any word, and the third is 'error'.

2. Step 2: Match each option to the pattern

   logs.system.error: 'logs.system.error' matches exactly.
   logs.error.system: 'logs.error.system' ends with 'system', not 'error'.
   logs.system.warning: 'logs.system.warning' ends with 'warning', not 'error'.
   error.logs.system: 'error.logs.system' does not start with 'logs'.

3. Final Answer:

   logs.system.error -> Option A

4. Quick Check:

   Binding key pattern matches routing key exactly [OK]

Hint: Match binding key wildcards to routing key words [OK]

Common Mistakes:

• Ignoring position of words in routing key
• Confusing '*' wildcard with '#' wildcard
• Assuming partial matches are enough

4. You have a queue bound to a topic exchange with binding key data.#. You send a message with routing key data but it is not received by the queue. What is the likely cause?

medium

A. Binding key data.# does not match routing key data

B. Routing key data should be data.#

C. Queue is not bound to the exchange

D. Binding key data.# matches routing key data, so the problem is elsewhere

Solution

1. Step 1: Check if binding key matches routing key

   The binding key data.# matches routing keys starting with 'data' and zero or more words after. The routing key 'data' matches because '#' can match zero words.

2. Step 2: Consider other causes

   Since the binding key matches, the message not arriving is likely due to other issues like queue not bound or exchange type mismatch.

3. Final Answer:

   Binding key data.# matches routing key data, so the problem is elsewhere -> Option D

4. Quick Check:

   Binding key '#' matches zero or more words [OK]

Hint: Remember '#' matches zero or more words including none [OK]

Common Mistakes:

• Thinking '#' requires at least one word
• Assuming routing key must equal binding key exactly
• Ignoring other configuration issues

5. You want to route messages with routing keys order.created and order.updated to a queue named orderQueue using a topic exchange. Which most specific binding key should you use to receive both types of messages?

hard

A. order.created, order.updated

B. order.*

C. *.created, *.updated

D. order.#

Solution

1. Step 1: Understand routing keys and binding keys

   Routing keys are 'order.created' and 'order.updated'. The binding key must match both.

2. Step 2: Analyze each binding key option

   order.*: 'order.*' matches 'order.created' and 'order.updated' because '*' matches exactly one word.
   order.#: 'order.#' matches these and more, but is broader than needed.
   *.created, *.updated: '*.created, *.updated' do not match because the first word must be 'order'.
   order.created, order.updated: 'order.created, order.updated' is not valid syntax for a single binding key; multiple bindings needed.

3. Final Answer:

   order.* -> Option B

4. Quick Check:

   'order.*' matches 'order.created' and 'order.updated' [OK]

Hint: Use 'order.*' to match one word after 'order' [OK]

Common Mistakes:

• Using '#' when '*' is enough
• Trying to use multiple keys in one binding key string
• Misplacing wildcards in binding keys