CN112965797B - Combined priority scheduling method for complex tasks under Kubernetes environment - Google Patents

Abstract

The combined priority scheduling method for complex tasks in the Kubernetes environment of the present invention is specifically implemented through the following steps: a). Calculate the actual parallelism of each group of tasks; b). Obtain the criticality of the task; c). Obtain the user priority; d). Obtain the dynamic priority of the user; e). Calculate the urgency of the task; f). Normalize the parallelism and urgency; g). Find the priority value; h). Pod sorting and scheduling. The combined priority scheduling method of the present invention, because the task parallelism is considered when setting the priority, can avoid the problem of task execution failure caused by other tasks occupying node resources in advance and the parallel tasks cannot obtain resources. Secondly, the urgency of the task is considered when setting the priority, which can ensure that the urgent task preempts the resources occupied by the non-emergency task when the node resources are insufficient, so that the urgent task can be successfully executed.

Description

A Combined Priority Scheduling Method for Complex Tasks in Kubernetes Environment

technical field

The invention relates to a combined priority scheduling method, more specifically, to a combined priority scheduling method for complex tasks in a Kubernetes environment.

Background technique

As the technology with the most development potential in the new era, artificial intelligence has been used and developed in many fields. At present, not all artificial intelligence computing is carried out on the cloud platform in the strict sense, but cloud computing is still the basic computing platform of artificial intelligence. A convenient way to integrate the capabilities of artificial intelligence into thousands of applications. Cloud computing is a service related to information technology, software, and the Internet. It provides dynamic and easily scalable resources through the Internet. Usually, these resources are virtualized resources. Cloud refers to this computing resource sharing pool. Artificial intelligence not only enriches the characteristics of cloud computing services, but also makes cloud computing services more in line with the needs of business scenarios, and further liberates manpower. Among them, machine learning, as a method to realize artificial intelligence, is the focus of artificial intelligence technology. For large-scale data and computing tasks, machine learning usually requires thousands of iterative calculations, so the demand for cloud computing resources is very large, and the time cost of training and optimizing models is also relatively high. In order to quickly complete machine learning tasks within limited resources, it is necessary to reasonably and effectively schedule and allocate cloud computing resources.

Kubernetes is a very popular open source container cluster management platform in the field of cloud computing, with very complete cluster management capabilities. A pod is the smallest unit that can be created and deployed in Kubernetes and contains one or more containers. Tasks will be mapped to one or more pods in Kubernetes. Since tasks have a sequence that needs to be prioritized, pods also need to be prioritized. Kubernetes divides pods into three QoS (Quality of Service) levels: Guaranteed: the highest priority; Best Effort: the lowest priority; Burstable: the priority is between the first two. In addition to QoS levels, Kubernetes also allows users to customize the priority of pods. A priority definition needs to be submitted in Kubernetes, and the attribute value is assigned a value in the definition. Once the priority is defined, the pod can declare its use.

In the default priority definition of Kubernetes, value needs to be assigned by the user. When faced with more complex tasks, various influencing factors need to be considered, and how to give it an appropriate priority becomes the key.

SUMMARY OF THE INVENTION

In order to overcome the shortcomings of the above technical problems, the present invention provides a combined priority scheduling method for complex tasks in a Kubernetes environment.

其特征在于，Kubernetes环境下面向复杂任务的组合优先级调度方法具体通过以下步骤来实现：The present invention provides a combined priority scheduling method for complex tasks under the Kubernetes environment. It is assumed that the tasks that need to be scheduled through the Kubernetes resource management platform are task1, task2, ..., taskn, a total of n tasks; these n tasks are further divided into q group, 1≤q≤n, suppose the _i -th group contains hi tasks, i≤q, hi ≤n, that is, the parallelism of the _i -th group of tasks is _hi , and the hi-tasks in the _i -th group are respectively recorded as task _i1 , task _i2 , …,

