Message brokers (Kafka, RabbitMQ) in Microservices - Scalability & System Analysis

Scalability Analysis - Message brokers (Kafka, RabbitMQ)

Growth Table: Message Brokers (Kafka, RabbitMQ)

Scale	Users / Messages	What Changes?
100 users	~100 msgs/sec	Single broker instance handles traffic easily. Simple setup, low latency.
10,000 users	~10,000 msgs/sec	Broker CPU and disk I/O increase. Need partitioning (Kafka) or multiple queues (RabbitMQ). Start monitoring lag.
1 million users	~1 million msgs/sec	Single broker insufficient. Must use cluster with multiple nodes. Network bandwidth and storage grow. Partitioning and replication critical.
100 million users	~100 million msgs/sec	Massive cluster with multi-region deployment. Data retention and archival strategies needed. Network and storage bottlenecks dominate.

First Bottleneck

The first bottleneck is usually the broker's disk I/O and network bandwidth. Message brokers write messages to disk for durability and replicate them across nodes. As message volume grows, disk throughput and network capacity limit performance before CPU or memory.

Scaling Solutions

• Partitioning/Sharding: Split topics or queues into partitions to distribute load across multiple broker nodes.
• Clustering: Use broker clusters to increase throughput and provide fault tolerance.
• Replication: Replicate partitions for high availability and data durability.
• Caching: Use consumer-side caching or intermediate caches to reduce load on brokers.
• Load Balancing: Distribute producers and consumers evenly across partitions and brokers.
• Compression: Compress messages to reduce network and storage usage.
• Retention Policies: Archive or delete old messages to manage storage growth.
• Multi-region Deployment: Deploy brokers closer to users to reduce latency and network load.

Back-of-Envelope Cost Analysis

• At 10,000 msgs/sec, assuming 1 KB per message, storage grows by ~864 GB/day (10,000 * 1 KB * 86,400 seconds).
• Network bandwidth needed: 10,000 msgs/sec * 1 KB = ~10 MB/s (80 Mbps), manageable on 1 Gbps links.
• At 1 million msgs/sec, storage grows ~86 TB/day, requiring distributed storage and archival.
• Broker nodes handle ~5,000-10,000 msgs/sec each; so 1 million msgs/sec needs ~100-200 nodes.
• Replication doubles or triples storage and network needs depending on replication factor.

Interview Tip

Start by clarifying message volume and durability needs. Identify bottlenecks like disk I/O and network early. Discuss partitioning and clustering as primary scaling methods. Mention trade-offs between consistency, availability, and latency. Use real numbers to justify scaling steps.

Self Check

Your message broker handles 1,000 QPS. Traffic grows 10x to 10,000 QPS. What do you do first?

Answer: Add partitions or queues and scale out the broker cluster horizontally to distribute load. This addresses disk I/O and network bottlenecks before upgrading hardware.

Key Result

Message brokers scale by partitioning and clustering to distribute disk and network load; disk I/O and network bandwidth are first bottlenecks as message volume grows.

Practice

1. What is the primary role of a message broker like Kafka or RabbitMQ in a microservices architecture?

easy

A. To store large amounts of user data permanently

B. To enable services to communicate asynchronously by passing messages

C. To replace the database in microservices

D. To directly execute business logic in services

Solution

1. Step 1: Understand message broker function

   Message brokers act as middlemen that help services send and receive messages without waiting for each other.

2. Step 2: Identify correct role in microservices

   They enable asynchronous communication, improving scalability and fault tolerance.

3. Final Answer:

   To enable services to communicate asynchronously by passing messages -> Option B

4. Quick Check:

   Message broker = asynchronous communication [OK]

Hint: Message brokers pass messages between services asynchronously [OK]

Common Mistakes:

• Confusing brokers with databases
• Thinking brokers execute business logic
• Assuming brokers store permanent user data

2. Which of the following is the correct way to declare a RabbitMQ queue in code?

easy

A. channel.queueDeclare('task_queue', true, false, false, null);

B. channel.createQueue('task_queue', durable=true);

C. queue.declare('task_queue', persistent=True);

D. rabbitmq.queue('task_queue', durable=True);

Solution

