How do you implement a custom load balancer with health checks?

Question

Accepted Answer

**Load balancer with health checks** — distribute traffic and monitor health.

```javascript
const httpProxy = require("http-proxy");
const http = require("http");

class LoadBalancer {
    constructor() {
        this.proxy = httpProxy.createProxyServer({});
        this.backends = [];
        this.currentIndex = 0;
    }

addBackend(host, port) {
        this.backends.push({
            host,
            port,
            healthy: true,
            failures: 0,
        });
    }

getNextBackend() {
        const healthy = this.backends.filter(b => b.healthy);
        if (!healthy.length) return null;

const backend = healthy[this.currentIndex % healthy.length];
        this.currentIndex++;
        return backend;
    }

async healthCheck(backend, timeout = 5000) {
        return new Promise((resolve) => {
            const req = http.get(
                `http://${backend.host}:${backend.port}/health`,
                { timeout },
                (res) => {
                    resolve(res.statusCode === 200);
                }
            );
            req.on("error", () => resolve(false));
            req.on("timeout", () => {
                req.destroy();
                resolve(false);
            });
        });
    }

startHealthChecks(interval = 10000) {
        setInterval(async () => {
            for (const backend of this.backends) {
                const healthy = await this.healthCheck(backend);
                if (healthy) {
                    backend.failures = 0;
                    backend.healthy = true;
                } else {
                    backend.failures++;
                    if (backend.failures >= 3) {
                        backend.healthy = false;
                        console.log(`Backend ${backend.host} marked unhealthy`);
                    }
                }
            }
        }, interval);
    }
}

// Usage
const lb = new LoadBalancer();
lb.addBackend("127.0.0.1", 3001);
lb.addBackend("127.0.0.1", 3002);
lb.startHealthChecks();

http.createServer((req, res) => {
    const backend = lb.getNextBackend();
    if (!backend) {
        res.writeHead(503);
        return res.end("No backends available");
    }
    lb.proxy.web(req, res, {
        target: `http://${backend.host}:${backend.port}`,
    });
}).listen(80);
```

Node.js: How do you implement a custom load balancer with health checks?