CN114721743A

CN114721743A - Task execution method and device and electronic equipment

Info

Publication number: CN114721743A
Application number: CN202210397497.XA
Authority: CN
Inventors: 陆宇飞; 曹辰; 胡东文; 胡晓龙; 王磊; 张本宇
Original assignee: Alipay Hangzhou Information Technology Co Ltd
Current assignee: Alipay Hangzhou Information Technology Co Ltd
Priority date: 2022-04-15
Filing date: 2022-04-15
Publication date: 2022-07-08
Anticipated expiration: 2042-04-15
Also published as: CN114721743B

Abstract

The embodiment of the specification provides a task execution method, a device and an electronic device, wherein in the task execution method, a target Agent acquires a description file of a first task to be executed, then starts an application process corresponding to the first task according to an application program corresponding to the first task carried in the description file, and finally executes the first task in the application process, so that task (Pod) execution by an Agent (Agent) can be realized, and when executing the task, the target Agent only creates a common process without any authority, and the target Agent can successfully start the first task no matter whether the target Agent runs on a physical machine or in a container environment, so that K8s can adapt to deployment environments of different mechanisms and shield differences on mechanism infrastructure.

Description

Task execution method and device and electronic equipment

[ technical field ] A method for producing a semiconductor device

The embodiment of the specification relates to the technical field of internet, in particular to a task execution method and device and electronic equipment.

[ background of the invention ]

At present, shared intelligence already relates to multiple services, including secure multi-party computing (MPC), multi-party security analysis (SCQL), Federal Learning (FL), and the like, and the common characteristics of these services are that tasks need to be executed at an organization end, how different tasks are quickly distributed to multiple organizations, and how the tasks at the organization end are effectively controlled, which is a difficult problem in engineering implementation. Fortunately, Kubernets (K8s) is widely popular in the cloud native field in recent years and is an ideal basic platform, K8s can automatically deploy, expand and manage containerized applications, and if the application is used in an organization, K8s can well meet various service requirements.

However, for the shared intelligent service, tasks are executed at a plurality of organization ends, and the software and hardware environments of the organizations are various, some are physical machines, and some are virtualized environments, for example: docker et al, and K8s have high environmental requirements and can only be deployed on physical machines, and if an organization cannot provide a physical machine, K8s cannot be deployed.

Therefore, it is desirable to provide a solution that allows K8s to adapt to the deployment environment of different agencies, shielding against differences in the infrastructure of the agencies.

[ summary of the invention ]

The embodiment of the specification provides a task execution method, a task execution device and electronic equipment, so that K8s can be adapted to deployment environments of different organizations, and differences of infrastructure of the organizations are shielded.

In a first aspect, an embodiment of the present specification provides a task execution method, including: acquiring a description file of a first task to be executed; the description file is sent to a target agent by a central node, and the description file carries an execution mechanism label of the first task, an application program corresponding to the first task and a stain tolerance statement; wherein the executive mechanism label is consistent with the mechanism label provided by the target agent when registering, and the content of the stain tolerance statement is consistent with the content of the stain information provided by the target agent when registering; starting an application process corresponding to the application program according to the application program corresponding to the first task; executing the first task in the application process.

In the task execution method, the target Agent obtains the description file of the first task to be executed, then starts the application process corresponding to the application program according to the application program corresponding to the first task carried in the description file, and finally executes the first task in the application process, so that the task (Pod) can be executed by the Agent (Agent), and when the task is executed, the target Agent only creates a common process without any authority, and the target Agent can successfully start the first task no matter the target Agent runs on a physical machine or in a container environment, so that the K8s can be adapted to the deployment environments of different mechanisms, and the difference on the mechanism infrastructure is shielded.

In one possible implementation manner, the starting, according to the application program corresponding to the first task, an application process corresponding to the application program includes: allocating a process group to the first task; starting an application process corresponding to the application program; and adding the application process into the allocated process group.

In one possible implementation manner, after the executing the first task in the application process, the method further includes: acquiring a task deleting instruction, wherein the task deleting instruction carries a second task to be deleted; sending a task termination signal to a process group corresponding to the second task to terminate the application process corresponding to the second task in the process group; notifying the central node that the second task has been deleted.

In one possible implementation manner, before the obtaining the description file of the first task to be executed, the method further includes: sending a node registration request to a central node; wherein the node registration request comprises an organization label of a target agent and taint information of the target agent.

In one possible implementation manner, the method further includes: acquiring a node deletion request; notifying the central node that the target agent cannot be scheduled; deleting the task executed on the target agent; notifying the central node to mark the status of the target agent as unavailable to cause the central node to delete the target agent.

In a second aspect, an embodiment of the present specification provides a task execution method, including: acquiring a description file of a first task to be executed; determining an execution mechanism of the first task according to an execution mechanism label carried in the description file; selecting a target agent suitable for executing the first task from the execution mechanism according to the content of the stain tolerance statement carried in the description file; wherein the content of the stain information provided by the target agent during registration is consistent with the content of the stain tolerance statement carried in the description file; and sending the description file to the target agent, wherein the description file carries the executing mechanism label, the application program corresponding to the first task and the stain tolerance statement, so that the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task and executes the first task in the application process.

