0
0
HLDsystem_design~12 mins

Redundancy and fault tolerance in HLD - Architecture Diagram

Choose your learning style9 modes available
LearnWhyDeepArchPracticeChallengeDesignRecallScale
System Overview - Redundancy and fault tolerance

This system is designed to remain available and reliable even when some parts fail. It uses multiple copies of components and smart routing to avoid downtime. The goal is to keep the service running smoothly without interruption.

Architecture Diagram
          +----------------+
          |     Users      |
          +--------+-------+
                   |
           +-------v-------+
           | Load Balancer |<----------------+
           +-------+-------+                 |
                   |                         |
    +--------------+--------------+          |
    |                             |          |
+---v---+                     +---v---+      |
| API 1 |                     | API 2 |      |
+---+---+                     +---+---+      |
    |                             |          |
    +-------------+---------------+          |
                  |                          |
          +-------v-------+                  |
          | Message Queue |------------------+
          +-------+-------+
                  |
          +-------v-------+
          | Worker Nodes  |
          +-------+-------+
                  |
          +-------v-------+
          |  Database(s)  |
          +-------+-------+
                  |
          +-------v-------+
          |     Cache     |
          +---------------+
Components
Users
client
End users who send requests to the system
Load Balancer
load_balancer
Distributes incoming requests evenly across API servers
API 1
service
Handles user requests and business logic
API 2
service
Backup API server to ensure availability if API 1 fails
Message Queue
queue
Decouples request processing and enables retry on failure
Worker Nodes
service
Processes tasks asynchronously from the queue
Database(s)
database
Stores persistent data with replication for fault tolerance
Cache
cache
Speeds up data retrieval and reduces load on the database
Request Flow - 10 Hops
Users → Load Balancer
Load Balancer → API 1
API 1 → Cache
Cache → API 1
API 1 → Message Queue
Message Queue → Worker Nodes
Worker Nodes → Database(s)
Database(s) → Cache
API 1 → Load Balancer
Load Balancer → Users
Failure Scenario
Component Fails:API 1
Impact:Requests routed to API 1 fail, causing service disruption
Mitigation:Load balancer detects failure and routes traffic to API 2 automatically
Architecture Quiz - 3 Questions
Test your understanding
What component ensures requests are evenly distributed to multiple API servers?
AMessage Queue
BLoad Balancer
CCache
DWorker Nodes
Design Principle
This architecture uses redundancy by having multiple API servers and fault tolerance through components like load balancers, caches, and message queues. These ensure the system stays available and responsive even if some parts fail.