중복성과 장애 조치 메커니즘

Imagine a crucial part of your system stopping unexpectedly. What happens?

A Single Point of Failure (SPOF) is any component whose failure would cause the entire system to stop working.

Designing for high availability means building systems that keep running even when individual parts fail.

To combat SPOFs, we use redundancy. This means having duplicate components or systems ready to take over.

Think of it like having a spare tire for your car. If one tire fails, you have another ready to go.

In system design, redundancy ensures that if one component fails, another can immediately step in.

Redundancy can be applied at various levels within a system:

• Hardware Redundancy: Duplicating physical components like servers, power supplies, or network cards.
• Software Redundancy: Running multiple instances of an application or service.
• Data Redundancy: Storing copies of data across different disks or locations.

The goal is always to eliminate any single component that could bring down the whole system.

A common example of hardware redundancy for storage is RAID (Redundant Array of Independent Disks).

RAID combines multiple physical disk drives into one or more logical units. If one disk fails, data is still available from the others, preventing data loss and system downtime.

Similarly, servers often have redundant power supplies to ensure continuous operation.

Redundancy provides the backup components, but how does the system switch to them when needed? That's where failover comes in.

Failover is the process of automatically switching to a redundant or standby system upon the failure or abnormal termination of the primary system.

It's the 'action' part of using your spare tire – the system detects a problem and activates the backup.

Failover can be performed in two main ways:

• Manual Failover: Requires human intervention to detect a failure and switch to the backup. This can be slow, costly, and error-prone.
• Automatic Failover: The system detects a failure and switches to the backup without human help. This is crucial for high availability and relies on continuous monitoring and health checks.

Automatic failover significantly reduces recovery time.

In an Active-Passive setup, one component (the 'active') handles all requests, while another component (the 'passive' or 'standby') is ready to take over.

The passive component is kept up-to-date (e.g., through data replication) but doesn't serve live traffic until a failover occurs.

Example: A primary database server with a replica that is only used if the primary fails.

In an Active-Active setup, all redundant components are simultaneously handling requests.

A load balancer distributes incoming traffic across all active components. If one component fails, the load balancer simply stops sending traffic to it, and the remaining active components handle the full load.

This pattern offers better resource utilization and often higher scalability compared to Active-Passive.

In this lesson, we explored how redundancy (having duplicates) and failover (automatic switching to backups) are fundamental for building highly available and reliable systems.

These mechanisms help eliminate single points of failure, ensuring your applications remain accessible and functional even when unexpected issues arise.

Understanding these concepts is key to designing robust and resilient architectures that can withstand failures.