In the task execution method, after a description file of a first task to be executed is acquired, an execution mechanism of the first task is determined according to an execution mechanism label carried in the description file, and then a target agent suitable for executing the first task is selected from the execution mechanism according to the content of a stain tolerance statement carried in the description file. Finally, the description file is sent to the target Agent, the description file carries the executing mechanism label, the application program corresponding to the first task and the stain tolerance statement, so that the target Agent starts the application process corresponding to the application program according to the basic information of the first task carried in the description file and starts the application process corresponding to the basic information according to the application program corresponding to the first task, and executes the first task in the application process, thereby realizing the task (Pod) execution by the Agent (Agent), and when executing the task, the target Agent only creates a common process without any authority, no matter whether the target Agent runs on a physical machine or in a container environment, the target Agent can successfully start the first task, thereby enabling the K8s to adapt to the deployment environments of different mechanisms, shielding against differences in infrastructure of the facility.

In a third aspect, an embodiment of the present specification provides a task execution device, provided in a target agent, including: the acquisition module is used for acquiring a description file of a first task to be executed; the description file is sent to a target agent by a central node, and the description file carries an execution mechanism label of the first task, an application program corresponding to the first task and a stain tolerance statement; wherein the executive mechanism label is consistent with the mechanism label provided by the target agent when registering, and the content of the stain tolerance statement is consistent with the content of the stain information provided by the target agent when registering; the starting module is used for starting an application process corresponding to the application program according to the application program corresponding to the first task; an execution module to execute the first task in the application process.

In one possible implementation manner, the starting module is specifically configured to allocate a process group to the first task, start an application process corresponding to the application program, and add the application process to the allocated process group.

In one possible implementation manner, the apparatus further includes: a sending module and a notification module; the acquisition module is further configured to acquire a task deletion instruction after the execution module executes the first task, where the task deletion instruction carries a second task to be deleted; the sending module is configured to send a task termination signal to the process group corresponding to the second task to terminate the application process corresponding to the second task in the process group; the notification module is configured to notify the central node that the second task has been deleted.

In one possible implementation manner, the apparatus further includes: a sending module; the sending module is used for sending a node registration request to the central node before the obtaining module obtains the description file of the first task to be executed; wherein the node registration request comprises an organization label of a target agent and taint information of the target agent.

In one possible implementation manner, the apparatus further includes: a notification module and a deletion module; the acquisition module is further used for acquiring a node deletion request; the notification module is used for notifying the central node that the target agent can not be scheduled; the deleting module is used for deleting the task executed on the target agent; the notifying module is further configured to notify the central node that the status of the target agent is marked as unavailable, so that the central node deletes the target agent.

In a fourth aspect, an embodiment of the present specification provides a task execution device, where the task execution device is disposed on a central node, and the task execution device includes: the acquisition module is used for acquiring a description file of a first task to be executed; the determining module is used for determining the executing mechanism of the first task according to the executing mechanism label carried in the description file; a selection module, configured to select, according to the content of the stain tolerance statement carried in the description file, a target agent suitable for executing the first task from the execution mechanism; wherein the content of the stain information provided by the target agent during registration is consistent with the content of the stain tolerance statement carried in the description file; a sending module, configured to send the description file to the target agent, where the description file carries the execution mechanism tag, the application program corresponding to the first task, and the stain tolerance statement, so that the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task, and executes the first task in the application process.

In a fifth aspect, an embodiment of the present specification provides an electronic device, including: at least one processor; and at least one memory communicatively coupled to the processor, wherein: the memory stores program instructions executable by the processor, the processor calling the program instructions to be able to perform the method provided by the first aspect.

In a sixth aspect, embodiments of the present specification provide a non-transitory computer-readable storage medium storing computer instructions for causing a computer to perform the method provided in the first aspect.

In a seventh aspect, an embodiment of the present specification provides an electronic device, including: at least one processor; and at least one memory communicatively coupled to the processor, wherein: the memory stores program instructions executable by the processor, the processor calling the program instructions to be able to perform the method provided by the second aspect.

In an eighth aspect, embodiments of the present specification provide a non-transitory computer-readable storage medium storing computer instructions that cause the computer to perform the method provided by the second aspect.

It should be understood that the third, fifth, and sixth aspects of the embodiments in this specification are consistent with the technical solution of the first aspect of the embodiments in this specification, and beneficial effects achieved by various aspects and corresponding possible implementation manners are similar and will not be described again;

the fourth, seventh and eighth aspects of the embodiments in this specification are consistent with the technical solution of the second aspect of the embodiments in this specification, and the beneficial effects obtained by each aspect and the corresponding possible implementation are similar, and are not described again.

[ description of the drawings ]

In order to more clearly illustrate the technical solutions of the embodiments of the present specification, the drawings required to be used in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present specification, and it is obvious for those skilled in the art that other drawings can be obtained according to the drawings without creative efforts.

