CN104902001B - Web request load-balancing method based on operating system virtualization - Google Patents

Abstract

The invention discloses a kind of Web request load-balancing method based on operating system virtualization.The present invention carries out server resource information and normalization first；Secondly server and Service Instance Dynamic Information Gathering；Then the multidate information arrived according to server resource information and periodic harvest calculates the final weights of the Service Instance copy of all services；Distribute finally by WRR and ask.The present invention is it is possible to prevente effectively from different Service Instance copies on same server, the phenomenon of server overload where a large amount of Web requests cause is received simultaneously because place server load is relatively low, realize the load balancing between Service Instance copy and server, the concurrent capability of Web group systems is improved, reduces the average response time of request.

Description

Web request load balancing method based on operating system virtualization

technical field

The invention belongs to the technical field of Web cluster load balancing, and in particular relates to a method for balancing Web request loads based on operating system virtualization.

Background technique

With the rapid development of Internet applications such as social networks and e-commerce, network servers are faced with the following two problems: (1) the number of visits increases exponentially; (2) transaction processing becomes more complicated. In order to deal with the above problems and provide users with a high-performance network service environment, a distributed Web server system (Web cluster) emerges as the times require, and is used to replace a single Web server with high performance. In a web cluster, each type of service contains multiple service instance copies, and multiple service instance copies of the same service are hosted by multiple different servers. In order to distribute user requests to different service instance copies in a reasonable and balanced manner, ensure load balance between servers and service instance copies, and improve the concurrency capability of the Web cluster system and the utilization of system resources, an efficient load balancing strategy is a problem the key to.

Traditional web clusters host copies of service instances in units of physical machines or virtual machines, and reasonably distribute user requests to physical machines or virtual machines that host copies of different service instances according to load balancing policies. However, with the development of cloud computing technology, the Docker container based on operating system virtualization has emerged as a new basic unit for carrying service instances. Because Docker uses the virtualization technology based on the operating system, compared with the traditional virtual machine based on full virtualization, Docker can realize the resource elastic allocation function of the runtime system (that is, when there is no task execution in the Docker container, Docker The container does not occupy CPU resources; when a task is executed, the Docker container occupies the required CPU resources according to its CPU weight), which improves the utilization of server resources. This new feature of Docker makes the load balancing strategy on the traditional Web cluster no longer applicable. Therefore, it is necessary to build a reasonable and balanced method of Web request load balancing based on operating system virtualization.

Contents of the invention

Aiming at the deficiencies of the prior art, the present invention provides a web request load balancing method based on operating system virtualization.

The concrete steps of the inventive method are:

Step (1) Establish a server resource status information list. The server set S in the Web cluster is expressed as:

S＝{s ₁ ,s ₂ ,s ₃ ,...,s _j ,...,s _n }

Among them, s _j (1≤j≤n) represents a certain server in the Web cluster, and n represents the total number of servers contained in the Web cluster. The total resource P _j of server s _j is expressed as:

P _j ＝(P _{j_cpu} ,P _{j_memory} ,P _{j_io} ,P _{j_network} )

Among them, P _{j_cpu} represents the computing power of the CPU of server s _j , P _{j_memory} represents the memory processing capacity of server s _j , P _{j_io} represents the hard disk I/O capacity of server s _j , and P _{j_network} represents the network throughput of server s _j . In order to eliminate the impact of server heterogeneity and the difference of different types of resources, the Max-Min method is used to normalize the total resource P _j value of server s _j , and the total resource normalized value PO of server s _{j j} is expressed as:

PO _j ＝(PO _{j_cpu} ,P _{Oj_memory} ,P _{Oj_io} ,P _{Oj_network} )

Step (2) Establish a list of service instance resource state information. Let the service set F provided by the Web cluster be expressed as:

F＝{f ₁ ,f ₂ ,f ₃ ,...,f _i ,...f _m }

Among them, f _i (1≤i≤m) represents the i-th service provided by the cluster, and m represents the total number of service types provided by the cluster. The service f _i contains multiple different service instance replica sets F _i expressed as:

F _i ＝{f _i1 ,f _i2 ,f _i3 ,…,f _ik ,…,f _il }

Among them, f _ik (1≤k≤l) represents the instance copy of service f _i , and l represents the number of instance copies of service f _i . The resource state information ST _ik of the service instance f _ik is expressed as:

in Indicates the host s _j where the instance copy f _ik of the service _{f i} is located, cpu_share _ik indicates the CPU weight of the instance copy f _ik of the service f _i , and memory _{ik_t o tal} indicates the maximum occupancy of the instance copy f _ik of the service f _i Memory.

