Shard key selection in HLD - Architecture Diagram

System Overview - Shard key selection

This system demonstrates how to select an effective shard key for a distributed database. The goal is to distribute data evenly across multiple database shards to improve scalability and performance while minimizing hotspots and cross-shard queries.

Architecture Diagram

User
  |
  v
Load Balancer
  |
  v
API Gateway
  |
  v
Shard Key Selector Service
  |
  v
+-----------------------+
|  Distributed Database  |
|  +-------+ +-------+  |
|  |Shard 1| |Shard 2|  |
|  +-------+ +-------+  |
+-----------------------+
  |
  v
Cache Layer

Components

User

client

Sends requests to the system

Load Balancer

load_balancer

Distributes incoming requests evenly to API Gateway instances

API Gateway

api_gateway

Handles client requests and routes them to the Shard Key Selector Service

Shard Key Selector Service

service

Determines the shard key based on request data to route queries to the correct shard

Distributed Database

database_cluster

Stores data partitioned across multiple shards based on the shard key

Shard 1

database_shard

Stores a subset of data determined by shard key range or hash

Shard 2

database_shard

Stores another subset of data determined by shard key range or hash

Cache Layer

cache

Caches frequently accessed data to reduce database load

Request Flow - 8 Hops

User → Load Balancer

Load Balancer → API Gateway

API Gateway → Shard Key Selector Service

Shard Key Selector Service → Cache Layer

Cache Layer → Distributed Database

Distributed Database → Cache Layer

Cache Layer → API Gateway

API Gateway → User

Failure Scenario

Component Fails:Shard Key Selector Service

Impact:Requests cannot be routed to the correct shard, causing failures or delays in data access

Mitigation:Deploy multiple instances with health checks and failover; cache shard key mappings to reduce dependency

Architecture Quiz - 3 Questions

Which component decides how to split data across shards?

A Cache Layer

B Shard Key Selector Service

C Load Balancer

D API Gateway

Design Principle

This architecture shows the importance of selecting a good shard key to evenly distribute data and reduce cross-shard queries. Using a dedicated service for shard key selection helps centralize routing logic. Caching improves performance by reducing database load. Load balancing ensures availability and scalability.

Practice

1. What is the main purpose of selecting a shard key in a distributed database system?

easy

A. To compress data to save storage space

B. To encrypt data for security purposes

C. To backup data automatically

D. To split data across servers for better load distribution and faster access

Solution

1. Step 1: Understand shard key role

   The shard key determines how data is divided across multiple servers or shards.

2. Step 2: Identify main benefit

   Splitting data helps balance load and speeds up data retrieval by parallelizing queries.

3. Final Answer:

   To split data across servers for better load distribution and faster access -> Option D

4. Quick Check:

   Shard key purpose = split data load [OK]

Hint: Shard key splits data to spread load and speed up access [OK]

Common Mistakes:

• Confusing shard key with encryption key
• Thinking shard key compresses data
• Assuming shard key is for backup

2. Which of the following is a good characteristic of a shard key?

easy

A. Has very few unique values

B. Has many unique values and distributes data evenly

C. Is always a timestamp

D. Is a large text field

Solution

1. Step 1: Identify shard key traits

   A good shard key should have many unique values to avoid data concentration.

2. Step 2: Understand distribution importance

   Even distribution prevents hotspots and balances load across shards.

3. Final Answer:

   Has many unique values and distributes data evenly -> Option B

4. Quick Check:

   Good shard key = unique + even distribution [OK]

Hint: Choose shard keys with many unique values and even spread [OK]

Common Mistakes:

• Picking keys with few unique values causing hotspots
• Assuming timestamp is always best shard key
• Using large text fields that slow down indexing

3. Consider a user database sharded by country_code which has only 5 unique values. What is the likely problem with this shard key?

medium

A. Data will be evenly distributed across shards

B. It will encrypt user data automatically

C. Some shards will be overloaded due to uneven data distribution

D. Queries will be faster because of fewer shards

Solution

1. Step 1: Analyze unique values count

   Only 5 unique values means few shards and many users per shard.

2. Step 2: Understand load distribution

   Popular countries will have more users, causing some shards to be overloaded.

3. Final Answer:

   Some shards will be overloaded due to uneven data distribution -> Option C

4. Quick Check:

   Few unique keys = uneven shard load [OK]

Hint: Few unique shard keys cause uneven load and hotspots [OK]

Common Mistakes:

• Assuming fewer shards always improve speed
• Thinking shard key encrypts data
• Ignoring uneven data distribution effects

4. A system uses user_id % 10 as a shard key but notices uneven shard sizes. What is the likely cause?

medium

A. User IDs are not uniformly distributed modulo 10

B. Shard key is too unique

C. Shard key is a string instead of number

D. System is encrypting shard keys

Solution

1. Step 1: Understand modulo shard key

   Modulo operation expects uniform distribution of user IDs.

2. Step 2: Identify distribution problem

   If user IDs cluster in certain ranges, modulo results cluster causing uneven shards.

3. Final Answer:

   User IDs are not uniformly distributed modulo 10 -> Option A

4. Quick Check:

   Non-uniform IDs cause uneven modulo shard keys [OK]

Hint: Modulo shard keys need uniform input distribution [OK]

Common Mistakes:

• Assuming modulo always balances shards
• Confusing shard key type with encryption
• Ignoring data distribution patterns

5. You design a sharded system for an e-commerce app. Users query orders mostly by user_id and order_date. Which shard key choice best supports fast queries and balanced load?

hard

A. Shard by a composite key of user_id and order_date

B. Shard by user_id only

C. Shard by order_date only

D. Shard by a random UUID

Solution

1. Step 1: Match shard key to query patterns

   Users query by both user_id and order_date, so shard key should support both.

2. Step 2: Evaluate shard key options

   Sharding by user_id alone may cause hotspots; order_date alone may cause uneven load by time.

3. Step 3: Use composite key benefits

   Composite key balances load and supports queries filtering by either field efficiently.

4. Final Answer:

   Shard by a composite key of user_id and order_date -> Option A

5. Quick Check:

   Composite shard key matches queries and balances load [OK]

Hint: Composite keys balance load and match query patterns best [OK]

Common Mistakes:

• Choosing single field shard keys ignoring query patterns
• Using random UUID causing inefficient queries
• Ignoring load balancing in shard key choice