Mastering Million-Request Concurrency: Nginx + LVS + Keepalived Blueprint

High concurrency is a core challenge for large‑scale architectures; this article details a practical million‑request solution using LVS, Keepalived, and Nginx.

Million‑Concurrency Scheme

In today's growing internet services, handling massive traffic requires combining load balancing and reverse proxy. The Nginx + LVS + Keepalived stack is a common high‑availability solution.

LVS Load Entry

The first layer (load‑balancing entry) consists of an LVS cluster managed by Keepalived, exposing a virtual IP (VIP) that forwards requests to the Nginx cluster.

# IPVS virtual service for HTTP
virtual_server 10.0.0.100:80 {
    delay_loop 5
    lb_algo rr
    lb_kind DR
    persistence_timeout 300
    protocol TCP
    real_server 10.0.0.11:80 {
        weight 1
        TCP_CHECK {
            connect_timeout 3
            connect_port 80
        }
    }
    real_server 10.0.0.12:80 {
        weight 1
        TCP_CHECK {
            connect_timeout 3
            connect_port 80
        }
    }
}

Keepalived (High Availability and Health Check)

Keepalived, based on VRRP, elects a Master node and multiple Backup nodes. The Master binds the virtual IP; if it fails, a Backup takes over transparently, ensuring seamless service continuity.

# Check Nginx status script
vrrp_script chk_nginx {
    script "/etc/keepalived/check_nginx.sh"
    interval 2
    weight -20  # lower priority if Nginx is down
}

Nginx (Layer‑7 Reverse Proxy and Application Delivery)

Nginx instances receive external requests and distribute them to backend application servers according to the configured load‑balancing algorithm (e.g., round‑robin, weighted, IP hash).

http {
    upstream backend_servers {
        server 192.168.1.100 weight=5; # backend server 1
        server 192.168.1.101 weight=5; # backend server 2
        server 192.168.1.102 weight=5; # backend server 3
    }

    server {
        listen 80;
        server_name your_domain.com;
        # other directives...
    }
}

This architecture disperses request pressure, hides backend IPs, and enhances security while providing seamless failover.