How to use Linux for network load balancing

Network load balancing is a method of evenly distributing network traffic to different servers, thereby improving the availability and performance of the entire system. The Linux system comes with some tools that can help us achieve network load balancing. This article will introduce how to use Linux for network load balancing.

1. The basic principle of Linux network load balancing

The basic principle of network load balancing is to distribute network traffic to multiple servers. There are many distribution methods, including polling method, weighted polling method, IP hashing method, minimum number of connections method, etc.

In Linux, we can use LVS (Linux Virtual Server) technology for network load balancing. LVS is a technology that distributes network traffic to multiple servers. It consists of a scheduler (also called a load balancer) and multiple backend servers.

2. Install and configure LVS

1. Installing LVS

Before configuring LVS, we need to install the necessary software packages, including ipvsadm, keepalived, these packages can be installed through the yum command.

① Install ipvsadm

Use the following command to install the ipvsadm package:

sudo yum install ipvsadm -y

② Install keepalived

Use the following command to install the keepalived package:

sudo yum install keepalived -y

2. Configure LVS

Before proceeding with LVS configuration, we need to know a few things Basic concept:

• Scheduler (load balancer): used to receive network requests from clients and forward the requests to the back-end server.
• Listening IP address: The IP address accessed by the client.
• Real server (backend server): handles client network requests.

The following is a configuration example of LVS, assuming that our scheduler IP address is 192.168.1.1 and the backend server IP addresses are 192.168.1.2 and 192.168.1.3.

① Configure the scheduler

First, install and configure the keepalived service on the scheduler. Edit the /etc/keepalived/keepalived.conf file and add the following configuration:

! Configuration File for keepalived

global_defs {
router_id LB_Test
}

vrrp_script chk_http_port {
script "/etc/keepalived/check.sh"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 50
priority 101
authentication {

   auth_type PASS
   auth_pass 1111

}
virtual_ipaddress {

   192.168.1.100

}
track_script {

   chk_http_port

}
}

Among them, vrrp_instance is used to set the parameters of the virtual router, virtual_router_id is used to set the ID of the virtual router, virtual_ipaddress is used to set the virtual IP address, and priority is used to set the master-backup relationship. The smaller the number, the higher the priority.

Then, create a script file named check.sh to check whether the backend server is alive. Save the following script content to the check.sh file:

!/bin/bash

A=ipvsadm -ln | grep -c "Server"
if [ $A -eq 0 ];then
echo "failed"
killall keepalived
fi

Description: When the backend server is unavailable, the script will terminate the keepalived service.

Execute the following command to make the configuration file take effect:

sudo systemctl restart keepalived

At this point, the configuration of the scheduler is completed.

② Configure the back-end server

Configure the Real Server of LVS on the back-end server.

Use the following command to add Real Server configuration:

sudo ipvsadm -A -t 192.168.1.100:80 -s rr

Among them, the -A option is used to add rules, -t is used to set the listening IP address and port, -s is used to set the scheduling rules, and the polling method is used here.

Add the Real Server to the rule using the following command:

sudo ipvsadm -a -t 192.168.1.100:80 -r 192.168.1.2 -g
sudo ipvsadm -a -t 192.168 .1.100:80 -r 192.168.1.3 -g

Among them, the -a option is used to add Real Server to the rule, -r is used to set the IP address of the backend server, and -g is used to set the backend server gateway mode.

At this point, the configuration of LVS is completed.

3. Test network load balancing

After completing the configuration of LVS, we can test the network load balancing function through the following steps:

1. Pass on the client The curl command accesses the virtual IP address:

curl 192.168.1.100

2. After processing by the scheduler, the request is sent to one of the back-end servers.
3. Start a simple HTTP service on one of the backend servers:

python -m SimpleHTTPServer 80

4. Then access the IP address of the real server ：

curl 192.168.1.2

5. Send the request to the virtual IP address again. At this time, the request should be sent to another real server.

After the above test, if when accessing the back-end server, the requests can be evenly distributed to different back-end servers, then the network load balancing can be said to be successful.

4. Summary

This article introduces how to use Linux for network load balancing. We install the ipvsadm and keepalived software packages, configure the IP address, port and scheduling rules of the scheduler and back-end server, and finally test the network load balancing function. Network load balancing can improve the availability and performance of the entire system and help handle network requests in high-concurrency environments, thereby improving user experience.

The above is the detailed content of How to use Linux for network load balancing. For more information, please follow other related articles on the PHP Chinese website!