Fig. 1 is an architecture diagram of a K8s cluster provided in the prior art;

FIG. 2 is an architecture diagram of a K8s cluster provided in one embodiment of the present description;

FIG. 3 is a flow diagram of a task execution method provided by one embodiment of the present description;

FIG. 4 is a flowchart of a task execution method provided in another embodiment of the present specification;

FIG. 5 is a flow diagram of a task execution method provided by yet another embodiment of the present description;

FIG. 6 is a flow diagram of a task execution method provided by yet another embodiment of the present description;

FIG. 7 is a flowchart of a task execution method provided by yet another embodiment of the present description;

FIG. 8 is a schematic structural diagram of a task execution device according to an embodiment of the present disclosure;

fig. 9 is a schematic structural diagram of a task execution device according to another embodiment of the present disclosure;

FIG. 10 is a schematic diagram of a task performing device according to still another embodiment of the present disclosure;

fig. 11 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.

[ detailed description ] embodiments

For better understanding of the technical solutions in the present specification, the following detailed description of the embodiments of the present specification is provided with reference to the accompanying drawings.

It should be understood that the described embodiments are only a few embodiments of the present specification, and not all embodiments. All other embodiments obtained by a person skilled in the art based on the embodiments in the present specification without any inventive step are within the scope of the present specification.

The terminology used in the embodiments of the present specification is for the purpose of describing particular embodiments only and is not intended to be limiting of the specification. As used in the specification examples and the appended claims, the singular forms "a", "an", and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise.

For a plurality of services related to shared intelligence, including MPC, SCQL or FL, etc., the related art implements distribution of tasks through K8s cluster, and task execution at the control mechanism end. K8s is short for Kubernetes, K8s is an open-source container arrangement service and is also an automatic container operation and maintenance management platform, multiple hosts are supported to be combined into a cluster to run a containerized application, K8s can automatically create or delete containers, and a plurality of manual operations involved in application deployment, capacity expansion and/or offline are eliminated.

Fig. 1 is an architecture diagram of a K8s cluster provided in the related art. As shown in fig. 1, the K8s cluster is composed of a Master (Master) and a node (Kubelet), the Master is deployed at a central end of the K8s cluster and used for controlling, managing and/or scheduling tasks (Pod), and the Kubelet is deployed at an execution mechanism end and used for receiving an instruction of the Master and executing a related action. Pod is the smallest computing unit in the K8s cluster, and is composed of one or more containers, and services related to shared intelligence are operated in the containers, for example: MPC, FL, SCQL, or the like. At present, shared intelligence already involves multiple services, and in order to distinguish different services, a specific service type can be abstracted into an Application (APP), for example: MPC is an APP, SCQL is an APP, and FL is also an APP.

MPC refers to a plurality of participants holding private data, which collectively execute a computation logic and obtain a computation result.

The SCQL refers to a plurality of participants holding private data, jointly executes a data query logic, and obtains a query result. The difference between SCQL and MPC is that the MPC has predefined computational logic and can only execute a limited number of computational logics, while the SCQL has arbitrary data query logic, which is represented by a specific query language (query language) and written by a user, and after the user submits a specific query (query) request, the SCQL engine executes the query request according to the user's intention and displays the query result. Like MPC, the query result and query intermediate process of SCQL are also secure and do not reveal the original data of any participant.

However, the above solutions provided by the prior related art have the following disadvantages:

1) k8s is originally designed for a single mechanism, and the K8s was not designed at the beginning considering that Kubelet belongs to different mechanisms, that is, in view of Master, Kubelet of Alice mechanism and Kubelet of Bob mechanism are completely equivalent without any difference, so that an additional mechanism is needed to ensure that Pod is accurately issued to Alice mechanism or Bob mechanism.

2) Kubelet can only be deployed on physical machines, and if Kubelet is deployed in a container environment, Pod cannot be started. This is because Kubelet creates one or more containers for each Pod, and if Kubelet itself runs in a container, the container cannot be nested inside the container any more, and all Pod creation instructions fail to execute. N containers can be deployed on one physical machine, the running speed is high, resource isolation can be achieved, and the environments among the containers deployed on the same physical machine are completely isolated.

3) The APP related to the shared intelligence relates to cross-mechanism calling, and the Kubelet does not support cross-mechanism Pod calling.

The embodiment of the present specification is created based on a K8s cluster, some modifications are made on the basis of a K8s cluster, and fig. 2 is an architecture diagram of a K8s cluster provided in an embodiment of the present specification.

As shown in fig. 2, the embodiment of the present specification fully reuses the K8s Master, but discards the Kubelet and uses a completely new Agent (Agent) instead. The Agent implements the same interface as Kubelet and can therefore register itself with the Master. The advantages of this embodiment of the present description are:

1) the capability of the K8s Master can be multiplexed;

2) the Agent and the Kubelet interface are the same, so that the Master does not need to distinguish whether the node is the Kubelet or the Agent, and the Master does not need to be modified in the embodiment of the specification;

3) agents can be deployed in a physical machine or container environment, and Kubelet can be deployed only on the physical machine, so that the mechanism deployment environment limitation is solved.

