Day 1 - Clustering

📌 Key Takeaways

• A cluster is a setup that ties multiple computers together and uses them as if they were one.
• By purpose, clusters fall into three types — High Performance Computing (HPC), High Availability (HA), and Load Balancing (LB).
• HPC computes fast, HA never stops, and load balancing splits the work.
• In practice, web services usually combine load balancing + high availability.
• The classic Linux-built HPC cluster is the Beowulf cluster.

What Is a Cluster

   [ User ]
        │
        ▼
   ┌─────────────────────────────┐
   │  Several computers (nodes)  │
   │  are tied together and      │
   │  look like a single machine │
   │   ▢  ▢  ▢  ▢               │
   └─────────────────────────────┘

• There is a limit to boosting the performance of a single machine, and the cost rises sharply. Tying several machines together is cheaper and easier to expand.
• Each computer in the group is called a node.
• The nodes are connected over a network, and from the outside they must look like a single system. Ten servers placed side by side that know nothing about each other are not a cluster.

• If you see the phrase "several cheap PCs" in a passage, it is talking about scale-out, that is, a cluster.

The Three Types of Clusters

Memorizing the definitions separately is the whole point of this unit. Questions come in the form of picking which of the three is being described.

The quickest question for telling the three apart is "what do the machines share?"

• High-computation, high-performance, HPC, parallel, and supercomputer are all words for the same box. Even if a choice says "high-performance cluster", read it as the same as HPC.
• "High performance" and "high availability" only look alike; they are on opposite sides. The former is about speed, the latter about no downtime.

HPC Cluster

• Several nodes split and solve a single problem. That is why it is also called parallel computing.
• A Beowulf cluster is an HPC cluster built by tying cheap PCs together with Linux. The name itself gets asked.

   User ──► Master node ──┬── Compute node 1   computes piece A
            (splits the   ├── Compute node 2   computes piece B
             job, hands   ├── Compute node 3   computes piece C
             out pieces,  └── Compute node 4   computes piece D
             collects            │
             results)    ▲       │
                    └── results merged into one answer ──┘

• Beowulf began in 1994 at NASA, when several ordinary PCs were tied together with Ethernet. The idea was to do the same job with common parts and open software instead of an expensive dedicated supercomputer.
• The layout is one master node + several compute nodes. Users connect only to the master, and the compute nodes just do the computation they are told to do.
• The nodes need conventions for exchanging pieces and results. The parallel programming libraries used for this are MPI (Message Passing Interface) and PVM (Parallel Virtual Machine).
• Not every program gets faster. Only programs written so that the work can be broken into pieces benefit from adding nodes. That is why it does not suit services like web servers, where each request is small.

HA Cluster

   Primary server (Active) ──── serving
        │  heartbeat checks that each is alive
   Standby server (Standby) ── waiting
 
   If the primary dies  →  the standby takes over immediately (failover)

• Availability is "the percentage of time the service is up". It is used for systems that must not stop, such as banks and hospitals.
• The goal is not to raise performance but to keep the service from being cut off. This distinction is important.

The terms used in an HA setup follow one after another.

• Read as a flow: heartbeat stops → failover → (repair) → failback. Choices that swap failover and failback are the trap.
• Users do not notice the server has changed, because the standby node takes over the service address as is.

Availability is "the percentage of time alive", so it is promised as a number. Each additional 9 cuts the allowed downtime to one tenth.

• The calculation is 1 year (8,760 hours) × (1 − availability). For 99.9%, 8,760 × 0.001 = 8.76 hours.
• On Linux, HA clusters are built with open software such as Heartbeat, Pacemaker, and Corosync. At Level 2, the exam asks not how to build one but only for the link "heartbeat = an HA term".

LB Cluster

              Requests
                │
          ┌─────┴─────┐
       Load balancer
       ┌────┬────┬────┐
     Web1 Web2 Web3 Web4

• Traffic that one machine cannot handle is shared among several machines.
• Even if one machine dies, the rest keep serving, so availability goes up too.

LVS (Linux Virtual Server) is a project that builds a load balancer with a feature of the Linux kernel.

• The "Virtual" in the name does not mean a virtual machine; it means several machines look like a single server. Don't confuse it with the virtualization we cover tomorrow.
• Three methods of forwarding requests are known: NAT · DR (Direct Routing) · TUN (IP tunneling), and who gets each request is decided by a scheduling method.

• What you need at Level 2 is the pair "LVS = load balancing". For the method and scheduling names, it is enough that they do not look unfamiliar when you read a passage.

In Practice They Are Used Together

Web services usually combine load balancing and high availability. Splitting requests across several servers (load balancing) while the rest keep handling requests even if one dies (high availability) means the two goals fit together naturally.

• If the combination "load balancing + high availability" appears among the choices, it is usually the answer. Conversely, HPC has a different nature from web services.

                  User requests
                      │
        ┌─────────────┴─────────────┐
   Balancer A (Active) ══heartbeat══ Balancer B (Standby)   ← high availability
        └─────────────┬─────────────┘
              ┌───────┼───────┐
             Web1    Web2    Web3                           ← load balancing

• If you only increase the number of web servers, a single load balancer remains as a single point of failure. So the load balancer itself is made redundant as Active-Standby. This diagram is what "load balancing + high availability" actually looks like.
• For combination questions, look first at the nature of the service.

Telling Them Apart from Passages

Passages leak keywords instead of the cluster name. Practice picking the box from the words.

Commonly Missed Points

1. An HA cluster raises performance → No. The purpose is no downtime. The standby server in an Active-Standby setup does not work normally.
2. Load balancing and HPC are the same thing → Both "split", but load balancing splits different requests, while HPC splits the pieces of one job.
3. Beowulf is a load balancing cluster → It is HPC. The representative load balancer is LVS.
4. Heartbeat is a load balancing method → It is the signal that confirms node liveness in high availability.
5. Failback is the action of switching over to the standby server → That is failover. Failback is the action of returning.
6. Embedded systems and grids are also kinds of clusters → No. There are only three cluster types.
7. Doubling the nodes makes anything twice as fast → It only helps for computations that can be broken into pieces.
8. LVS is a virtual machine technology → It is load balancing, not virtualization.

Distinguishing Similar Concepts

• An embedded system is not a cluster. This name gets mixed into questions like "which of the following is not a type of cluster".

Tomorrow we cover virtualization technologies and the features of each product.

📖 Glossary

• Cluster : A setup that ties several computers together so they act as one.
• Node : Each individual computer that makes up a cluster.
• HPC cluster : A cluster in which several nodes split and process one big computation.
• Beowulf cluster : The classic HPC cluster built by tying cheap PCs together with Linux.
• HA cluster : A cluster configured so the service does not stop even when a failure occurs.
• Failover : The action where the standby server takes over the role when the primary server stops.
• Heartbeat : The signal nodes exchange periodically to confirm that each other is alive.
• LB cluster : A cluster that distributes requests across several servers.
• LVS : Linux Virtual Server, which builds a load balancer with Linux. It has nothing to do with virtual machines.
• Grid computing : A method of gathering and using the idle resources of geographically scattered computers.