⚖️ Load Balancing Algorithms

🌱Beginner · 0–1 yrBeginner0–1 yr experience Foundational concepts explained from first principles. No prior system-design experience required.Prerequisites: Comfortable reading code. Familiarity with at least one programming language.

Load balancing is the process of distributing network traffic across multiple servers. This ensures no single server bears too much load, which improves responsiveness and availability.

---

1. Round Robin

Concept: The simplest algorithm. It passes each new request to the next server in a fixed, rotating list.

🔄 How it Works

1. Request 1 → Server A
2. Request 2 → Server B
3. Request 3 → Server C
4. Request 4 → Server A (Repeat)

📊 Diagram: Round Robin Flow

💻 Code Example: Round Robin

class RoundRobinLB {
  constructor(servers) {
    this.servers = servers;
    this.index = 0;
  }

  getNextServer() {
    const server = this.servers[this.index];
    this.index = (this.index + 1) % this.servers.length;
    return server;
  }
}

const lb = new RoundRobinLB(["App-Server-1", "App-Server-2", "App-Server-3"]);
console.log(lb.getNextServer()); // App-Server-1
console.log(lb.getNextServer()); // App-Server-2

---

2. Least Connections

Concept: Directs traffic to the server with the fewest active connections. This is superior when requests take varying amounts of time to process.

📉 Why Use Least Connections?

If Server A is handling a heavy database query (long-lived connection) and Server B just finished a quick request, Round Robin would still send the next request to A. Least Connections intelligently sends it to B.

📊 Diagram: Least Connections Logic

💻 Code Example: Least Connections

class LeastConnectionsLB {
  constructor(servers) {
    // Array of objects tracking active connections
    this.servers = servers.map((name) => ({ name, activeConnections: 0 }));
  }

  getNextServer() {
    // Find server with minimal connections
    const bestServer = this.servers.reduce((prev, curr) =>
      prev.activeConnections < curr.activeConnections ? prev : curr
    );

    bestServer.activeConnections++; // Simulate connection start
    return bestServer;
  }

  releaseServer(serverName) {
    const server = this.servers.find((s) => s.name === serverName);
    if (server && server.activeConnections > 0) {
      server.activeConnections--;
    }
  }
}

const lb = new LeastConnectionsLB(["Svr-1", "Svr-2"]);
const s = lb.getNextServer(); // Returns Svr-1
console.log(`Routing to ${s.name} (Active: ${s.activeConnections})`);

---

3. IP Hashing

Concept: Uses a hash function to map a client's IP address to a specific server. This ensures that a particular user always hits the same server (Session Affinity).

🔐 Use Case: Sticky Sessions

Useful when you store session data locally on a server (though modern designs prefer external caches like Redis).

📊 Diagram: IP Mapping

💻 Code Example: IP Hashing

class IPHashLB {
  constructor(servers) {
    this.servers = servers;
  }

  // Simple numeric hash for demonstration
  hash(ip) {
    return ip.split(".").reduce((acc, part) => acc + parseInt(part), 0);
  }

  getNextServer(clientIP) {
    const hashValue = this.hash(clientIP);
    const index = hashValue % this.servers.length;
    return this.servers[index];
  }
}

const lb = new IPHashLB(["Primary", "Secondary", "Tertiary"]);
console.log(lb.getNextServer("192.168.1.1")); // Consistent mapping
console.log(lb.getNextServer("192.168.1.1")); // Always same server

---

📈 Architecture Overview

A load balancer is often the entry point (Reverse Proxy) for your infrastructure.

---

⚖️ Comparison Table

Algorithm	Complexity	Best For	Downsides
Round Robin	Very Low	Equal server specs, short tasks	Ignores server load
Least Conn	Medium	Long-lived connections	Overhead of tracking state
IP Hashing	Low	Session persistence	Can lead to uneven distribution