In the embodiment of the present specification, there are two types of communication interfaces between the Master and the Kubelet, which need to be implemented by an Agent, and the two types of interfaces are a node registration interface and a node deletion interface, and a Pod creation interface and a Pod deletion interface, respectively.

The process of the Agent implementing these two types of interfaces will be described below.

1. Node creation

When the Agent is started, the Agent needs to register itself with the Master, and the Master can issue the Pod instruction only after the Agent is registered. The information required to be attached when the Agent registers can include:

1) and the basic node information may include all information attached to Kubelet registration, including node names and/or node machine hardware configuration information, and the like.

2) An organization name tag. The Agent additionally tags itself with a label associated with the organization, for example: alice organization agents will bring the label of "kubernets. io/namespace: Alice" when registering.

3) And the taint information is used for distinguishing Agent and Kubelet, and the Agent can additionally mark itself with a taint' nueva. The so-called taint is a mechanism provided by the K8s Master that if a node is tainted, a Pod will not be dispatched to the node unless the Pod declares that I can tolerate some taint.

Why is Agent stained? Because Agent is a "masquerading" Kubelet and does not support all types of Pod operations, only pulling up MPC, SCQL and/or FL related APPs is supported, agents can voluntarily taint themselves in order to avoid Master scheduling other unrelated pods onto agents.

2. Pod creation

Pod creation is initially triggered by a user who needs to submit one or more task (Pod) profiles to the Master when triggering MPC, SCQL, and/or FL tasks, for example, the Pod profiles may be as follows:

1.apiVersion:v1

2.kind:Pod

3.metadata:

4.name:task

5.namespace:alice

6.spec:

7.containers:

8.-name:main

9.image:mpc_trainer:v1

10.nodeSelector:

11.kubernetes.io/namespace:alice

12.tolerations:

13.-key:nueva.alipay.com/agent

14.operator:Exists

15.effect:NoSchedule

the main contents of the Pod description file may include:

1) task (Pod) basic information, lines 1-9;

2) a node selection (nodeSector) declaration, lines 10-11, tells Master that Pod must be dispatched to a node with a "kubernets. io/namespace: alice" label that is consistent with the label provided at Agent registration. In this way, the Master can ensure that the Pod will only be dispatched to Alice's machines and not to Bob's facilities.

3) Stain tolerance statement, lines 12-15. Since agents smudge themselves, users must specify that a smudge can be tolerated when submitting a Pod, otherwise the Pod cannot be dispatched to an Agent. The contents of the stain tolerance declaration are consistent with the contents of the Agent declaration.

In specific implementation, after a user submits the Pod, the Pod description file is issued to the Agent, and the Agent pulls up the related APP according to the image field in the Pod description file after receiving the Pod description file. Agent differs from Kubelet, most significantly, in how to pull up the APP, which is done by creating one or more containers for the APP and then starting the APP within the container. The Agent allocates a process group to each Pod, and then directly pulls up the APP process and adds the APP process to the allocated process group. The benefits of doing so are: the start-up container is a heavy-weight operation, needs many authorities, and generally only the physics machine can provide relevant authority, and the container is inside to have no authority, consequently, if Kubelet itself runs in the container, then the Kubelet authority is not enough, can't establish the Pod again, and APP can't start. The Agent only creates a common process without any authority, and can successfully start the Pod no matter the Agent runs on a physical machine or in a container environment.

3. Pod delete

After the Agent acquires the Pod delete instruction, the following process can be executed:

step 1, the Agent sends a task Suspension (SIGKILL) signal to the whole process group, and the process is terminated after receiving the SIGKILL signal. It should be noted that killing the process through the SIGKILL signal is a mechanism provided by the Linux operating system.

And step 2, informing the Master that the Pod is deleted.

4. Node deletion

The node deleting instruction is triggered by a mechanism administrator, when the mechanism administrator wants to offline a machine or delete a container where the Agent is located, a node deleting request can be initiated to the Agent, and the node deleting process of the Agent is as follows:

step 1, the Agent informs the Master that the node can not be scheduled. At this point, the Master does not schedule a new Pod onto the node.

And 2, sequentially executing a 'Pod delete' flow for the pods running by the local machine, deleting all the pods on the local machine, and informing the Master Pod of being deleted.

And 3, the Agent informs the Master to mark the node as unavailable.

And 4, deleting all the information related to the nodes from the K8s Master, namely logging out the nodes.

The embodiment of the present specification makes certain transformation and upgrade on the architecture of the K8s cluster, and can achieve the following technical effects:

1) the node execution framework Agent uses a process creation mode to replace a Kubelet container creation mode, and is suitable for all mechanism environments;

2) the Agent and the Kubelet have consistent interfaces, the central node does not need to be modified, the K8s central node can be directly multiplexed, and the scheme is low in implementation cost;

3) through the flexible matching of the label and the taint mechanism of K8s, the directional distribution of the Pod is realized.

The task execution method provided by the embodiment of the present specification is described below based on fig. 2 and the above description.