It is characterized in that the combined priority scheduling method for complex tasks in the Kubernetes environment is specifically implemented through the following steps:

a). Calculate the actual parallelism of each group of tasks; set the number of worker nodes contained in hardware resources to be m, and the number of CPU cores used for task calculation on each worker node to be c, then the hardware resources support m×c The maximum task concurrency is m×c; for each group of task parallelism hi and the maximum task concurrency supported by hardware resources, the minimum value should be prioritized. Therefore, the actual parallelism P _i of the _i -th group of tasks is determined by formula (1) To ask for:

P _i =min( _hi ,m×c) (1)

Until the actual parallelism of all task groups is obtained;

利用选择函数(2)求取第i组内第j个任务task_ij的任务关键程度k_ij：b). Obtain the criticality of the task; assign a high criticality factor H to the critical tasks in all tasks task1, task2, ..., taskn, and assign a low criticality factor W to the rest of the tasks, H>W; for the hi tasks in the _i -th group task _i1 , task _i2 , …,

Use the selection function (2) to obtain the task criticality k _ij of the j-th task task _ij in the i-th group:

k _ij =choice(H,W) (2)

Among them, i≤q, _j≤hi , H∈N ^* , W∈N ^* ;

则其分配的用户优先级依次为Pr_i1、Pr_i2、…、

利用公式(3)获取第i组内第j个任务task_ij的用户优先级：c). Obtain user priority; assign user priority U to all tasks, and set the hi tasks in the _i -th group to be task _i1 , task _i2 , ...,

Then its assigned user priorities are Pr _i1 , Pr _i2 , ...,

Use formula (3) to obtain the user priority of the jth task task _ij in the ith group:

U _ij =Pr _ij (3)

Among them, _{i≤q, j≤hi, Pr ij ∈N} ^* ;

利用公式(4)求取第i组内第j个任务task_ij的动态优先级D_ij：d). Obtain the dynamic priority of the user; the dynamic priority D of the user is determined by the idle time L of the task, and the smaller the idle time is, the higher the dynamic _priority of the _task ; _i2 , …,

Use formula (4) to find the dynamic priority D _ij of the j-th task task _ij in the i-th group:

为向上取整函数，L_ij第i组内第j个任务task_ij的空闲时间，L_ij的取值范围为：1≤L_ij≤50；in,

In order to round up the function, L _ij is the idle time of the j-th task task _ij in the i-th group, and the value range of L _ij is: 1≤L _ij ≤50;

e). Calculate the task urgency, and calculate the task urgency J _ij of the j-th task task _ij in the i-th group according to formula (5):

J _ij =k _ij +U _ij +D _ij (5)

f). Normalization of parallelism and urgency; set the value range of task parallelism to be [P _min , P _max ], and the value range of urgency to be [J _min , J _max ], and the i-th group of tasks The actual parallelism P _i of is normalized by formula (6):

P _i-normal =(P _i -P _min )/(P _max -P _min ) (6)

The urgency degree J _ij of the j-th task task _ij in the i-th group is normalized by formula (7):

J _ij-normal =(J _ij -J _min )/(J _max -J _min ) (7)

g). Find the priority value; a task can be mapped to a single pod or multiple pods, multiple pods are pod groups, each pod in the group executes a subtask, and the priority of the task is mapped to a single pod or a pod in Kubernetes. For the priority of the pod group, the priority value is appropriately expanded, and formula (8) is used to obtain the priority V _ij corresponding to the jth task task _ij in the ith group:

V _ij =k′×(P _i-normal +J _ij-normal ) (8)

Among them, k' is the expansion multiple, P _i-normal is the actual parallelism of the i-th group of tasks after normalization, J _ij-normal is the normalized processing of the j-th task task _ij in the i-th group emergency level;

h). Pod sorting and scheduling; the single pod or pod group corresponding to the j-th task task _ij in the i-th group is sorted according to the priority V _ij of its corresponding task, the higher priority ranks first and the lower priority A single pod or group of pods in the front is scheduled first.

