Redis as message broker in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Django app publishes a message to Redis?

Consider a Django app configured to use Redis as a message broker. When the app publishes a message to a Redis channel, what is the expected behavior?

A The message is sent to all clients subscribed to that Redis channel immediately.

B The message is stored in Redis and delivered only when the subscriber requests it.

C The message is saved in a Redis list and requires manual polling to retrieve.

D The message is lost if no subscriber is connected at the time of publishing.

💡 Hint

Think about how Redis Pub/Sub works with subscribers.

Redis Pub/Sub delivers messages instantly to all connected subscribers of the channel. If no subscriber is connected, the message is not stored or queued.

📝 Syntax

intermediate

Identify the correct Redis publish command in Django using redis-py

Which of the following code snippets correctly publishes a message to a Redis channel named 'notifications' using the redis-py client in Django?

A redis_client.publish_message('notifications', 'New user signed up')

B redis_client.send('notifications', 'New user signed up')

C redis_client.push('notifications', 'New user signed up')

D redis_client.publish('notifications', 'New user signed up')

💡 Hint

Check the redis-py documentation for the method to send messages to a channel.

The correct method to publish a message to a Redis channel using redis-py is publish. Other methods do not exist or serve different purposes.

🔧 Debug

advanced

Why does the Redis subscriber in Django not receive messages?

A Django app subscribes to a Redis channel but never receives messages published to that channel. Which of the following is the most likely cause?

A The subscriber is using a blocking call that prevents message processing.

B The subscriber did not call the <code>subscribe</code> method before listening.

C The Redis server is configured to reject all Pub/Sub messages.

D The published messages are too large and get dropped silently.

💡 Hint

Check the subscriber setup steps carefully.

If the subscriber does not call subscribe on the Redis client, it will not receive any messages from the channel.

❓ state_output

advanced

What is the state of Redis after publishing messages with no subscribers?

If a Django app publishes messages to a Redis channel but no clients are subscribed at that moment, what happens to those messages in Redis?

A Messages are discarded immediately and not stored anywhere.

B Messages are stored in a Redis list for later retrieval.

C Messages are saved in Redis memory until a subscriber connects.

D Messages cause Redis to throw an error due to no subscribers.

💡 Hint

Think about Redis Pub/Sub message persistence.

Redis Pub/Sub does not store messages if no subscribers are connected. Messages are discarded immediately.

🧠 Conceptual

expert

Why choose Redis as a message broker in Django over other brokers?

Which of the following reasons best explains why a developer might choose Redis as a message broker for a Django app?

A Redis guarantees message delivery persistence and complex routing like RabbitMQ.

B Redis automatically scales horizontally without any configuration.

C Redis offers fast in-memory message delivery with simple Pub/Sub and supports lightweight task queues.

D Redis supports only synchronous message processing, which simplifies debugging.

💡 Hint

Consider Redis strengths and limitations compared to other brokers.

Redis is known for fast in-memory operations and simple Pub/Sub, making it suitable for lightweight messaging and task queues. It does not guarantee persistence or complex routing like RabbitMQ.

Practice

1. What is the main role of Redis when used as a message broker in a Django application?

easy

A. To send messages quickly between different parts of the app

B. To store user passwords securely

C. To serve static files like images and CSS

D. To handle database migrations automatically

Solution

1. Step 1: Understand Redis as a message broker

   Redis acts as a fast messenger that sends messages between parts of an app.

2. Step 2: Identify Redis's role in Django

   In Django, Redis helps different components communicate by sending and receiving messages quickly.

3. Final Answer:

   To send messages quickly between different parts of the app -> Option A

4. Quick Check:

   Redis message broker = fast message sending [OK]

Hint: Remember Redis is for fast message passing, not storage [OK]

Common Mistakes:

• Confusing Redis with database storage
• Thinking Redis serves static files
• Assuming Redis manages migrations