Fig. 3 is a flowchart of a task execution method according to an embodiment of the present disclosure, where the task execution method according to this embodiment may be executed by an Agent (Agent) in the K8s cluster shown in fig. 2. As shown in fig. 3, the task execution method may include:

step 302, a target agent obtains a description file of a first task to be executed; the description file is sent to a target agent by a central node, and carries an execution mechanism label of a first task, an application program corresponding to the first task and a stain tolerance statement; the execution mechanism label is consistent with the mechanism label provided by the target agent when registering, and the content of the stain tolerance statement is consistent with the content of the stain information provided by the target agent when registering.

For example, the description file of the first task may be as follows:

1.apiVersion:v1

2.kind:Pod

3.metadata:

4.name:task

5.namespace:alice

6.spec:

7.containers:

8.-name:main

9.image:mpc_trainer:v1

10.nodeSelector:

11.kubernetes.io/namespace:alice

12.tolerations:

13.-key:nueva.alipay.com/agent

14.operator:Exists

15.effect:NoSchedule

in the above example, the "namespace" field in line 5 shows that the "alice" field is the execution mechanism tag of the first task; the "image" field in line 9 shows that the application program "MPC" corresponding to the first task is obtained; lines 12-15 are stain tolerance statements.

Step 304, the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task.

Specifically, according to the application program corresponding to the first task, starting the application process corresponding to the application program may be: allocating a process group to the first task, and starting an application process corresponding to the application program; and adding the application process into the allocated process group.

That is to say, in this embodiment, the target agent allocates a process group to the first task, then directly starts the application process corresponding to the application program, and adds the application process to the allocated process group, so that the target agent only creates a common process without any authority, and the target agent can successfully start the first task no matter whether the target agent runs on a physical machine or in a container environment.

Step 306, executing a first task in the application process.

Fig. 4 is a flowchart of a task execution method according to another embodiment of the present specification, as shown in fig. 4, in the embodiment shown in fig. 3 of the present specification, after step 306, the method may further include:

step 402, a task deleting instruction is obtained, and the task deleting instruction carries a second task to be deleted.

Step 404, sending a task termination signal to the process group corresponding to the second task to terminate the application process corresponding to the second task in the process group.

Step 406, the central node is notified that the second task has been deleted.

Fig. 5 is a flowchart of a task execution method according to still another embodiment of the present specification, as shown in fig. 5, in the embodiment shown in fig. 3 of the present specification, before step 302, the method may further include:

step 502, sending a node registration request to a central node; wherein, the node registration request includes an organization label of a target agent and taint information of the target agent.

For example, a target agent of an Alice organization may carry a label of "kubernets. The taint information carried by the target agent in the node registration request may be "nueva.

Fig. 6 is a flowchart of a task execution method according to another embodiment of the present specification, and as shown in fig. 6, the embodiment shown in fig. 3 in the present specification may further include:

step 602, a node deletion request is obtained.

Specifically, the node deletion request may be triggered by an organization administrator, and when the organization administrator wants to offline a machine or delete a container in which the target agent is located, the node deletion request may be initiated to the target agent.

Step 604, notifying the central node that the target agent cannot be scheduled.

Step 606, delete the task executing on the target agent.

Specifically, when deleting a task executed on a target agent, the method provided by the embodiment shown in fig. 4 in this specification may be used to implement the task, and details are not described here again.

Step 608, notifying the central node to mark the status of the target agent as unavailable so that the central node deletes the target agent.

In this embodiment, steps 602 to 608 may be executed after the target agent sends the node registration request to the central node, and the execution sequence of steps 602 to 608 is not limited in this embodiment.

Fig. 7 is a flowchart of a task execution method according to still another embodiment of this specification, where the task execution method according to this embodiment may be executed by a central node in the K8s cluster shown in fig. 2. As shown in fig. 7, the task execution method may include:

step 702, obtaining a description file of a first task to be executed.

Step 704, determining the execution mechanism of the first task according to the execution mechanism tag carried in the description file.

Step 706, selecting a target agent suitable for executing the first task from the execution mechanism according to the content of the stain tolerance statement carried in the description file; and the content of the stain information provided by the target agent during registration is consistent with the content of the stain tolerance statement carried in the description file.

Step 708, sending the description file to the target agent, where the description file carries the execution mechanism tag, the application program corresponding to the first task, and the stain tolerance statement, so that the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task, and executes the first task in the application process.

According to the task execution method, after a description file of a first task to be executed is obtained, an execution mechanism of the first task is determined according to an execution mechanism label carried in the description file, and then a target agent suitable for executing the first task is selected from the execution mechanisms according to the content of a stain tolerance statement carried in the description file. And finally, sending the description file to a target Agent, wherein the description file carries the execution mechanism label, the application program corresponding to the first task and the stain tolerance statement, so that the target Agent starts an application process corresponding to the application program according to the application program corresponding to the first task and executes the first task in the application process, thereby realizing that the Agent (Agent) executes a task (Pod), and when executing the task, the target Agent only creates a common process without any authority, and the target Agent can successfully start the first task no matter whether running on a physical machine or a container environment, thereby enabling the K8s to adapt to the deployment environments of different mechanisms and shielding the difference on the infrastructure of the mechanisms.