The combined priority scheduling method for complex tasks in the Kubernetes environment of the present invention, in step h), for the pod group, each pod in the pod group corresponds to a subtask, and its priority setting is achieved through the following steps:

h-1). First, establish a directed acyclic graph between pods in the group according to the subtask dependencies;

h-2). In a directed acyclic graph, starting from any vertex with in-degree 0, randomly find a vertex with out-degree 0 along the directed edge, and put the pod corresponding to the vertex with out-degree 0. into the stack; execute step h-3);

h-3). Return to the upper-level vertex. If the out-degree of the upper-level vertex is 0 except for the vertices that have been put in the stack, the pod corresponding to this vertex is put into the stack; If the out-degree outside the vertices in the stack is not 0, then look for the next point with out-degree 0 along the directed edge that does not contain the vertices that have been put in the stack, and put the pod corresponding to the vertex with out-degree 0 into the stack , and repeat this step until the pods corresponding to all the vertices of the directed acyclic graph are put into the stack;

h-4). After all vertices enter the stack, perform the pop-out operation. Due to the principle of first-in, last-out, the priority of the pods pushed later is higher than the priority of the pods pushed into the stack first, and each pod in the pod group is obtained. priority sequence.

The combined priority scheduling method for complex tasks in the Kubernetes environment of the present invention, in step h), if there are two tasks with equal priority values, then they are sorted according to the following rules:

h-1-1). Sort by key coefficient. For two tasks with equal priority values, compare their key coefficients first. If the key coefficients are different, assign the task with the higher key coefficient to a single pod or pod group. Rank in the front, and rank the single pod or pod group corresponding to the task with the low key factor in the back; if the key factor is equal, perform step h-1-2);

h-1-2). Sort by user priority. For two tasks with equal priority values and key coefficients, compare their user priorities. If the user priorities are different, assign the higher user priority to the task. The single pod or pod group corresponding to the task is ranked first, and the single pod or pod group corresponding to the task with the lower user priority is ranked last; if the user priority is equal, perform step h-1-3);

h-1-3). Sort by dynamic priority. For two tasks with equal priority value, key coefficient and user priority, compare their dynamic priorities. If the dynamic priorities are different, the dynamic The single pod or pod group corresponding to the task with high priority is ranked first, and the single pod or pod group corresponding to the task with dynamic priority is ranked last; if the dynamic priority is equal, the two tasks are sorted randomly one after the other.

In the combined priority scheduling method for complex tasks in the Kubernetes environment of the present invention, the expansion multiple k' described in step g) is 1,000,000.

The beneficial effects of the present invention are: the combined priority scheduling method for complex tasks in the Kubernetes environment of the present invention, when facing complex tasks such as machine learning, because the task parallelism is considered when setting the priority, other tasks can be avoided in advance. The problem of task execution failure caused by the occupation of node resources and the inability of parallel tasks to obtain resources. Secondly, the urgency of the task is considered when setting the priority, which can ensure that the urgent task preempts the resources occupied by the non-emergency task when the node resources are insufficient, so that the urgent task can be successfully executed. Taking the above two points into consideration, the priority setting method can effectively improve the success rate of task execution when scheduling node resources for complex tasks. In addition, in the group scheduling for machine learning tasks, another level of priority setting method solves the problem of dependencies between pods in the group.

Description of drawings

Fig. 1 is the task scheduling mapping process diagram in Kubernetes in the present invention;

Fig. 2 is the overall structure diagram of task in the present invention;

Fig. 3 is the task parallel diagram in the present invention, A group task includes task1 to task3, B group task includes task4 to task8;

FIG. 4 is a directed acyclic graph of dependencies within a pod group in the present invention.

Detailed ways

The present invention will be further described below with reference to the accompanying drawings and embodiments.