2. Which Django code snippet correctly publishes a message to a Redis channel named updates?

easy

A. redis_client.send('updates', 'New data available')

B. redis_client.subscribe('updates', 'New data available')

C. redis_client.publish('updates', 'New data available')

D. redis_client.receive('updates', 'New data available')

Solution

1. Step 1: Identify the correct Redis method to send messages

   The method to send messages is publish, not subscribe, send, or receive.

2. Step 2: Match method with channel and message

   Using publish('updates', 'New data available') sends the message to the 'updates' channel correctly.

3. Final Answer:

   redis_client.publish('updates', 'New data available') -> Option C

4. Quick Check:

   Send message = publish method [OK]

Hint: Use publish() to send, subscribe() to receive messages [OK]

Common Mistakes:

• Using subscribe() to send messages
• Using non-existent send() or receive() methods
• Mixing up method names

3. Given this code snippet, what will be printed when the message 'Hello everyone' is published to the chat channel?

import redis

r = redis.Redis()

pubsub = r.pubsub()
pubsub.subscribe('chat')

for message in pubsub.listen():
    if message['type'] == 'message':
        print(f"Received: {message['data'].decode()}")
        break

medium

A. Received: Hello everyone

B. Received: message

C. Received: chat

D. No output, code will error

Solution

1. Step 1: Understand the subscription and listening

   The code subscribes to 'chat' channel and listens for messages.

2. Step 2: Decode and print the message data

   When a message is received, it decodes the bytes and prints with prefix 'Received:'.

3. Final Answer:

   Received: Hello everyone -> Option A

4. Quick Check:

   Message data decoded and printed [OK]

Hint: Listen loop prints decoded message data on 'message' type [OK]

Common Mistakes:

• Printing message type instead of data
• Not decoding bytes to string
• Assuming code errors without message

4. You wrote this code to subscribe to Redis messages but your Django app freezes. What is the likely problem?

import redis

r = redis.Redis()

pubsub = r.pubsub()
pubsub.subscribe('notifications')

for message in pubsub.listen():
    print(message)

medium

A. The subscribe() method is missing a callback function

B. The print statement syntax is incorrect

C. Redis server is not running, causing freeze

D. The listen() loop blocks the main thread, freezing the app

Solution

1. Step 1: Analyze the listen() method behavior

   The listen() method blocks and waits for messages, running an infinite loop.

2. Step 2: Understand impact on Django app

   Running this loop in the main thread freezes the app because it never returns control.

3. Final Answer:

   The listen() loop blocks the main thread, freezing the app -> Option D

4. Quick Check:

   Blocking listen() causes freeze [OK]

Hint: Run listen() in background thread to avoid blocking [OK]

Common Mistakes:

• Thinking subscribe() needs a callback
• Assuming Redis server down causes freeze
• Misreading print syntax as error

5. You want to build a Django app that updates the UI in real-time when Redis messages arrive. Which approach best keeps the app responsive while receiving messages?

hard

A. Use Redis publish without subscribing to any channel

B. Run the Redis subscribe listen loop in a separate background thread

C. Call pubsub.listen() directly in the main Django view function

D. Store messages in Django database and poll every minute

Solution

1. Step 1: Identify the need for responsiveness

   The app must stay responsive while waiting for Redis messages.

2. Step 2: Choose non-blocking message listening

   Running the listen loop in a background thread prevents blocking the main app thread.

3. Step 3: Evaluate other options

   Calling listen() in main thread blocks; publishing without subscribing misses messages; polling is slow and inefficient.

4. Final Answer:

   Run the Redis subscribe listen loop in a separate background thread -> Option B

5. Quick Check:

   Background thread keeps app responsive [OK]

Hint: Use background thread for listening to avoid blocking UI [OK]

Common Mistakes:

• Running listen() in main thread causing freeze
• Ignoring subscription and only publishing
• Using slow polling instead of real-time updates