Example of implementing load balancing with Nginx+SpringBoot

Introduction to Load Balancing

Before introducing the load balancing implementation of Nginx, let's briefly talk about the classification of load balancing, which is mainly divided into hardware load balancing and software load balancing. Hardware load balancing is a device that uses a combination of specialized software and hardware. Equipment vendors will provide complete and mature solutions, such as F5, which is very reliable in terms of data stability and security, but is more expensive than software. Software load balancing is mainly based on software such as Nginx, which implements a message queue distribution mechanism.

Simply put, load balancing is to divert many requests and assign them to different servers for processing. For example, I have three servers, A, B, and C, and then use Nginx for load balancing, using a polling strategy. If 9 requests are received at this time, these 9 requests will be evenly distributed to A, B, and Cf servers, and each server will process 3 requests. In this way, we can use the characteristics of multiple machine clusters to reduce the pressure on a single server.

Example diagram of Nginx implementing load balancing:

Load balancing strategy

NGINX Open Source supports four load balancing methods, and NGINX Plus adds two more.

1.Round Robin:

Poll all requests and send them, which is the default allocation method.

nginx.conf configuration example:

upstream
  server www.panchengming.com;
  server www.panchengming2.com;
}

Note: The domain name above can also be replaced by IP.

2. Least Connections:

Send the request to the server with the least number of active connections, also taking into account the server weight.

nginx.conf configuration example:

upstream
  least_conn;
  server www.panchengming.com;
  server www.panchengming2.com;
}

3.IP Hash:

The server to which the request is sent is determined by the client's IP address. In this case, the first three bytes of the IPv4 address or the entire IPv6 address are used to calculate the hash value. This method ensures that requests from the same address reach the same server, unless that server is unavailable.

upstream
   ip_hash;
   server www.panchengming.com;
   server www.panchengming2.com;
}

4.Generic Hash:

The server to which the request is sent is determined by a user-defined key, which can be a text string, a variable, or a combination.

	upstream
	  hash $request_uri consistent;
	  server www.panchengming.com;
    server www.panchengming2.com;
	}

5. Least Time (NGINX Plus only)

For each request, NGINX Plus selects the server with the lowest average latency and the lowest number of active connections, where the lowest average latency is calculated based on the following parameters including the least_time directive:

• header: The time when the first byte was received from the server.
• last_byte: The time when the complete response was received from the server.
• last_byte inflight: The time when the complete response was received from the server.

upstream
least_time header;
server www.panchengming.com;
server www.panchengming2.com;
}

6. Random:

Each request will be passed to a randomly selected server. If both parameters are specified, NGINX first randomly selects two servers based on their server weights and then selects one of them using the specified method.

• least_conn : Minimum number of active connections
• least_time=header (NGINX Plus): The shortest average time to receive the response header from the server ($upstream_header_time).
• least_time=last_byte (NGINX Plus) : The minimum average time to receive a complete response from the server ($upstream_response_time).

upstream
random two least_time=last_byte;
server www.panchengming.com;
server www.panchengming2.com;
}

Nginx+SpringBoot to achieve load balancing

Environment Preparation

• Depends on JDK 1.8 or later;
  
• Depends on the Nginx environment;
  

The project here uses a previous springboot project of mine. The project address of SpringBoot is: https://github.com/xuwujing/springBoot-study/tree/master/springboot-thymeleaf

First, we download the project and enter: mvn clean package to package the project into a jar file. Then put application.properties and this jar project in a folder, and then copy the folder (here it is copied for clarity, but you can actually restart it without changing the port), and modify the port of the copied folder application.properties , for example, to 8086.

Nginx Configuration

We find the nginx configuration file nginx.conf, which is in the nginx/conf/nginx.conf directory, and then we modify the configuration and add the following configuration:

upstream pancm{
  server 127.0.0.1:8085;
  server 127.0.0.1:8086;
}

• upstream pancm: define a name, any name is fine;
• server + ip:port or domain name;
  

If you don't want to use the Round Robin strategy, you can switch to another one.

Then add/modify the following configuration on the server:

 server {
    listen 80;
    server_name 127.0.0.1;


    location / {
      root html;
      proxy_pass http://pancm;
      proxy_connect_timeout 3s;
      proxy_read_timeout 5s;
      proxy_send_timeout 3s;	
      index index.html index.htm;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
      root html;
    }
  }

Configuration instructions:

• Server: the name of the virtual host. Multiple servers can be configured in one http.
• listen: Nginx default port;
• server_name: The address of the Nginx service. You can use the domain name. Multiple names are separated by spaces.
• proxy_pass: proxy path, generally the name after upstream is configured to achieve load balancing, you can directly configure the IP for jump;
  

nginx.conf complete configuration:

events {
  worker_connections 1024;
}

error_log nginx-error.log info;
http {
  include mime.types;
  default_type application/octet-stream;
  sendfile on;
  keepalive_timeout 65;

   upstream pancm{
    server 127.0.0.1:8085;
    server 127.0.0.1:8086;
  }
  
  server {
    listen 80;
    server_name 127.0.0.1;


    location / {
      root html;
      proxy_pass http://pancm;
      proxy_connect_timeout 3s;
      proxy_read_timeout 5s;
      proxy_send_timeout 3s;	
      index index.html index.htm;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
      root html;
    }
  }
}

Load balancing test

After completing the Nginx configuration, we start Nginx.
In Linux, enter /usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf . If it has been started, you can use the /usr/local/nginx/sbin/nginx -s reload command to hot reload the configuration file. In Windows, directly click nginx.exe in the Nginx directory or run start nginx cmd to start it. If it has been started, you can still use nginx -s reload to hot reload.

After Nginx is started, we start the springboot just downloaded and the project with the changed port copied in turn, and enter: java -jar springboot-jsp-thymeleaf.jar to start.

After everything is started successfully, we can access it by entering the service IP in the browser.

Example image:

Note: Here I use Windows system for testing, and the actual Linux system is the same.

Then we do it and check the console log!

From the above example diagram, we made 4 interface refresh requests, which were eventually evenly distributed to two services. From the above test results, we achieved load balancing.

Here I'm talking about the precautions for using Nginx. When learning and testing, there is generally no problem using the default port of nginx to achieve load balancing. However, when we use it in a project, especially when there is a login interface and the port is not 80, the login interface cannot be redirected. When debugging, an error such as net::ERR_NAME_NOT_RESOLVED will appear. The reason for this is that the default port of nginx is 80, and the default jump is also this. Therefore, when this happens, you need to add the proxy_set_header Host $host:port configuration under location, and the port and listen port must be consistent.

The above is the details of the example of Nginx+SpringBoot to achieve load balancing. For more information about Nginx to achieve load balancing, please pay attention to other related articles on 123WORDPRESS.COM!