1. Step 1: Recall RabbitMQ queue declaration syntax

   In RabbitMQ Java client, channel.queueDeclare is used with parameters: queue name, durable, exclusive, autoDelete, and arguments.

2. Step 2: Match correct syntax

   channel.queueDeclare('task_queue', true, false, false, null); matches the official method signature and parameter order correctly.

3. Final Answer:

   channel.queueDeclare('task_queue', true, false, false, null); -> Option A

4. Quick Check:

   RabbitMQ queueDeclare syntax = channel.queueDeclare('task_queue', true, false, false, null); [OK]

Hint: Remember RabbitMQ uses channel.queueDeclare with 5 parameters [OK]

Common Mistakes:

• Using incorrect method names like createQueue
• Passing parameters with wrong names or order
• Confusing RabbitMQ syntax with other brokers

3. Given the following Kafka consumer code snippet, what will be the output if the topic has 3 messages and auto-commit is enabled?

consumer.subscribe(['orders'])
for message in consumer.poll(timeout_ms=1000).values():
    print(message.value.decode('utf-8'))

medium

A. Prints nothing because poll returns a dict of lists

B. Prints only the first message and stops

C. Prints all 3 messages from the 'orders' topic

D. Raises an error due to wrong method usage

Solution

1. Step 1: Analyze Kafka consumer.poll() return type

   The poll() method returns a dictionary where keys are partitions and values are lists of messages.

2. Step 2: Understand iteration over poll().values()

   Iterating over values() gives lists of messages, not individual messages, so calling message.value will cause an error because message is a list, not a message object.

3. Final Answer:

   Raises an error due to wrong method usage -> Option D

4. Quick Check:

   poll() returns dict of lists; iterating directly over values and accessing message.value causes error [OK]

Hint: poll() returns dict of lists, not single messages [OK]

Common Mistakes:

• Assuming poll() returns a flat list of messages
• Not decoding message values properly
• Ignoring that poll() returns per-partition batches

4. A developer wrote this RabbitMQ consumer code but it never receives messages:

channel.basicConsume('task_queue', autoAck=False, callback=process_message)

What is the likely issue?

medium

A. The consumer must call channel.start_consuming() to begin receiving messages

B. The callback function name should be 'on_message' instead of 'process_message'

C. autoAck must be set to True for messages to be received

D. The queue name 'task_queue' is invalid and must be changed

Solution

1. Step 1: Understand RabbitMQ consumer lifecycle

   After setting up basicConsume, the consumer must start the event loop with channel.start_consuming() to receive messages.

2. Step 2: Identify missing call

   The code lacks start_consuming(), so no messages are delivered.

3. Final Answer:

   The consumer must call channel.start_consuming() to begin receiving messages -> Option A

4. Quick Check:

   Missing start_consuming() = The consumer must call channel.start_consuming() to begin receiving messages [OK]

Hint: Remember to call start_consuming() after basicConsume [OK]

Common Mistakes:

• Thinking callback function name must be fixed
• Believing autoAck controls message receipt
• Assuming queue name is invalid without evidence

5. You need to design a scalable order processing system using Kafka. Which approach best ensures message order per customer while allowing parallel processing across customers?

hard

A. Use a single Kafka partition for all orders to keep global order

B. Use multiple topics, one per customer, to isolate order streams

C. Partition messages by customer ID so each customer's orders stay ordered in their partition

D. Send all orders to a single consumer instance to maintain order

Solution

1. Step 1: Understand Kafka partitioning and ordering

   Kafka guarantees order only within a partition, so to keep order per customer, messages must be partitioned by customer ID.

2. Step 2: Evaluate options for scalability and ordering

   Partitioning by customer ID allows parallel processing across partitions (customers) while preserving order per customer.

3. Final Answer:

   Partition messages by customer ID so each customer's orders stay ordered in their partition -> Option C

4. Quick Check:

   Partition by key for order + parallelism = Partition messages by customer ID so each customer's orders stay ordered in their partition [OK]

Hint: Partition by customer ID to keep order and scale processing [OK]

Common Mistakes:

• Using single partition limits scalability
• Creating many topics adds unnecessary complexity
• Using single consumer blocks parallelism