It should be noted that the task description file, so-called file, mentioned in the embodiments of this specification is only one way to transfer information, and in an actual scenario, the file here may be replaced by a string sent over a network, or a JSON (JavaScript Object Notation) text, and the "file" is only one form of data transfer and does not constitute a limitation to the embodiments of this specification.

The foregoing description has been directed to specific embodiments of this disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.

Fig. 8 is a schematic structural diagram of a task execution device according to an embodiment of this specification, where the task execution device may be disposed in a target Agent (Agent) of a K8s cluster shown in fig. 2, and as shown in fig. 8, the task execution device may include: an acquisition module 81, a start module 82 and an execution module 83;

the acquiring module 81 is configured to acquire a description file of a first task to be executed; the description file is sent to a target agent by a central node, and the description file carries an execution mechanism label of a first task, an application program corresponding to the first task and a stain tolerance statement; the execution mechanism label is consistent with the mechanism label provided by the target agent during registration, and the content of the stain tolerance statement is consistent with the content of the stain information provided by the target agent during registration;

a starting module 82, configured to start, according to an application program corresponding to a first task, an application process corresponding to the application program;

and an executing module 83, configured to execute the first task in the application process.

The task execution device provided in the embodiment shown in fig. 8 may be used to execute the technical solution of the method embodiment shown in fig. 3 in this specification, and the implementation principle and the technical effect may further refer to the related description in the method embodiment.

Fig. 9 is a schematic structural diagram of a task execution device according to another embodiment of the present disclosure, and in the task execution device shown in fig. 9, a starting module 82 is specifically configured to allocate a process group to a first task, start an application process corresponding to the application program, and add the application process to the allocated process group.

Further, the task execution device may further include: a sending module 84 and a notification module 85;

the obtaining module 81 is further configured to obtain a task deleting instruction after the executing module 83 executes the first task, where the task deleting instruction carries a second task to be deleted;

a sending module 84, configured to send a task termination signal to a process group corresponding to a second task to terminate an application process corresponding to the second task in the process group;

a notification module 85, configured to notify the central node that the second task has been deleted.

Further, the sending module 84 is configured to send a node registration request to the central node before the obtaining module 81 obtains the description file of the first task to be executed; wherein, the node registration request includes an organization label of a target agent and taint information of the target agent.

Further, the task execution device may further include: a notification module 85 and a deletion module 86;

the obtaining module 81 is further configured to obtain a node deletion request;

a notification module 85, configured to notify the central node that the target agent cannot be scheduled;

a delete module 86 for deleting tasks executed on the target agent;

the notifying module 85 is further configured to notify the central node to mark the status of the target agent as unavailable, so that the central node deletes the target agent.

The task execution device provided in the embodiment shown in fig. 9 may be used to execute the technical solutions of the method embodiments shown in fig. 3 to fig. 6 in this specification, and further reference may be made to the relevant descriptions in the method embodiments for realizing the principles and technical effects.

Fig. 10 is a schematic structural diagram of a task performing device according to still another embodiment of the present disclosure, where the task performing device may be disposed on a central node (Master) of a K8s cluster shown in fig. 2, and as shown in fig. 10, the task performing device may include: an acquisition module 1001, a determination module 1002, a selection module 1003 and a sending module 1004;

the acquiring module 1001 is configured to acquire a description file of a first task to be executed;

a determining module 1002, configured to determine an execution mechanism of the first task according to the execution mechanism tag carried in the description file;

a selecting module 1003, configured to select, according to the content of the stain tolerance declaration carried in the description file, a target agent suitable for executing the first task from the executing mechanism; wherein, the content of the stain information provided by the target agent during registration is consistent with the content of the stain tolerance statement carried in the description file;

a sending module 1004, configured to send the description file to the target agent, where the description file carries the execution mechanism tag, the application program corresponding to the first task, and the stain tolerance statement, so that the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task, and executes the first task in the application process.

The task execution device provided in the embodiment shown in fig. 10 may be used to execute the technical solution of the method embodiment shown in fig. 7 in this specification, and the implementation principle and the technical effect may further refer to the related description in the method embodiment.

Fig. 11 is a schematic structural diagram of an electronic device provided in an embodiment of the present specification, where as shown in fig. 11, the electronic device may include at least one processor; and at least one memory communicatively coupled to the processor, wherein: the memory stores program instructions executable by the processor, and the processor calls the program instructions to execute the task execution method provided by the embodiments shown in fig. 3 to fig. 6 in the present specification.

The electronic device may be configured to deploy an Agent (Agent) in the K8s cluster, and the embodiment does not limit the form of the electronic device.

FIG. 11 illustrates a block diagram of an exemplary electronic device suitable for use in implementing embodiments of the present specification. The electronic device shown in fig. 11 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present specification.