Task parallelism: used to evaluate the number of tasks executed in parallel at a certain time. Whether multiple tasks specified by the user can be executed concurrently depends on the number of worker nodes and the number of CPU cores used for task computation on each worker node. Note that the number of worker nodes currently executing tasks is m, and the number of CPU cores used for task calculation on each worker node is c, then the maximum task concurrency supported by hardware resources is m×c, and the value range is a positive integer. Let the degree of parallelism of the task be h, the degree of parallelism of the task depends on the number of subtasks of each task in the serial task, and the value range is a positive integer. For the task parallelism h and the maximum task concurrency m×c supported by hardware resources, the smaller value should be preferred, and the smaller value is the actual parallelism P of the task.

Task urgency: The task urgency of each task is J, and the task urgency is a combination of a fixed priority F and a dynamic priority D, where the fixed priority F is determined by the task criticality k and user priority U; The dynamic priority D is determined by the task idle time L. The smaller the idle time, the higher the dynamic priority of the task. A high critical coefficient H is assigned to the key task set, and a low critical coefficient W is assigned to the rest of the tasks. The value range of the critical coefficient is a positive integer, and must be H>W. A unique user priority U is assigned to each task in a batch of tasks. The value of U is a positive integer, and the user priority of a group of tasks can be assigned sequentially from 1.

As shown in Figure 1, the process diagram of task scheduling and mapping in Kubernetes in the present invention is given. A pod is the smallest unit that can be created and deployed in Kubernetes, including one or more containers, and a task will be mapped into a pod in Kubernetes. or pod groups.

As shown in Fig. 2, the overall structure diagram of tasks in the present invention is given, wherein task1, task2, task3 are a group (referred to as the first group of tasks), and the parallelism is 3; task4, task5, task6, task7, task8 are One group (denoted as the second group of tasks), the degree of parallelism is 5. As shown in Figure 2, there are 3 nodes in total, and each node has 2 cores.

Use formula (1) to find the actual parallelism P ₁ of the first group of tasks:

P ₁ =min(h ₁ , m×c)=min(3, 3×2)=3

In the same way, the actual parallelism degree P ₂ of the second group of tasks can be obtained by using formula (1):

P ₂ =min(h ₂ ,m×c)=min(5,3×2)=5

As shown in Table 1, the three parallel tasks task1, task2, and task3 in the first group have user priorities of 1, 2, and 3, respectively. Let task1 and task3 be the key task set with a high critical factor of 10, and task2 is a non-critical task. The set is configured with a low criticality factor of 5, and the idle time obtained by the system is 6, 3, and 2, respectively. In the second group of five parallel tasks task4, task5, task6, task7, and task8, the user priorities are 1, 2, 3, 4, and 5, respectively. Suppose task4 and task5 are non-critical task sets with low criticality factor 5, and task6, task7, and task8 are critical task sets configured with high criticality factor 10, and the idle time obtained by the system is 4, 5, 3, 2, and 2, respectively.

Table 1

User priority U key factor k Free time L Dynamic priority D priority V task1 1 H=10 6 17 0.483333×10⁶ task2 2 W=5 3 34 0.766667×10⁶ task3 3 H=10 2 50 1.0×10⁶ task4 1 W=5 4 25 0.85×10⁶ task5 2 W=5 5 20 0.816667×10⁶ task6 3 H=10 3 34 1.116667×10⁶ task7 4 H=10 2 50 1.4×10⁶ task8 5 H=10 2 50 1.416667×10⁶

By formula (4), the dynamic priorities D ₁₁ , D ₁₂ , and D ₁₃ of the three tasks task1, task2, and task3 in the first group can be calculated to be 17, 34, and 50, respectively, and the five tasks task4 in the second group can be calculated. The dynamic priorities D ₂₁ , D ₂₂ , D ₂₃ , D ₂₄ , and D ₂₅ of task5, task6, task7, and task8 are 25, 20, 34, 50, and 50, respectively.