Step (3) Every cycle time T, the load balancing server periodically collects load information of all servers in the Web cluster within the cycle time T. Key payload information includes:

CPU utilization of server s _j :

CPU _j = CPU busy time/(CPU busy time + CPU idle time)

Hard disk I/O load of server s _j :

IO _j = hard disk IO busy time / (hard disk IO busy time + hard disk IO idle time)

Network load of server s _j :

Network _j = (incoming traffic in period T + output traffic in period T)/(period T*P _{j_network} )

The sum of CPU weights of all instance replicas on server s _j :

The memory utilization of instance copy f _ik of service f _i on server s _j :

Where memory _{ik_used} represents the memory value used by the instance copy f _ik of the service f _i ;

Step (4) The load balancing server calculates the final weight of the service instance f _ik deployed on the server s _j according to the collected server load information and the status information of the existing servers and service instances And update the weight information of the corresponding service instance in the weight list.

Among them, α _ik , β _ik , γ _ik , and δ _ik respectively represent the different weights given by service f _i to the four types of resources of CPU, memory, hard disk and network, and the weights given by different service instances of the same service to these four types of resources same value. According to the weight of each service instance, the load balancing server uses the weighted round-robin algorithm widely used in the industry to distribute the web requests of the corresponding services.

The web request load balancing method based on operating system virtualization provided by the present invention is composed of a group of functional modules, including: a static information collection module, a dynamic information collection module, a weight calculation module and a load distribution module.

The static information collection module collects static information of servers and service instances when the load balancing method is initialized. The static information of the server mainly includes: the total CPU computing capability P _{j_cpu} of each server in the Web cluster, the memory processing capability P _{j_memory} , the hard disk I/O capability P _{j_io} , and the network throughput capability P _{j_network} . The static information of the service instance mainly includes: the host of the service instance f _ik of the service f _i The CPU weight cpu_share _ik of the service instance _{f ik of} the service f _i , the maximum memory _{ik_total} that can be occupied by the service instance f _ik of the service f i. When the server or service in the Web cluster changes dynamically, the static information of the corresponding server or service needs to be updated in the static information template.

The dynamic information collection module mainly collects the dynamic state information of servers and service instances. Every cycle time T, the dynamic information collection module will collect the dynamically changing state information of the server and the service instance. In order to prevent network load caused by too frequent information collection, the value of cycle time T is set to 5-10 seconds based on statistical experience. In addition, when a service instance is added or deleted, the dynamic information collection module will also perform a collection action. The collected state information mainly includes the CPU utilization CPU _j of the server s _j (1≤j≤n) within the cycle time T, the I/O load IO _j of the hard disk, the network load Network _j , and all service instance copies on the server s _j The sum of the CPU weights Memory utilization of instance copy f _ik of service f _i on server s _j

The weight calculation module calculates the final weight of each service instance according to the collected information of servers and service instances.

According to the weight of the service instance obtained by the weight calculation module, the load distribution module adopts the weighted round-robin scheduling algorithm to distribute more Web requests to service instances with larger weights, and distribute fewer service requests to those with smaller weights. Service instances to achieve load balancing among different service instances of the same service.

The method proposed in the present invention utilizes the characteristics that the Docker container based on the virtualization of the operating system can realize the elastic allocation of system resources at runtime, that is, the computing resources are allocated in proportion to the Docker container carrying the corresponding service instance according to the CPU weight of the service instance, so as to realize different Service instance replicas and load balancing between servers. This method further introduces the CPU weight of the service instance into the calculation formula of the service instance weight, thus avoiding the vicious competition between the Docker containers carrying different service instances on the same server for the remaining computing resources of the server and causing the server to be overloaded . Compared with the traditional method, the method of the present invention can effectively avoid different service instance copies on the same server, and the phenomenon that the server is overloaded due to the low load of the server receiving a large number of Web requests at the same time can realize the service instance copy and server-to-server communication. Load balancing, improve the concurrent capability of the Web cluster system, and reduce the average response time of requests.

Description of drawings

Figure 1 is an example diagram of the relationship among servers, services, and service instance replicas in the cluster;

Figure 2 is a flowchart of dynamic information collection.

Detailed ways

The specific implementation of the Web request load balancing method based on operating system virtualization provided by the present invention is mainly divided into four steps:

(1) Server resource information collection and normalization; (2) Server and service instance dynamic information collection (3) Calculate the final weight of service instance copies of all services based on server resource information and periodically collected dynamic information; ( 4) Distribute requests by weighted round robin.

(1) Collection and normalization of server resource information

The static information collection module collects four resource information including CPU computing capability P _{j_cpu} , memory processing capability P _{j_memory} , hard disk I/0 capability P _{j_io} , and network throughput capability P _{j_network} of each server in the Web cluster. And calculate their maximum and minimum values respectively as follows:

P _{max_cpu} ＝max(P _{1_cpu} ,P _{2_cpu} ,…,P _{j_cpu} ,…,P _{n_cpu} )

P _{min_cpu} ＝min(P _{1_cpu} ,P _{2_cpu} ,…,P _{j_cpu} ,…,P _{n_cpu} )

P _{max_memory} ＝max(P _{1_memory} ,P _{2_memory} ,…,P _{j_memory} ,…,P _{n_memory} )

P _{min_memory} ＝min(P _{1_memory} ,P _{2_memory} ,…,P _{j_memory} ,…,P _{n_memory} )

P _{max_io} ＝max(P _{1_io} ,P _{2_io} ,…,P _{j_io} ,…,P _{n_io} )

P _{min_io} ＝min(P _{1_io} ,P _{2_io} ,…,P _{j_io} ,…,P _{n_io} )

P _{max_network} ＝max(P _{1_network} ,P _{2_network} ,…,P _{j_network} ,…,P _{n_network} )

P _{min_network} ＝min(P _{1_network} ,P _{2_network} ,…,P _{j_network} ,…,P _{n_network} )

In order to eliminate the impact of server heterogeneity and the difference of different types of resources, the Max-Min method is used to evaluate the server CPU computing power P _{j_cpu} , memory processing power P _{j_memory} , hard disk I/0 capacity P _{j_io} , and network throughput P The four resource information _{of j_network} are normalized, and PO _{j_cpu} , PO _{j_memory} , PO _{j_io} , PO _{j_network} are respectively used to represent the corresponding values after normalization.

Normalized value of CPU computing capability PO _j _ _cpu :

PO _{j_cpu} = (P _{j_cpu} -P _{min_cpu} )/(P _{max_cpu} -P _{min_cpu} )

Normalized value of memory processing capability P _{j_memory} :

PO _{j_memory} = (P _{j_memory} -P _{min_memory} )/(P _{max_memory} -P _{min_memory} )

Hard disk I/O capability normalized value PO _j _ _i o:

PO _{j_io} = (P _{j_io} -P _{min_ix} )/(P _{max_io} -P _{min_io} )

Normalized value of network throughput P _{j_network} :

PO _{j_network} = (P _{j_network} -P _{min_network} )/(P _{max_network} -P _{min_network} )

(2) Server and service instance dynamic information collection

The relationship among servers, services and service instance replicas in the Web cluster is shown in Figure 1. In Figure 1, the three physical machines s ₁ , s ₂ , and s ₃ in the Web cluster are running 8 service instance copies of the three services f ₁ , f ₂ , and f ₃ (f ₁₁ , f ₁₂ , f ₂₁ , f ₂₂ , f ₂₃ , f ₃₁ , f ₃₂ , f ₃₃ ). Every cycle time T, the dynamic information collection module performs dynamic information collection on the three servers and eight service instance copies of the three services in Figure 1 according to the dynamic information collection process shown in Figure 2, and then recalculates through the weight calculation module The weight of service instance replicas for all services. In addition, when a service instance is added or deleted, the dynamic information collection module will also perform a collection action and recalculate the weight of the service instance copy.

The information collected by the dynamic information collection module mainly includes: the CPU utilization CPU _j of the server s _j (1≤j≤n) within the cycle time T, the I/O load IO _j of the hard disk, the network load Network _j , _and the The sum of the CPU weights of all service instance replicas Memory utilization of instance copy f _ik of service f _i on server s _j

(3) Service instance replica weight calculation

According to the normalized value of server resources calculated in step (1) and the dynamic information of servers and service instances collected in step (2), calculate the final weight of service instance f _ik deployed on server s _j

(4) Distribute requests through weighted round robin

According to the service instance weight obtained in step (3) and after the weight result is updated, the load distribution module uses the weighted round-robin scheduling algorithm to evenly distribute the web requests of the same service to different service instance copies of the service, so as to realize different Instance replication and load balancing between servers.

Claims (1)

1. the Web request load-balancing method based on operating system virtualization, it is characterised in that this method comprises the following steps：

Step (1) establishes server resource state information list；Server set S is expressed as in Web clusters：

S={ s₁,s₂,s₃,…,s_j,…,s_n}

Wherein s_jThe a certain server in Web clusters is represented, 1≤j≤n, n represent the server sum that Web clusters include；Service Device s_jTotal resource P_jIt is expressed as：

P_j=(P_{j_cpu},P_{j_memory},P_{j_io},P_{j_network})

