Understanding Distributed Systems and Cluster Architecture: Concepts, Types, and Differences

In simple terms, distributed computing shortens the execution time of a single task to improve efficiency, while clustering increases the number of tasks processed per unit time to boost efficiency.

Example: If a task consists of 10 subtasks, each requiring one hour, a single server would need 10 hours. Using a distributed approach with 10 servers, each handling one subtask, the whole task finishes in one hour (as in Hadoop's Map/Reduce model). In a cluster with 10 servers, if 10 tasks arrive simultaneously, all servers work in parallel and complete the 10 tasks in one hour, effectively processing one task per hour.

Cluster Concept

1. Two Key Characteristics

A cluster is a group of cooperating service entities that together provide a more scalable and highly available platform than a single entity. To the client, a cluster appears as a single service, but it actually consists of multiple service instances.

① Scalability: Performance is not limited to a single instance; new instances can be added dynamically to enhance capacity.

② High Availability: Redundant service instances ensure that if one fails, another takes over, preventing service interruption.

2. Two Essential Capabilities

To achieve scalability and high availability, a cluster must provide:

① Load Balancing: Evenly distributes tasks across computing and network resources within the cluster.

② Error Recovery: If a resource fails while executing a task, another instance transparently continues the task, preserving the required information context.

Both capabilities require that each service instance holds the same task execution information.

3. Two Core Technologies

① Cluster Address: A single address (or virtual image) that clients use to access the cluster; the load balancer manages instance registration and address translation. Some load balancers implement full balancing algorithms, while others only perform task redirection, suitable for ACTIVE‑STANDBY setups.

② Internal Communication: Continuous communication among instances (e.g., heartbeat checks, task context exchange) is essential for load balancing and error recovery.

Cluster Classification

Linux clusters are generally divided into three categories:

High Availability Cluster (HA)

Load Balance Cluster

High Performance Computing Cluster (HPC)

Specific examples include:

• Linux HA Cluster – two‑node hot standby, multi‑node HA, RAC, shared or share‑nothing configurations.

• Linux Load Balance Cluster – e.g., LVS.

• Linux HPC Cluster – Beowulf‑style clusters.

Other types: distributed storage clusters, OpenMosix, rendering farms, etc.

Detailed Introduction

1. High Availability Cluster

Typically a two‑node HA setup, often called “dual‑machine hot standby”. It ensures continuous service availability by minimizing the impact of hardware/software failures on the user‑facing application.

2. Load Balance Cluster

All nodes are active and share the workload. Commonly used for web servers, databases, and application servers. The load balancer directs incoming requests to the least‑busy node, providing both load distribution and fault tolerance.

3. High Performance Computing Cluster (HPC)

Provides computational power beyond a single machine. It includes:

① High‑Throughput Computing – many independent tasks (e.g., SETI@HOME) processed in parallel.

② Distributed Computing – tightly coupled tasks requiring extensive data exchange, classified as MIMD.

4. Relationship and Differences Between Distributed Systems and Clusters

Distributed systems spread workloads across separate locations, while clusters concentrate multiple servers in one place to serve the same workload. Any node in a distributed system can act as a cluster, but a cluster is not necessarily a distributed system.

Example: A popular website may use a front‑end server to route requests to a pool of back‑end servers (cluster). If a back‑end server fails, another takes over (high availability). In a loosely coupled distributed setup, a failed node could make its specific service unavailable.

Source: blog.csdn.net/bluishglc/article/details/5483162