Then, according to formula (5), the task urgency levels J ₁₁ , J ₁₂ , and J ₁₃ of the three tasks task1, task2, and task3 in the first group can be calculated to be 24, 41, and 55, respectively, and 5 in the second group can be calculated. The task urgency levels J ₂₁ , J ₂₂ , J ₂₃ , J ₂₄ , and J ₂₅ of the tasks task4, task5, task6, task7, and task8 are 31, 27, 47, 64, and 65, respectively.

Normalize the degree of parallelism and the degree of urgency, set the value range of the degree of parallelism to be P _max =9 and P _min =1, and the value range of the degree of urgency to be J _min =10 and J _max =70, using the formula ( 6) It can be obtained that the normalized value P _{1-normal of} the parallelism of task1 to task3 is 0.25, and the normalized value of parallelism P2-normal of task4 to task8 is 0.5.

Using formula (7), the urgency normalized values J _11-normal , J _12-normal , and J _13-normal of task1 to task3 can be obtained as 0.233333, 0.516667, and 0.750, respectively, and the urgency normalized values of task4 to task8 J _21-normal , J _22-normal , J _23-normal , J _24-normal , and J _25-normal are 0.350, 0.316667, 0.616667, 0.90, and 0.916667, respectively.

Using formula (8), the priorities V ₁₁ , V ₁₂ , V ₁₃ , V ₂₁ , V ₂₂ , V ₂₃ , V ₂₄ and V ₂₅ of task1 to task8 can be obtained as 0.483333×10 ⁶ , 0.766667×10 ⁶ , and 1.0 respectively ×10 ⁶ , 0.85×10 ⁶ , 0.816667×10 ⁶ , 1.116667×10 ⁶ , 1.4×10 ⁶ , 1.416667×10 ⁶ , the tasks are sorted according to the size of the priority value: task8, task7, task6, task3, task4 , task5, task2, task1.

So far, 8 tasks are mapped to 8 pods on Kubernetes, and the 8 pods will be scheduled to the worker nodes that meet the resource requirements in sequence according to this sequence.

When facing complex tasks such as machine learning tasks, each of the eight tasks above will be mapped to multiple pods, and each pod corresponds to a subtask in the task, that is, a task will be mapped to a task with multiple pods. The pod group for the pod. It is assumed that task8 with the highest priority needs to run 5 pods during execution, that is, pod 8 is a pod group, which consists of 5 pods. As shown in Figure 4, a directed acyclic graph of dependencies within a pod group in the present invention is given.

Next, consider the priority of the 5 pods in the pod 8 group separately. At this point, the 5 pods in the group have dependencies, and some pods will serve as prerequisites for other pods. As shown in Figure 4, the default pod sequence is:

pod1→pod2→pod3→pod4→pod5

Calculate its topological sequence from a directed graph. First, select vertex 1 with an in-degree of 0 as the starting point, and find a vertex with an out-degree of 0 along any directed edge, for example, find vertex 4 along vertices 1, 2, 3, and 4 and put it into the stack; return to the previous vertex 3. It is found that the out-degree of vertex 3 is 0 except for the directed edge pointing to 4, so 3 is put into the stack; the upper-level vertex 2 of vertex 3 is returned, and it is found that the out-degree of vertex 2 is not 0, because vertex 3 It has been put into the stack, so it reaches vertex 5 along the directed edge, and because vertex 4 has been put into the stack, the out-degree of vertex 5 is 0, and vertex 5 is put into the stack; return to the previous vertex 2 again, this When the out-degree of vertex 2 is 0, put it into the vertex 2 stack; return to the previous level of vertex 1, at this time, the out-degree of vertex 1 is 0, and put vertex 1 into the stack. So far, all vertices have been put into the stack in the order of 4, 3, 5, 2, and 1. According to the principle of first-in-last-out of the stack, the order of vertices popped out of the stack is 1, 2, 5, 3, and 4, which is the directed The topological sequence corresponding to the graph. That is, the priority sequence is:

pod1→pod2→pod5→pod3→pod4

Therefore, the pods in the group should be given priority from high to low in this order. First, customize the pod priority as a, b, c, d, and e. In the yaml file of podGroup-status, specify the priority name to be used through pod.spec.PriorityClassName to complete the declaration.

This priority does not participate in the process of setting the parallelism and urgency priority, and is only applicable to the priority sorting when there is a dependency in the pod group after the priority scheduling between the pod groups is completed.

Combining with the specific tasks, it can be seen that since the task parallelism and task urgency are taken into account when setting the priority, the priority setting can be made more detailed and more standardized and reasonable. When there are resource requirements for parallel tasks and urgent tasks It can effectively improve the success rate of task execution. In addition, in the group scheduling for machine learning tasks, another level of priority setting method solves the problem of dependencies between pods in the group.

Claims (4)

1. A combined priority scheduling method for complex tasks in a Kubernetes environment is provided, wherein the tasks needing to be scheduled through a Kubernetes resource management platform are respectively set astask1, task2, … and task n, wherein the total number of the tasks is n; the n tasks are divided into q groups, q is more than or equal to 1 and less than or equal to n, and the ith group is set to contain h_iA task, i is less than or equal to q, h_iN is less than or equal to n, namely the parallelism of the ith group of tasks is h_iH in group i_iEach task is respectively recorded as

The combined priority scheduling method for the complex tasks under the Kubernetes environment is characterized by being specifically realized through the following steps:

a) calculating the actual parallelism of each group of tasks; setting the number of working nodes contained in the hardware resources as m, and the number of CPU cores used for task calculation on each working node as c, wherein the maximum task concurrency amount supported by the hardware resources is mxc; task parallelism h for each group_iThe maximum task concurrency m multiplied by c supported by hardware resources should be the minimum value first, so the actual parallelism P of the ith group of tasks_iThe calculation is carried out by the formula (1):

P_i＝min(h_i,m×c) (1)

until the actual parallelism of all task groups is completely solved;

b) acquiring the key degree of the task; distributing a high key coefficient H to key tasks in all tasks task1, task2, … and task, and distributing a low key coefficient W to the other tasks, wherein H is larger than W; for h within the ith group_iA task

The jth task in the ith group is obtained by using a selection function (2)_ijTask criticality of k_ij：

k_ij＝choice(H,W) (2)

Wherein i is less than or equal to q, j is less than or equal to h_i，H∈N^*、W∈N^*；

c) Acquiring a user priority; assigning user priority U to all tasks, and setting h in ith group_iEach task is

It is assigned a user priority of in turn

Obtaining the jth task in the ith group by using a formula (3)_ijUser priority of (2):

U_ij＝Pr_ij (3)

wherein i is less than or equal to q, j is less than or equal to h_i，Pr_ij∈N^*；

d) Acquiring the dynamic priority of the user; the dynamic priority D of the user is determined by the idle time L of the task, and the task with smaller idle time has higher dynamic priority; for h within the ith group_iA task

Solving the jth task in the ith group by using a formula (4)_ijDynamic priority D of_ij：

Wherein,

as an upward rounding function, L_ijJth task in ith group_ijIdle time of L_ijThe value range is as follows: l is more than or equal to 1_ij≤50；

e) Calculating the task urgency degree, and calculating the jth task in the ith group according to a formula (5)_ijTask urgency degree J_ij：

J_ij＝k_ij+U_ij+D_ij (5)

f) Normalization processing of parallelism and urgency; setting the value range of the task parallelism as [ P ]_min,P_max]The value range of the emergency degree is [ J_min,J_max]Actual parallelism P of the ith group of tasks_iNormalization processing is performed using equation (6):

