What Makes a System Highly Available? 6 Proven Architecture Patterns

Before diving into specific high‑availability (HA) solutions, it is useful to define the core traits an HA architecture should exhibit:

Master‑Slave Failover : When a primary instance crashes, traffic should be redirected to a standby instance within seconds, and the failed node should automatically revert to a slave role once recovered.

Load Balancing : Traffic must be distributed across multiple instances when a single node cannot handle the load. Advanced HA setups may dynamically adjust distribution based on each node’s performance to keep response times balanced.

Horizontal Scalability : Adding capacity should be transparent to callers, allowing the system to grow without disrupting existing services.

LVS + Keepalive

LVS (Linux Virtual Server) creates a virtual IP that is shared by several Linux machines running IPVS and Keepalive. Only one machine holds the virtual IP at a time; if it fails, another machine immediately takes over, ensuring continuous service availability. Keepalive continuously checks the health of each node.

NGINX

Although NGINX is primarily a reverse‑proxy server, its rich load‑balancing capabilities make it a common choice for HA. It can distribute requests among backend servers and, when combined with Keepalive or a custom DNS setup, can detect and bypass failed nodes.

Key concepts:

Forward proxy : client‑side proxy that accesses external resources on behalf of the client.

Reverse proxy : server‑side proxy that forwards client requests to internal services, hiding the actual backend servers.

Zookeeper

Zookeeper itself is a distributed coordination service that provides HA. Services register themselves with Zookeeper and maintain a heartbeat. If a service disappears, its registration is removed, preventing clients from routing to a dead instance.

Client‑Side HA Strategies

Using Memcached as an example, a client can maintain connections to multiple cache nodes and apply a selection algorithm. When a node fails, the client re‑routes requests to remaining nodes, though data loss is possible without server‑side replication.

Service‑Level HA (e.g., Redis Replication)

Redis clusters demonstrate HA by having master and replica nodes communicate. If the master fails, a replica is promoted automatically, making the failover transparent to clients.

Middleware‑Based HA

Middleware such as MyCAT can provide HA for databases like MySQL. Early Redis versions also relied on external middleware to achieve HA before native clustering was available.

In summary, the article offers a brief overview of common HA patterns. Detailed implementations—especially for stateful services and advanced microservice scenarios—require deeper exploration beyond this introductory guide.