Use Nginx as a Load Balancer

As web services are evolving rapidly, ensuring that your application can handle a high traffic volume without compromising on speed and reliability is paramount. One effective way to achieve this is through load balancing, and NGINX stands out as a powerful tool for this purpose.

What is Load Balancing?

Before learning about the specifics of NGINX, it’s essential to understand what load balancing is. Load balancing is distributing network or application traffic across multiple servers. This distribution helps in optimizing resource use, maximizing throughput, reducing response time, and ensuring fault tolerance of applications.

Why Choose NGINX for Load Balancing?

NGINX, known for its high performance, stability, rich feature set, simple configuration, and low resource consumption, is widely used as a web server, reverse proxy and load balancer. When used as a load balancer, NGINX efficiently distributes incoming traffic among backend servers, known as a server pool or server farm, to improve the performance, scalability, and reliability of web applications.

In this article, we will learn how to use NGINX as a load balancer, focusing on their implementations with 5 popular techniques,

1. Round Robin
2. Weighted Round Robin
3. Least Connection Technique
4. IP-based hashing Technique
5. Path-based distribution

Prerequisite:

Install NGINX: Ensure that NGINX is installed on your system. (If not you can run nginx on docker. The steps are mentioned in use-nginx-as-a-reverse-proxy )

1. Round Robin

The round-robin method is the simplest form of load-balancing algorithm. In this approach, NGINX passes each new request to the next server in line, eventually distributing requests evenly across all servers.

Configuration Steps:

1. Define the upstream server block. Here, list all the backend servers in the pool.
2. Set the load balancing method to Round Robin (which is the default setting).
3. Configure the server block to pass requests to the upstream server block.

Config File:

http {

    upstream backend {
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }

server {
        location / {
            proxy_pass https://backend;
        }
    }
}
        

2. Weighted Round Robin

The Weighted Round Robin technique is an enhanced version of the Round Robin method. Each server is assigned a weight based on its processing capacity in this approach. Servers with higher weights receive more requests than those with lower weights.

Configuration Steps:

1. Define Weights for Each Server: In the upstream server block, assign a weight to each server using the weight parameter.
2. Other Steps: Similar to the Round Robin setup.

Config File:

http {

    upstream backend {
        server backend1.example.com weight=3;
        server backend2.example.com weight=2;
        server backend3.example.com weight=1;
    }

server {
        location / {
            proxy_pass https://backend;
        }
    }
}
        

3. Least Connection Technique

The Least Connection load balancing method is a technique used to distribute incoming network or web traffic across multiple servers in a way that optimizes the use of server resources.

Implementing the Least Connection technique in NGINX for load balancing is an effective strategy, especially in scenarios where the request load is unevenly distributed. This method differs from the Round Robin or Weighted Round Robin approaches, as it directs new connections to the server with the fewest active connections, rather than distributing them evenly or based on predefined weights. This approach can be more efficient when dealing with varying request sizes or processing times.

Configuration Steps

Upstream Server Block:

1. In this block, list all the backend servers that are part of your load-balancing scheme.
2. Instead of the default Round Robin method, specify least_conn; to enable the Least Connection method.

Config File:

http {

    upstream backend {
        least_conn;  # Enable Least Connection method
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }

    server {
        location / {
            proxy_pass https://backend;
        }
    }
}        

4. IP-based hashing Technique

IP-based hashing is a load-balancing technique used to distribute incoming network or web traffic across multiple servers. In this method, the client’s IP address is used as a key to consistently direct their requests to the same server in a pool of servers.

This approach is particularly useful for ensuring session persistence in applications where a client needs to interact with the same server during each session.

Configuration Steps

Upstream Server Block:

1. List all the backend servers that are part of your load-balancing scheme in this block.
2. Specify hash $remote_addr; to enable IP-based hashing. This directive tells NGINX to use the client's IP address ($remote_addr) as the key for hashing.

Config File:

http {
    upstream backend {
        hash $remote_addr;  # Enable IP-based hashing
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }

    server {
        location / {
            proxy_pass https://backend;
        }
    }
}        

5. Path-based distribution Technique

Path-based distribution, also known as URL path-based routing, is a load-balancing technique used to distribute incoming web traffic to different servers based on the URL path of the request.

In this approach, the path of the incoming request determines which server or service will handle the request. This method is particularly useful in environments where different segments of an application or different applications are hosted on separate servers.

Configuration Steps

Define Multiple Upstream Blocks:

1. Create separate upstream blocks for each path, each pointing to a different set of backend servers.

Configure the Server Block with Location Directives:

1. Within the server block, use location directives to match different URL paths.
2. Each location block should proxy traffic to the corresponding upstream block based on the path.

Config File:

http {

    upstream backend1 {
        server server1.example.com;
    }

    upstream backend2 {
        server server2.example.com;
    }

    server {
        listen 80;

        location /path1/ {
            proxy_pass https://backend1;
        }

        location /path2/ {
            proxy_pass https://backend2;
        }
    }

}        

In this example, requests going to /path1/ are forwarded to backend1 (which could be a specific microservice or server cluster), while requests to /path2/ are sent to backend2.

Conclusion

Utilizing NGINX as a load balancer through techniques like Round Robin, Weighted Round Robin, Least Connection, IP-based Hashing, and Path-based Distribution can significantly elevate the performance and reliability of web applications.

The simplicity of the Round Robin method, combined with the adaptive resource allocation of the Weighted Round Robin approach, showcases NGINX’s versatility for diverse operational needs. Additionally, the Least Connection method optimizes server workload by directing traffic to the least busy servers, while IP-based Hashing ensures consistent user sessions by tying clients to specific servers. Path-based Distribution further enhances this by directing traffic based on URL paths, making NGINX an ideal choice for complex, multi-faceted web architectures.

As your application scales and demands evolve, NGINX stands as a robust, flexible platform, ready to meet the changing load balancing requirements effectively.

If you found this article helpful, don’t forget to give it a like ?? and share it with your friends!