P_i-normal＝(P_i-P_min)/(P_max-P_min) (6)

jth task in ith group_ijDegree of emergency J_ijNormalization processing is performed using equation (7):

J_ij-normal＝(J_ij-J_min)/(J_max-J_min) (7)

g) seeking a priority value; one task can be mapped into a single pod or a plurality of pods, each pod in the group executes a subtask, the priority of the task is mapped to the priority of the single pod or the pod group in Kubernets, the priority value is expanded by a proper amount, and the jth task in the ith group is solved by using a formula (8)_ijCorresponding priority V_ij：

V_ij＝k′×(P_i-normal+J_ij-normal) (8)

Wherein k' is the magnification factor, P_i-normalTo normalize the actual parallelism of the processed i-th group of tasks, J_ij-normalIs the j task in the ith group after normalization processing_ijThe degree of urgency of (d);

h) pod ordering and scheduling; jth task in ith group_ijThe corresponding single pod or pod group is according to the priority V of the corresponding task_ijThe ordering is performed, with the big priority ranked in front, the small priority ranked behind, and the single pod or pod group ranked in front to schedule first.

2. The Kubernetes environment combined priority scheduling method for complex tasks according to claim 1, wherein in step h), for a pod group, each pod in the pod group corresponds to one subtask, and the priority setting is realized by the following steps:

h-1), firstly, establishing a directed acyclic graph between the pods in the group according to the dependency relationship of the subtasks;

h-2), in the directed acyclic graph, starting from any vertex with the degree of 0, randomly searching a vertex with the degree of 0 along a directed edge, and putting a pod corresponding to the vertex with the degree of 0 into a stack; performing step h-3);

h-3), returning the top-level vertex, and if the out degree of the top-level vertex except the vertex already put in the stack is 0, putting the pod corresponding to the vertex in the stack; if the out-degree of the top point of the previous stage is not 0 except the top point which is already put in the stack, searching a next point with the out-degree of 0 along a directed edge which does not contain the top point which is already put in the stack, putting the pod corresponding to the top point with the out-degree of 0 in the stack, and repeatedly executing the step until all the pods corresponding to the top points of the directed acyclic graph are all put in the stack;

h-4), when all the vertexes enter the stack, executing the stack popping operation, and obtaining the priority sequence of each pod in the pod group, wherein the priority of the pod which is popped later is higher than the priority of the pod which is popped first according to the principle that the stack is popped first and then popped later.

3. The Kubernetes environment combined priority scheduling method for complex tasks according to claim 1 or 2, characterized in that in step h), if there are two tasks with equal priority values, the tasks are ordered according to the following rules:

h-1-1), sorting according to key coefficients, for two tasks with equal priority values, firstly comparing the key coefficients, and if the key coefficients are different, arranging a single pod or pod group corresponding to the task with a high key coefficient in front of the two tasks and arranging a single pod or pod group corresponding to the task with a low key coefficient in back of the two tasks; if the key coefficients are equal, executing the step h-1-2);

h-1-2), ordering according to user priorities, comparing the user priorities of two tasks with equal priority values and key coefficients, and if the user priorities are different, arranging a single pod or pod group corresponding to the task with high user priority in front of the two tasks and arranging a single pod or pod group corresponding to the task with low user priority behind the two tasks; if the user priorities are equal, executing the step h-1-3);

h-1-3), ordering according to dynamic priority, comparing the dynamic priority of two tasks with equal priority values, key coefficients and user priorities, and if the dynamic priorities are different, arranging a single pod or pod group corresponding to a task with high dynamic priority in front of the two tasks and arranging a single pod or pod group corresponding to a task with dynamic priority behind the two tasks; if the dynamic priorities are equal, the two tasks are randomly ordered in tandem.

4. A combined priority scheduling method to complex tasks under a kubernets environment according to claim 1 or 2, characterized in that: the magnification k' stated in step g) is 1000000.

Images