Wherein P_{j_cpu}Represent server s_jCPU computing capability, P_{j_memory}Represent server s_jInternal memory disposal ability, P_{j_io} Represent server s_jHard disk I/O abilities, P_{j_network}Represent server s_jNetwork throughput；Using Max-Min methods to clothes Be engaged in device s_jTotal resource P_jValue is normalized, server s_jTotal resource normalized value PO_jIt is expressed as：

PO_j=(PO_{j_cpu},PO_{j_memory},PO_{j_io},PO_{j_network})

Wherein PO_{j_cpu}Represent P_{j_cpu}Normalized value, PO_{j_memory}Represent P_{j_memory}Normalized value, PO_{j_io}Represent P_{j_io}Return One change value, PO_{j_network}Represent P_{j_network}Normalized value；

Step (2) establishes Service Instance resource state information list；If the set of service F that Web clusters externally provide is expressed as:

F={ f₁,f₂,f₃,…,f_i,…,f_m}

Wherein f_iI-th kind of service that cluster externally provides is represented, 1≤i≤m, m represent the type service sum that cluster provides；Service f_iInclude multiple different Service Instance copy set F_iIt is expressed as：

F_i={ f_i1,f_i2,f_i3,…,f_ik,…,f_il}

Wherein f_ikRepresent service f_iExample copy, 1≤k≤l, l represent service f_iExample copy number；Service Instance f_ik's Resource state information ST_ikIt is expressed as：

<mrow> <msub> <mi>ST</mi> <mrow> <mi>i</mi> <mi>k</mi> </mrow> </msub> <mo>=</mo> <mrow> <mo>(</mo> <msubsup> <mi>L</mi> <mrow> <mi>i</mi> <mi>k</mi> </mrow> <mi>j</mi> </msubsup> <mo>,</mo> <mi>c</mi> <mi>p</mi> <mi>u</mi> <mo>_</mo> <msub> <mi>share</mi> <mrow> <mi>i</mi> <mi>k</mi> </mrow> </msub> <mo>,</mo> <msub> <mi>memory</mi> <mrow> <mi>i</mi> <mi>k</mi> <mo>_</mo> <mi>t</mi> <mi>o</mi> <mi>t</mi> <mi>a</mi> <mi>l</mi> </mrow> </msub> <mo>)</mo> </mrow> </mrow>

WhereinRepresent service f_iExample copy f_ikThe main frame s at place_j, cpu_share_ikRepresent service f_iExample copy f_ik CPU weights, memory_{ik_total}Represent service f_iExample copy f_ikMaximum can committed memory；

Step (3) is every Servers-all in cycle time T, load-balanced server meeting periodic collection Web clusters in the cycle Load information in time T；Basic load information includes：

Server s_jCpu busy percentage CPU_j：

CPU_j=cpu busy time/(the cpu busy time+cpu idle time)

Server s_jHard disk I/O load IO_j：

IO_j=hard disk IO the rush hours/(the hard disk IO rush hours+hard disk IO free times)

Server s_jNetwork load Network_j：

Network_j=(output flow in flow+cycle T is flowed into cycle T)/(cycle T * P_{j_network})

Server s_jUpper all example copy CPU weights number sums：

Server s_jUpper service f_iExample copy f_ikMemory usage

<mrow> <msubsup> <mi>Memory</mi> <mrow> <mi>i</mi> <mi>k</mi> </mrow> <mi>j</mi> </msubsup> <mo>=</mo> <msub> <mi>memory</mi> <mrow> <mi>i</mi> <mi>k</mi> <mo>_</mo> <mi>u</mi> <mi>s</mi> <mi>e</mi> <mi>d</mi> </mrow> </msub> <mo>/</mo> <msub> <mi>memory</mi> <mrow> <mi>i</mi> <mi>k</mi> <mo>_</mo> <mi>t</mi> <mi>o</mi> <mi>t</mi> <mi>a</mi> <mi>l</mi> </mrow> </msub> </mrow>

Wherein memory_{ik_used}Represent service f_iExample copy f_ikThe memory value used；

Step (4) load-balanced servers are according to the server load information and existing service device of collection and Service Instance shape State information, calculating are deployed in server s_jOn Service Instance f_ikFinal weightsAnd update corresponding in weights list The value information of Service Instance：

Wherein α_ik、β_ik、γ_ik、δ_ikService f is represented respectively_iCPU, internal memory, hard disk and the class resource of network four are assigned not Same weights, and the weights that the different Service Instances of same service are assigned to this four classes resource are identical,Expression is deployed in Server s_jOn service f_iExample f_ikCPU weights；Load-balanced server is according to the weights size of each Service Instance Using the Web request of Weighted Round Robin distribution respective service.