As shown in fig. 11, the electronic device is embodied in the form of a general purpose computing device. Components of the electronic device may include, but are not limited to: one or more processors 410, a communication interface 420, a memory 430, and a communication bus 440 that connects the various components (including the memory 430, the communication interface 420, and the processing unit 410).

Communication bus 440 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, or a local bus using any of a variety of bus architectures. By way of example, the communication bus 440 may include, but is not limited to, an Industry Standard Architecture (ISA) bus, a Micro Channel Architecture (MCA) bus, an enhanced ISA (enhanced ISA) bus, a Video Electronics Standards Association (VESA) local bus, and a Peripheral Component Interconnect (PCI) bus.

Electronic devices typically include a variety of computer system readable media. Such media may be any available media that is accessible by the electronic device and includes both volatile and nonvolatile media, removable and non-removable media.

Memory 430 may include computer system readable media in the form of volatile memory, such as Random Access Memory (RAM) and/or cache memory. Memory 430 may include at least one program product having a set (e.g., at least one) of program modules that are configured to carry out the functions of the embodiments described herein with respect to fig. 3-6.

A program/utility having a set (at least one) of program modules, including but not limited to an operating system, one or more application programs, other program modules, and program data, may be stored in memory 430, each of which examples or some combination may include an implementation of a network environment. The program modules generally perform the functions and/or methods of the embodiments described in fig. 3-6 herein.

The processor 410 executes various functional applications and data processing by executing programs stored in the memory 430, for example, implementing the task execution method provided by the embodiments shown in fig. 3 to 6 of the present specification.

Embodiments of the present specification further provide an electronic device, where the electronic device may include at least one processor; and at least one memory communicatively coupled to the processor, wherein: the memory stores program instructions executable by the processor, and the processor calls the program instructions to execute the task execution method provided by the embodiment shown in fig. 7 in the present specification.

The electronic device may be configured with a central node (Master) in a K8s cluster, and the form of the electronic device is not limited in this embodiment. In a specific implementation, the electronic device may be implemented by using the structure shown in fig. 11, which is not described herein again.

The embodiments of the present specification provide a non-transitory computer readable storage medium, which stores computer instructions, the computer instructions causing the computer to execute the task execution method provided by the embodiments shown in fig. 3 to 6 of the present specification.

The embodiments of the present specification provide a non-transitory computer-readable storage medium storing computer instructions that cause the computer to perform a task execution method provided by the embodiment shown in fig. 7 of the present specification.

The non-transitory computer readable storage medium described above may take any combination of one or more computer readable media. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a Read Only Memory (ROM), an Erasable Programmable Read Only Memory (EPROM) or flash memory, an optical fiber, a portable compact disc read only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, Radio Frequency (RF), etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for aspects of the present description may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

In the description of the specification, reference to the description of the term "one embodiment," "some embodiments," "an example," "a specific example," or "some examples," etc., means that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the specification. In this specification, the schematic representations of the terms used above are not necessarily intended to refer to the same embodiment or example. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples. Furthermore, various embodiments or examples and features of different embodiments or examples described in this specification can be combined and combined by one skilled in the art without contradiction.

Furthermore, the terms "first", "second" and "first" are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of the feature. In the description of the present specification, "a plurality" means at least two, e.g., two, three, etc., unless explicitly defined otherwise.

Any process or method descriptions in flow charts or otherwise described herein may be understood as representing modules, segments, or portions of code which include one or more executable instructions for implementing steps of a custom logic function or process, and alternate implementations are included within the scope of the preferred embodiment of the present description in which functions may be executed out of order from that shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved, as would be understood by those reasonably skilled in the art of the embodiments of the present description.

The word "if" as used herein may be interpreted as "at … …" or "when … …" or "in response to a determination" or "in response to a detection", depending on the context. Similarly, the phrases "if determined" or "if detected (a stated condition or event)" may be interpreted as "when determined" or "in response to a determination" or "when detected (a stated condition or event)" or "in response to a detection (a stated condition or event)", depending on the context.

It should be noted that the terminal referred to in the embodiments of the present specification may include, but is not limited to, a Personal Computer (PC), a Personal Digital Assistant (PDA), a wireless handheld device, a tablet computer (tablet computer), a mobile phone, an MP3 player, an MP4 player, and the like.

In the several embodiments provided in this specification, it should be understood that the disclosed system, apparatus, and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and there may be other divisions in actual implementation, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

In addition, functional units in the embodiments of the present description may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.

The integrated unit implemented in the form of a software functional unit may be stored in a computer readable storage medium. The software functional unit is stored in a storage medium and includes several instructions to enable a computer device (which may be a personal computer, a server, or a network device) or a processor (processor) to execute some steps of the methods described in the embodiments of the present disclosure. And the aforementioned storage medium includes: various media capable of storing program codes, such as a U disk, a removable hard disk, a Read Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.

The above description is only a preferred embodiment of the present disclosure, and should not be taken as limiting the present disclosure, and any modifications, equivalents, improvements, etc. made within the spirit and principle of the present disclosure should be included in the scope of the present disclosure.

Claims

1. A task execution method, comprising:

acquiring a description file of a first task to be executed; the description file is sent to a target agent by a central node, and the description file carries an execution mechanism label of the first task, an application program corresponding to the first task and a stain tolerance statement; wherein the executive mechanism label is consistent with the mechanism label provided by the target agent when registering, and the content of the stain tolerance statement is consistent with the content of the stain information provided by the target agent when registering;

starting an application process corresponding to the application program according to the application program corresponding to the first task;

executing the first task in the application process.

2. The method of claim 1, wherein the launching of the application process corresponding to the application program according to the application program corresponding to the first task comprises:

allocating a process group to the first task;

starting an application process corresponding to the application program;

and adding the application process into the allocated process group.

3. The method of claim 2, wherein after the executing the first task in the application process, further comprising:

acquiring a task deleting instruction, wherein the task deleting instruction carries a second task to be deleted;

sending a task termination signal to a process group corresponding to the second task to terminate the application process corresponding to the second task in the process group;

notifying the central node that the second task has been deleted.

4. The method of claim 1, wherein before obtaining the description file of the first task to be performed, further comprising:

sending a node registration request to a central node; wherein the node registration request comprises an organization label of a target agent and taint information of the target agent.

5. The method of any of claims 1-4, further comprising:

acquiring a node deletion request;

notifying the central node that the target agent cannot be scheduled;

deleting the task executed on the target agent;

notifying the central node to mark the status of the target agent as unavailable to cause the central node to delete the target agent.

6. A task execution method, comprising:

acquiring a description file of a first task to be executed;

determining an execution mechanism of the first task according to an execution mechanism label carried in the description file;

selecting a target agent suitable for executing the first task from the execution mechanism according to the content of the stain tolerance statement carried in the description file; wherein the content of the stain information provided by the target agent during registration is consistent with the content of the stain tolerance statement carried in the description file;

and sending the description file to the target agent, wherein the description file carries the executing mechanism label, the application program corresponding to the first task and the stain tolerance statement, so that the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task and executes the first task in the application process.

7. A task execution device provided in a target agent, the device comprising:

the acquisition module is used for acquiring a description file of a first task to be executed; the description file is sent to a target agent by a central node, and the description file carries an execution mechanism label of the first task, an application program corresponding to the first task and a stain tolerance statement; wherein the executive mechanism label is consistent with the mechanism label provided by the target agent when registering, and the content of the stain tolerance statement is consistent with the content of the stain information provided by the target agent when registering;

the starting module is used for starting an application process corresponding to the application program according to the application program corresponding to the first task;

an execution module to execute the first task in the application process.

8. The apparatus of claim 7, wherein,

the starting module is specifically configured to allocate a process group to the first task, start an application process corresponding to the application program, and add the application process to the allocated process group.

9. The apparatus of claim 8, further comprising: a sending module and a notification module;

the acquisition module is further configured to acquire a task deletion instruction after the execution module executes the first task, where the task deletion instruction carries a second task to be deleted;

the sending module is configured to send a task termination signal to the process group corresponding to the second task to terminate the application process corresponding to the second task in the process group;

the notification module is configured to notify the central node that the second task has been deleted.

10. The apparatus of claim 7, further comprising: a sending module;

the sending module is used for sending a node registration request to the central node before the obtaining module obtains the description file of the first task to be executed; wherein the node registration request comprises an organization label of a target agent and taint information of the target agent.

11. The apparatus of any of claims 7-10, further comprising: a notification module and a deletion module;

the acquisition module is further used for acquiring a node deletion request;

the notification module is used for notifying the central node that the target agent can not be scheduled;

the deleting module is used for deleting the task executed on the target agent;

the notifying module is further configured to notify the central node that the status of the target agent is marked as unavailable, so that the central node deletes the target agent.

12. A task performance apparatus disposed on a central node, the apparatus comprising:

the acquisition module is used for acquiring a description file of a first task to be executed;

the determining module is used for determining the executing mechanism of the first task according to the executing mechanism label carried in the description file;

a selection module, configured to select, according to the content of the stain tolerance statement carried in the description file, a target agent suitable for executing the first task from the execution mechanism; wherein the content of the stain information provided by the target agent during registration is consistent with the content of the stain tolerance statement carried in the description file;

a sending module, configured to send the description file to the target agent, where the description file carries the execution mechanism tag, the application program corresponding to the first task, and the stain tolerance statement, so that the target agent starts an application process corresponding to the application program according to the application program corresponding to the first task, and executes the first task in the application process.

13. An electronic device, comprising:

at least one processor; and

at least one memory communicatively coupled to the processor, wherein:

the memory stores program instructions executable by the processor, the processor invoking the program instructions to perform the method of any of claims 1 to 5.

14. A non-transitory computer readable storage medium storing computer instructions that cause the computer to perform the method of any of claims 1 to 5.

15. An electronic device, comprising:

at least one processor; and

at least one memory communicatively coupled to the processor, wherein:

the memory stores program instructions executable by the processor, the processor invoking the program instructions to perform the method of claim 6.

16. A non-transitory computer-readable storage medium storing computer instructions that cause the computer to perform the method of claim 6.