CN117134960A - Cross-cluster privacy computing task execution method and device - Google Patents
Cross-cluster privacy computing task execution method and device Download PDFInfo
- Publication number
- CN117134960A CN117134960A CN202311076224.6A CN202311076224A CN117134960A CN 117134960 A CN117134960 A CN 117134960A CN 202311076224 A CN202311076224 A CN 202311076224A CN 117134960 A CN117134960 A CN 117134960A
- Authority
- CN
- China
- Prior art keywords
- state
- party
- resource
- pod
- kubernetes cluster
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 48
- 230000007246 mechanism Effects 0.000 claims abstract description 59
- 230000004044 response Effects 0.000 claims abstract description 12
- 230000001360 synchronised effect Effects 0.000 claims description 35
- 230000008859 change Effects 0.000 claims description 15
- 238000004590 computer program Methods 0.000 claims description 4
- 238000004364 calculation method Methods 0.000 abstract description 25
- 238000010586 diagram Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 4
- 238000012986 modification Methods 0.000 description 4
- 238000012544 monitoring process Methods 0.000 description 4
- 238000012217 deletion Methods 0.000 description 3
- 230000037430 deletion Effects 0.000 description 3
- 230000006870 function Effects 0.000 description 3
- 230000008569 process Effects 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 2
- 239000003999 initiator Substances 0.000 description 2
- 150000002500 ions Chemical class 0.000 description 2
- 101100384355 Mus musculus Ctnnbip1 gene Proteins 0.000 description 1
- 238000005192 partition Methods 0.000 description 1
- 238000011045 prefiltration Methods 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000012163 sequencing technique Methods 0.000 description 1
- 238000012549 training Methods 0.000 description 1
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L63/00—Network architectures or network communication protocols for network security
- H04L63/20—Network architectures or network communication protocols for network security for managing network security; network security policies in general
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
- G06F9/5038—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the execution order of a plurality of tasks, e.g. taking priority or time dependency constraints into consideration
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5061—Partitioning or combining of resources
- G06F9/5072—Grid computing
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L63/00—Network architectures or network communication protocols for network security
- H04L63/16—Implementing security features at a particular protocol layer
- H04L63/168—Implementing security features at a particular protocol layer above the transport layer
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L9/00—Cryptographic mechanisms or cryptographic arrangements for secret or secure communications; Network security protocols
- H04L9/08—Key distribution or management, e.g. generation, sharing or updating, of cryptographic keys or passwords
- H04L9/0816—Key establishment, i.e. cryptographic processes or cryptographic protocols whereby a shared secret becomes available to two or more parties, for subsequent use
- H04L9/0852—Quantum cryptography
- H04L9/0858—Details about key distillation or coding, e.g. reconciliation, error correction, privacy amplification, polarisation coding or phase coding
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Computer Security & Cryptography (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- Signal Processing (AREA)
- Computer Networks & Wireless Communication (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Computer Hardware Design (AREA)
- Electromagnetism (AREA)
- Mathematical Physics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The embodiment of the specification provides a cross-cluster privacy computing task execution method, which relates to a first party and a second party, and comprises the following steps: the first party obtains the description information of the privacy calculation task, and respectively creates a first resource and a second resource for running the privacy calculation task under a first naming space and a second naming space corresponding to the first party and the second party in the first Kubernetes cluster. And a synchronization mechanism is established between the second naming space and the second party. The first party synchronizes the second resource into the second Kubernetes cluster through a synchronization mechanism. Upon determining that there is a first computing node for which the resource condition meets the target requirement, the first party sets the resource state to a reserved state and obtains the resource state from the second party through a synchronization mechanism. When the resource states under the first and second namespaces are determined to be reserved states, they are updated to schedulable states. In response to the resource status being a schedulable status, the first party performs Pod group scheduling to perform the privacy calculation task.
Description
Technical Field
One or more embodiments of the present disclosure relate to the field of computer technologies, and in particular, to a method and an apparatus for executing a cross-cluster privacy computing task.
Background
In the scenario where multiple participants cooperatively perform a privacy calculation task, it is necessary to consider whether each participant has sufficient resources when scheduling the task. Otherwise, a problem may occur that a part of the participants have been successfully scheduled, and another part of the participants have failed to be scheduled, thereby causing the whole privacy calculation task to be failed to execute.
For the above-mentioned multiple participants, they may be located in different Kubernetes (k 8s for short) clusters, which requires performing a cross-cluster resource condition judgment, so as to implement cross-cluster privacy task execution.
Disclosure of Invention
One or more embodiments of the present disclosure describe a cross-cluster method for executing a private computing task, which may perform execution of the private computing task between a plurality of participants corresponding to different Kubernetes clusters, and may improve the utilization rate of cluster resources and the execution efficiency of the private computing task.
In a first aspect, a cross-cluster privacy computing task execution method is provided, involving first and second parties corresponding to first and second Kubernetes clusters, respectively; the method is performed by the first party and comprises:
acquiring description information of a privacy computing task, and respectively creating first and second resources for running the privacy computing task under a first naming space and a second naming space corresponding to the first and second parties in the first Kubernetes cluster according to the description information, wherein the first resources comprise a first Pod group and a first state; the second resource includes a second Pod group and a second state; a synchronization mechanism is established between the second naming space and the second party;
Synchronizing the second resource into the second Kubernetes cluster through the synchronization mechanism;
when a first computing node of which the resource condition meets the target requirement in the description information exists in the first Kubernetes cluster, setting the value of the first state into a reserved state;
acquiring a value of the second state from the second party through the synchronization mechanism;
updating both the first and second states to a schedulable state if it is determined that the values are both reserved;
and in response to the value of the first state being a schedulable state, scheduling the first Pod group to the first computing node to perform the privacy computing task.
In a second aspect, a cross-cluster privacy computing task execution method is provided, involving first and second parties corresponding to first and second Kubernetes clusters, respectively; the method is performed by the second party and comprises:
creating a second resource acquired from the first party under a namespace corresponding to the second party in the second Kubernetes cluster through a synchronization mechanism established between the second party and the second namespace, wherein the second resource comprises a second Pod group and a second state; the second namespace is a namespace created for the second party in the first Kubernetes cluster;
When a second computing node with a resource condition meeting the target requirement in the description information exists in the second Kubernetes cluster, setting the value of the second state to be a reserved state;
synchronizing the value of the second state into the first Kubernetes cluster through the synchronization mechanism;
updating the value of the second state to a schedulable state through the synchronization mechanism;
and in response to the value of the second state being a schedulable state, scheduling the second Pod group to the second computing node to perform the privacy computing task.
In a third aspect, a cross-cluster privacy computing task execution device is provided, and is configured to be set on a first party, where the device includes:
the system comprises an acquisition unit, a first storage unit and a second storage unit, wherein the acquisition unit is used for acquiring description information of a privacy calculation task and respectively creating first and second resources for running the privacy calculation task under first and second namespaces corresponding to first and second parties in a first Kubernetes cluster corresponding to the first party according to the description information, and the first resources comprise a first Pod group and a first state; the second resource includes a second Pod group and a second state; a synchronization mechanism is established between the second naming space and the second party;
The synchronization unit is used for synchronizing the second resource into a second Kubernetes cluster corresponding to the second party through the synchronization mechanism;
the setting unit is used for setting the value of the first state to be a reserved state when determining that a first computing node exists in the first Kubernetes cluster and the resource condition meets the target requirement in the description information;
the acquiring unit is further configured to acquire a value of the second state from the second party through the synchronization mechanism;
an updating unit configured to update, in a case where it is determined that the values of the first and second states are both reserved states, both of them to schedulable states;
and the scheduling unit is used for scheduling the first Pod group to the first computing node to execute the privacy computing task in response to the value of the first state being a schedulable state.
In a fourth aspect, a cross-cluster privacy computing task execution device is provided, configured to be disposed on a second party, and includes:
the creating unit is configured to create, by using a synchronization mechanism established between the second party and a second namespace, a second resource acquired from the first party under the namespace corresponding to the second party in a second Kubernetes cluster corresponding to the second party, where the second resource includes a second Pod group and a second state; the second namespace is a namespace created for the second party in a first Kubernetes cluster corresponding to the first party;
The setting unit is used for setting the value of the second state to be a reserved state when determining that a second computing node exists in the second Kubernetes cluster and the resource condition meets the target requirement in the description information;
a synchronization unit, configured to synchronize, by using the synchronization mechanism, the value of the second state into the first Kubernetes cluster;
an updating unit, configured to update, by using the synchronization mechanism, the value of the second state to a schedulable state;
and the scheduling unit is used for scheduling the second Pod group to the second computing node to execute the privacy computing task in response to the value of the second state being a schedulable state.
In a fifth aspect, there is provided a computer readable storage medium having stored thereon a computer program which, when executed in a computer, causes the computer to perform the method of the first or second aspect.
In a sixth aspect, there is provided a computing device comprising a memory having executable code stored therein and a processor which, when executing the executable code, implements the method of the first or second aspect.
According to the cross-cluster privacy computing task execution method provided by one or more embodiments of the present disclosure, after receiving a privacy computing task, an arbitrary first party may create resources for running the privacy computing task for a plurality of parties in the Kubernetes cluster, where the resources include a Pod group and a state corresponding to the Pod group. Wherein the resources created for each participant can be synchronized with each participant by a synchronization mechanism. And when the states of all the participants are determined to be schedulable states, scheduling the corresponding Pod groups to computing nodes meeting the conditions, synchronously updating the scheduled task Pod states to a first synchronous controller by other participants, and updating the states to Pods under the namespaces of other participants by the first synchronous controller so as to realize the cooperative execution of privacy computing tasks. In a word, the scheme can perform the execution of the privacy calculation task among a plurality of participants corresponding to different Kubernetes clusters, and can improve the utilization rate of cluster resources and the execution efficiency of the privacy calculation task.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present description, the drawings that are needed in the description of the embodiments will be briefly described below, it being obvious that the drawings in the following description are only some embodiments of the present description, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a schematic illustration of an implementation scenario of one embodiment disclosed herein;
FIG. 2 illustrates a schematic diagram of a method of performing a private computing task across clusters, according to one embodiment;
FIG. 3 illustrates a schematic diagram of a cross-cluster privacy computing task performing device in accordance with one embodiment;
FIG. 4 illustrates a schematic diagram of a cross-cluster privacy computing task performing device in accordance with another embodiment.
Detailed Description
The following describes the scheme provided in the present specification with reference to the drawings.
The privacy computing task is generally calculated by a plurality of participants in a cooperative manner under the condition that respective data does not leave a domain, and a final computing result is obtained, for example, the privacy computing task can be a multiparty cooperative modeling task, each participant holds part of training data, and finally each participant obtains a secret sharing partition of model parameters.
In the conventional technology, a plurality of participants cooperatively executing a privacy computing task can only be located in one Kubernetes cluster, and when the plurality of participants are respectively located in different Kubernetes clusters, cooperative computing of the privacy computing task cannot be realized.
In this scheme, the participants (also called sponsors) receiving the privacy task create corresponding namespaces for the multiple participants in the corresponding Kubernetes cluster, respectively, and create corresponding resources under the namespaces of the respective participants. Meanwhile, a synchronization mechanism is established between each namespace and the corresponding participant to synchronize resource changes under each namespace. After that, the initiator can judge whether all the participants have enough resources to run the privacy calculation task based on the resources under each naming space, so that the problem that after the task Pod or Pod resources (hereinafter referred to as Pod) are scheduled, the Pod of the participants with insufficient resources cannot be scheduled to a proper node due to insufficient resources of some of the participants can be avoided, and finally the whole task fails.
In other words, the problem of task scheduling failure caused by insufficient resources of some participants can be effectively avoided, and meanwhile, the utilization rate of cluster resources and the operation efficiency of multiparty safe computing tasks can be effectively improved.
The execution method is described in detail below.
Fig. 1 is a schematic diagram of an implementation scenario of an embodiment disclosed in the present specification. In fig. 1, party a corresponds to Kubernetes cluster a and party B corresponds to Kubernetes cluster B. In Kubernetes cluster a, namespaces namespace a and namespace B are created for party a and party B, respectively. In Kubernetes cluster B, a namespace B is created for party B. In addition, in Kubernetes cluster a, a task controller (Task Contro l ler), a synchronization controller (Sync Contro l ler), a group controller (PartyGroup Contro l ler), and a task Pod scheduler (Kuscia Schedu ler) corresponding to participant a are also deployed. And in Kubernetes cluster B, there is also deployed a synchronization controller (Sync Contro l ler) and a task Pod scheduler (Kuscia Schedu ler).
In fig. 1, a party a may receive a private computing task, after which first and second resources for running the private computing task may be created by a task controller therein under nasespacea and nasespaceb, respectively, in Kubernetes cluster a. Wherein the first resource comprises Pod group A and PartyResourceA, and the second resource comprises Pod group B and PartyResourceB. Here PartyResourceA a and PartyResourceB are custom resource CRs for storing resource states. The second resource may then be synchronized in both clusters by the synchronization controllers in Kubernetes cluster a and Kubernetes cluster B. And, the resource states stored by the PartyresourceA and PartyresourceB described above may be set or updated by the group controller in the Kubernetes cluster A. In addition, when the resource states stored by the PartyResourceA and PartyResourceB are schedulable states, the first Pod group can be scheduled by a task Pod scheduler in the Kubernetes cluster A, and the second Pod group created in the Kubernetes cluster B can be scheduled by the task Pod scheduler in the Kubernetes cluster B, so that the cooperative execution of the privacy calculation task between the participant A and the participant B is realized.
The task Pod scheduler is realized by expanding a native scheduler based on Kubernetes schedu ler framework. The main extension points and the functions of the extension points are as follows:
sequencing according to Pod priority or creation time;
PreFi lter, pre-checking Pod, such as whether PartyResource exists, whether PartyResource resource state is normal, etc.;
when the PostFi lter fails, rejecting other Pods in the same group in all wait states, and entering the next round of scheduling;
reserve, adding Pod into the state information of the belonging group, wherein the summarized state information of the belonging group is used for a permission expansion point;
UnReserve, namely updating the PartyResource resource state and clearing state information of the group to which Pod belongs;
permission, checking whether the group to which the Pod belongs accords with a minReservedPods threshold value, and performing approval, rejection or delay scheduling;
PreBind, monitoring and updating PartyResource resource state, and time delay binding;
PostBind, namely clearing state information of the group to which Pod belongs.
Furthermore, it should be understood that fig. 1 is only an exemplary illustration, and in practical application, in Kubernetes cluster B, a namespace corresponding to participant a may also be created, and a task controller, a group controller, etc. may be deployed therein, which is not limited in this specification.
Finally, the number of the above-mentioned participants is not limited to two, and may be three or more.
FIG. 2 illustrates a schematic diagram of a method of performing a private computing task across clusters, according to one embodiment. In fig. 2, the method may include the steps of:
step S202, a first party obtains description information of a privacy calculation task, and creates first and second resources for running the privacy calculation task under first and second namespaces corresponding to first and second parties in a first Kubernetes cluster corresponding to the first party according to the description information.
The first resource comprises a first Pod group and a first state, and the second resource comprises a second Pod group and a second state. The first/second state herein refers to a resource state, and the resource includes a computing resource, a storage resource, and the like.
In particular, the description information of the privacy calculation task may be obtained by a first task controller of a first party deployed in a first Kubernetes cluster.
For example, the first party may be party a in fig. 1, and the first Kubernetes cluster may be Kubernetes cluster a in fig. 1.
In one embodiment, the above-described privacy computing task may be created by a task presenter (e.g., a user) using a command line tool (kubenete l) of the first Kubernetes cluster.
In another embodiment, the above-described privacy computing task may be created by a task presenter (e.g., an application program) by invoking an application programming interface (App l icat ion Programming I nterface, API) of the first Kubernetes cluster.
In a more specific embodiment, the task presenter creates the above-described privacy calculation task by creating a CR instance of a custom resource (Custom Resource Defin it ions, CRD). The CRD herein may be used to extend the resources of the Kubernetes cluster, where description information of the privacy computation task may be stored in the CR instance.
In the case of creating the above-described privacy calculation task by creating a CR instance, the privacy calculation task may also be referred to as a privacy task CR. In one example, the content of the privacy task CR may be seen in the following code segments:
as seen in connection with the above example, the privacy calculation task includes at least information of each participant, as in lines 12-26 in the above example, specifically, the information of each participant may include the following information items:
the domain identity (domain ID) of the participant, in the k8s cluster, corresponds to a Namespace (Namespace), so that the domain identity may also be referred to as a Namespace identity.
The Pod information may include, in particular, the number of copies of the Pod (rep documents), detailed information of the Pod (spec), and the like.
In one embodiment, the first task controller may apply in advance for changes (including creation, modification, and deletion) to the listening privacy task CR to the control plane (API Server) of the first Kubernetes cluster.
In one embodiment, the interception of changes to the privacy task CR may be implemented based on the i st-watch mechanism of Kubernetes.
The ist-watch mechanism is an asynchronous message handling mechanism that enables the control plane of Kubernetes and task controllers to communicate with each other and synchronize update information. Specifically, when the task controller applies to monitor the change of the privacy task CR, a long connection may be constructed between the control plane of Kubernetes and the first task controller, and when the change is monitored, an update event notification is sent to the task controller through the long connection. In one particular example, the update event notification may carry the created privacy task CR.
The first task controller may analyze the obtained privacy calculation task, so as to obtain description information of the privacy calculation task or content information of the privacy calculation task.
In practice, the first/second resources may also include service (service discovery) resources, configmap (application configuration management) resources, and the like.
In one embodiment, the first party creates the first/second state by creating a CR instance of the CRD, wherein the created CR instance may be referred to as a PartyResource resource, which may store the first/second state. In the following description of the present specification, the first/second state stored in the PartyResource resource is referred to as a PartyResource state.
In one example, the contents of the PartyResource resource may be seen in the following code segment:
wherein, in the code segment, the l-abel s field of lines 4-5 represents the label of PartyResource resource. The task-name information in this field indicates the name of the privacy calculation task to which the PartyResource resource belongs. The name field of line 6 represents the Partyresource resource name. The anamespace field of line 7 represents the namespace in which the Partyresource resource resides. The in it iator field of line 9 indicates the initiator of the task. The minReservedPods field of line 10 indicates the minimum number of Pods of reserved resources under the participants' Namespace. When this condition is met, the task Pod scheduler will update the PartyResource resource state to which the Pods belong under the Namespace to a Reserved state (Reserved). The pods field of lines 11-15 indicates the relevant information of the Pod group. The name field of line 12 indicates the Pod name, the resource reserved seconds field of line 13 indicates the maximum time that resources are reserved after the Pods are reserved under each nacispace, and if this state does not change to a schedulable state (schedulable l ab le) within the predetermined time, the PartyResource state is set to a failed state (failed). The retryDurat ionSeconds field of line 14 indicates the wait time for the next rescheduling after the unsuccessful scheduling of the task within the specified participant reserved resource duration, and the l ifecyc leSeconds field of line 15 indicates the longest life cycle of the task outstanding scheduling. The status field of lines 16-21 indicates the PartyResource resource status. The phase field of line 17 indicates the phase to which the Partyresource resource state belongs. The phase includes any one of the following: reserved resources, schedulers l ab le (schedulable state: when the Pods are Reserved for each nacspace), task Pod schedulers can perform binding operations on Pod), reserved Fai led (failure to reserve resources, waiting for the next round of scheduling), and Fai led (failure to reserve resources due to scheduling timeout).
It should be appreciated that some of the fields in the code segments described above may be inherited from the belonging privacy task CR. Such as the resourceReservedSeconds field, retryDurat ionSeconds field, l ifecyc leSeconds field, etc.
Taking the above first party as the participant a in fig. 1 as an example, the first task controller may be a task controller in Kubernetes cluster a. Specifically, the first task controller may create, under Namespace A, a first resource for party A to run a privacy computing task, such as Pod group A and PartyResourceA, and the like. In addition, a second resource for running privacy computing tasks for party B, such as Pod group B and partyresource B, etc., may also be created under naspace B.
In one embodiment, when the first Pod group is created, a scheduler name (schedulers) field in first Pod information (i.e., pod information of the first party) in the description information of the privacy task may be set to a first identifier of a first task Pod scheduler (i.e., a task Pod scheduler of the first party deployed in the first Kubernetes cluster), so that the first Pod group is scheduled by the first task Pod scheduler;
in addition, when the second Pod group is created, a scheduler name field in second Pod information (i.e., pod information of the second party) in the description information of the privacy task may be set to other identifications so that the second Pod group is not scheduled by the first task Pod scheduler.
In step S204, the first party synchronizes the second resource to the second Kubernetes cluster through a synchronization mechanism.
In the embodiment of the present specification, a synchronization mechanism is established between the second namespace and the second party.
The establishment of the synchronization mechanism specifically includes:
a second synchronization controller of a second party deployed in a second Kubernetes cluster subscribes to resource changes (including resource creation, modification, and deletion) under a second namespace from a first synchronization controller of a first party deployed in a first Kubernetes cluster.
Specifically, the second synchronization controller sends a message subscription request to the first synchronization controller, including the second namespace and the resource type (e.g., pod, partyResource, etc.) to be subscribed to. After receiving the message subscription request, the first synchronous controller sends the resource change to the second synchronous controller when monitoring the resource change of the subscribed resource type under the second naming space.
In one embodiment, the second namespace and the resource type to be subscribed may be described by subscribing to the resource CR, and the second synchronization controller may monitor the change of the subscribed resource CR, and send a message subscription request to the first synchronization controller when the subscribed resource CR is monitored to be created.
In practice, the subscription resource CR is further used to describe an access address of the first synchronization controller, so that the second synchronization controller may send the message subscription request to the first synchronization controller according to the access address.
For example, in the foregoing example, the synchronization controller of the party B may send in advance a message subscription request to the synchronization controller of the party a, the message subscription request including a namespace to be subscribed to: namespace B and the resource type to be subscribed to: and after the synchronous controller of the participant A monitors the Pod group B and PartyResourceB resource change under Namespace B, the synchronous controller of the participant A can synchronize the change to the synchronous controller of the participant B.
In one example, the content of the subscription resource CR may be referred to as the following code segments:
in the code segment, the name of the 4 th row represents the name of the subscribed resource, the host of the 6 th row represents the access address of the synchronous controller of the opposite side (i.e. the first synchronous controller of the first side), the members of the 7 th-8 th rows represent the namespaces of the method, i.e. the namespaces to be subscribed (i.e. the second namespaces), and the resources of the 9 th-11 th rows represent the types of the resources to be subscribed.
The step S204 specifically includes:
the first synchronous controller monitors that a second resource is created under a second naming space in the first Kubernetes cluster, and sends the second resource to the second synchronous controller, so that the second synchronous controller creates the received second resource under a naming space (hereinafter referred to as a target naming space) of a second party in the second Kubernetes cluster. I.e. creating a second Pod set and a second state.
The first synchronous controller can monitor resource change (including resource creation, modification and deletion) under the second naming space in the first Kubernetes cluster through an i st-watch mechanism.
For example, in the foregoing example, the synchronization controller of party B creates (updates or deletes) Pod groups B and partyresource B under nasspace B in Kubernetes cluster B after receiving the second resource sent by the synchronization controller of party a. Wherein in creating a Pod, the schedullername field in the Pod is set to kuservice-scheduler (identification of the task Pod scheduler in Kubernetes cluster B) so that the Pod group B is scheduled by the task Pod scheduler in Kubernetes cluster B.
In step S206, when determining that there is a first computing node in the first Kubernetes cluster whose resource condition satisfies the task Pod resource requirement, the first party sets the value of the first state to be a reserved state.
The task Pod resource requirements described above may be included in the description information of the private computing task.
In particular, the setting of the value of the first state described above may be performed by a first task Pod scheduler of a first party deployed in a first Kubernetes cluster.
The first task Pod scheduler can monitor resource change under the first naming space through an ist-watch mechanism, so that the first task Pod scheduler can build first resources under the first naming space, and a first computing node is determined from a first Kubernetes cluster.
In one embodiment, the task Pod resource requirements described above include: the number of Pod of successfully reserved resources for the first Pod group is not less than the Pod number threshold (i.e., the value of minReservedPods field).
Similarly, a second task Pod scheduler of a second party deployed in a second Kubernetes cluster may set a value of a second state created under the target namespace.
Specifically, the second task Pod scheduler may monitor, through the ist-watch mechanism, a resource change under the target namespace, so that the second task Pod scheduler monitors that a second resource is created under the target namespace, determines a second computing node whose resource condition meets the task Pod resource requirement from the second Kubernetes cluster, and sets a value of a second state under the target namespace to a reserved state.
In step S208, the first party obtains the value of the second state from the second party through the synchronization mechanism.
After the second task Pod scheduler sets the value of the second state under the target namespace to a reserved state (i.e. modifies the PartyResource), the second synchronous controller listens to the resource change under the target namespace, and can synchronize the value of the second state under the target namespace into the first Kubernetes cluster, that is, send the value of the second state under the target namespace to the first synchronous controller, so that the first synchronous controller sets the value of the second state under the second namespace to the reserved state.
It should be noted that the value of the second state under the target namespace is synchronized into the first Kubernetes cluster, because after the synchronization mechanism is established between the second namespace and the second party, the resource change under the target namespace is synchronized to the second namespace accordingly.
In step S210, the first party updates both the first and second namespaces to the schedulable state if it is determined that the values of both the first and second states are reserved states.
Specifically, a first group of controllers deployed on a first party in a first Kubernetes cluster may monitor resource changes under the first and second namespaces through an ist-watch mechanism, so that when both the value of the first state under the first namespace and the value of the second state under the second namespace are monitored to be reserved states, and when the number of parties of the reserved resources is greater than a predetermined threshold (i.e., the value of a minReserve members field), the value of the first state and the value of the second state are updated to schedulable states. The updating of the values of the first state and the second state herein may also be understood as modifying the PartyResource resource.
The first synchronous controller applies for monitoring the resource change under the second naming space in advance, so that after updating the value of the second state under the second naming space, the first synchronous controller can synchronize the updated value (i.e. the schedulable state) of the second state under the second naming space to the second synchronous controller, and the second synchronous controller updates the value of the second state under the target naming space into the schedulable state.
Of course, in practical application, after setting the value of the first state in the first namespace to the reserved state, the first group of controllers starts to count time, and when the count time reaches a first preset duration (such as the value of the resourcereresvedseconds field) and the value of the second state in the second namespace is not monitored to be set to the reserved state, the first group of controllers sets the value of the first state in the first namespace and the value of the second state in the second namespace to the reserved resource failure state (reservedfalied). In addition, after the first set of controllers starts timing, the timing reaches a second preset duration (e.g., the value of l ifecyc leSeconds field), and the values of the first state and the second state are not monitored to be set to a schedulable state, and the value of the first state under the first namespace and the value of the second state under the second namespace are set to a failed state (failed). The first synchronization controller may synchronize the updated value of the second state under the second namespace (including the reserved resource failure state and the failure state) to the second synchronization controller such that the second synchronization controller updates the value of the second state under the target namespace.
In step S212, the first party dispatches the first Pod group to the first computing node to execute the privacy computing task in response to the value of the first state under the first namespace being a dispatchable state.
Specifically, the first task Pod scheduler monitors that the value of the first state is changed to a schedulable state under the first namespace, and may schedule the first Pod group to an appropriate computing node (i.e., the first computing node).
Similarly, the second side task Pod scheduler monitors that the value of the second state is changed to a schedulable state under the target namespace, and may schedule the second Pod group to an appropriate computing node (i.e., the second computing node).
It should be appreciated that after the second Pod group is dispatched to the second computing node, the task Pod state changes, and then the second synchronization controller synchronizes the task Pod state changes to the first synchronization controller, such that the first synchronization controller updates the state changes into the Pod under the second namespace. Thus, the first party and the second party complete task Pod collaborative scheduling.
The task Pod state may include a bind state, a run state, a suspended state, and a failed state.
In summary, according to the cross-cluster privacy computing task execution method provided in the embodiments of the present disclosure, after receiving a privacy computing task, an arbitrary first party may create, for a plurality of parties, resources for running the privacy computing task in the Kubernetes cluster to which the first party belongs, where the resources include a Pod group and a state corresponding to the Pod group. Wherein the resources created for each participant can be synchronized with each participant by a synchronization mechanism. And when the states of all the participants are determined to be schedulable states, scheduling the corresponding Pod groups to computing nodes meeting the conditions, synchronously updating the scheduled task Pod states to a first synchronous controller by other participants, and updating the states to Pods under the namespaces of other participants by the first synchronous controller so as to realize the cooperative execution of privacy computing tasks. In a word, the scheme can perform the execution of the privacy calculation task among a plurality of participants corresponding to different Kubernetes clusters, and can improve the utilization rate of cluster resources and the execution efficiency of the privacy calculation task.
In addition, the scheme has the following advantages:
1) The group controller is used for managing the PartyResource resource states of all the participants belonging to the same privacy computing task, and only when the PartyResource resource states of all the participants are changed to a reserved state, the PartyResource resource states of all the participants are updated to a schedulable state, so that scheduling of the power of the cross-cluster is controlled, and further execution of the privacy computing task of the cross-cluster is realized.
2) The pole scheduling management of the participant namespace layer is completed through a task pole scheduler realized based on Kubernetes schedu ler framework. When there are compute nodes in the cluster that satisfy the schedule Pods, the task Pod scheduler will update the Partyresource resource state to a reserved state, where the Pods only reserves resources but will not bind to a particular compute node. When the number of participants of the reserved resources is larger than a predetermined threshold (minReservedMembers), the group controller changes the PartyResource resource state of the participants to a schedulable state, and then the task Pod scheduler binds (schedules) the task Pod to a specific computing node.
3) The synchronization of the states of the Pods and PartyResource resources crossing the clusters is realized through the synchronization controller, so that the first party and other parties can be guaranteed to finish the collaborative scheduling of the Pods under each cluster.
Corresponding to the above-mentioned cross-cluster privacy computing task execution method, an embodiment of the present disclosure further provides a cross-cluster privacy computing task execution device, which is disposed on the first party. As shown in fig. 3, the apparatus may include:
the creating unit 302 is configured to obtain description information of the privacy computing task, and create, according to the description information, first and second resources for running the privacy computing task under first and second namespaces corresponding to the first and second parties in a first Kubernetes cluster corresponding to the first party, where the first resource includes a first Pod group and a first state, and the second resource includes a second Pod group and a second state. A synchronization mechanism is established between the second namespace and the second party.
And the synchronization unit 304 is configured to synchronize the second resource to a second Kubernetes cluster corresponding to the second party through a synchronization mechanism.
A setting unit 306, configured to set a value of the first state to a reserved state when it is determined that there is a first computing node in the first Kubernetes cluster whose resource condition meets the target requirement in the description information.
In one embodiment, the target requirement includes that the number of Pod of the successfully reserved resources for the first Pod group is not less than a Pod number threshold.
The obtaining unit 308 is further configured to obtain the value of the second state from the second party through a synchronization mechanism.
An updating unit 310, configured to update the values of the first and second states to the schedulable states if they are determined to be reserved states.
The scheduling unit 312 is configured to schedule the first Pod group to the first computing node to execute the privacy computing task in response to the value of the first state being a schedulable state.
In one embodiment, the updating unit 310 is further configured to update, under the second namespace, task Pod state changes acquired from the second party, which indicates that the second Pod group is scheduled, through a synchronization mechanism.
The synchronization unit 304 is further configured to synchronize, by a synchronization mechanism, the updated value of the second state into the second Kubernetes cluster.
In one embodiment, a second synchronous controller corresponding to a second party is deployed in a second Kubernetes cluster;
the synchronization mechanism is established by the following steps: the second synchronization controller subscribes to the resource changes under the second namespace from the synchronization unit 304.
In one embodiment, the synchronization unit 304 is specifically configured to:
and monitoring to create a second resource, and sending the second resource to a second synchronous controller, so that the second synchronous controller creates the received second resource under the naming space of a second party in the second Kubernetes cluster.
In one embodiment, the updating unit 310 is specifically configured to:
and updating the values of the first and second states to a schedulable state if the values of the first and second states are monitored to be reserved and the number of participants of the reserved resources is determined to be greater than a predetermined threshold.
In one embodiment of the present invention, in one embodiment,
the setting unit 306 is further configured to, when the timing is determined to reach the preset duration and the values of the first state and the second state are not monitored to be schedulable states, set the value of the first state to be a failure state;
the synchronization unit 304 is further configured to set the value of the second state to a failure state through a synchronization mechanism.
In one embodiment, the updating unit 310 is further configured to, in a case where the timer is determined to reach the first preset duration and the value of the second state is not monitored to be the reserved state, set the values of the first and second states to be the reserved resource failure state;
the synchronization unit 304 is further configured to synchronize, by a synchronization mechanism, the updated value of the second state into the second Kubernetes cluster.
In one embodiment, the updating unit 310 is further configured to, in a case where the timer is determined to reach the second preset duration and the values of the first and second states are not monitored to be set to the schedulable state, set the values of the first and second states to the failed state;
The synchronization unit 304 is further configured to synchronize, by a synchronization mechanism, the updated value of the second state into the second Kubernetes cluster.
In one embodiment, the description information of the privacy calculation task includes first Pod information and second Pod information; the creation unit 302 is specifically configured to:
setting a scheduler name field in the first Pod information as a unit identifier of a scheduling unit 312, so that the first Pod group is scheduled by the scheduling unit 312;
the scheduler name field in the second party's information is set to other identification so that the second Pod group is not scheduled by the scheduling unit 312.
The functions of the functional units of the apparatus in the foregoing embodiments of the present disclosure may be implemented by the steps of the foregoing method embodiments, so that the specific working process of the apparatus provided in one embodiment of the present disclosure is not repeated herein.
According to the cross-cluster privacy computing task execution device provided by the embodiment of the specification, the privacy computing task can be efficiently and accurately executed among a plurality of participants respectively corresponding to different Kubernetes clusters, and the utilization rate of cluster resources and the execution efficiency of the privacy computing task can be improved.
Corresponding to the above cross-cluster privacy computing task execution method, an embodiment of the present disclosure further provides a cross-cluster privacy computing task execution device, which is disposed on the second party. As shown in fig. 4, the apparatus may include:
A creating unit 402, configured to create, under a synchronization mechanism established between the second party and a second namespace, a second resource acquired from the first party under a namespace corresponding to the second party in a second Kubernetes cluster corresponding to the second party, where the second resource includes a second Pod group and a second state, and the second namespace is a namespace created for the second party in the first Kubernetes cluster corresponding to the first party.
A setting unit 404, configured to set a value of the second state to a reserved state when it is determined that there is a second computing node in the second Kubernetes cluster, where a resource condition meets a target requirement in the description information of the privacy computing task.
A synchronization unit 406, configured to synchronize the value of the second state into the first Kubernetes cluster through a synchronization mechanism.
An updating unit 408, configured to update the value of the second state to the schedulable state through a synchronization mechanism.
The scheduling unit 410 is configured to schedule the second Pod group to the second computing node to perform the privacy computing task in response to the value of the second state being a schedulable state.
The functions of the functional units of the apparatus in the foregoing embodiments of the present disclosure may be implemented by the steps of the foregoing method embodiments, so that the specific working process of the apparatus provided in one embodiment of the present disclosure is not repeated herein.
According to the cross-cluster privacy computing task execution device provided by the embodiment of the specification, the privacy computing task can be efficiently and accurately executed among a plurality of participants respectively corresponding to different Kubernetes clusters, and the utilization rate of cluster resources and the execution efficiency of the privacy computing task can be improved.
According to an embodiment of another aspect, there is also provided a computer-readable storage medium having stored thereon a computer program which, when executed in a computer, causes the computer to perform the method described in connection with fig. 2.
According to an embodiment of yet another aspect, there is also provided a computing device including a memory having executable code stored therein and a processor that, when executing the executable code, implements the method described in connection with fig. 2.
In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for medium or device embodiments, the description is relatively simple as it is substantially similar to method embodiments, with reference to the description of method embodiments in part.
The foregoing describes specific embodiments of the present disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can 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 are also possible or may be advantageous.
The foregoing detailed description of the embodiments has further described the objects, technical solutions and advantages of the present specification, and it should be understood that the foregoing description is only a detailed description of the embodiments of the present specification, and is not intended to limit the scope of the present specification, but any modifications, equivalents, improvements, etc. made on the basis of the technical solutions of the present specification should be included in the scope of the present specification.
Claims (15)
1. A cross-cluster privacy computing task execution method relates to a first party and a second party, which respectively correspond to a first Kubernetes cluster and a second Kubernetes cluster; the method is performed by the first party and comprises:
Acquiring description information of a privacy computing task, and respectively creating first and second resources for running the privacy computing task under a first naming space and a second naming space corresponding to the first and second parties in the first Kubernetes cluster according to the description information, wherein the first resources comprise a first Pod group and a first state; the second resource includes a second Pod group and a second state; a synchronization mechanism is established between the second naming space and the second party;
synchronizing the second resource into the second Kubernetes cluster through the synchronization mechanism;
when a first computing node of which the resource condition meets the target requirement in the description information exists in the first Kubernetes cluster, setting the value of the first state into a reserved state;
acquiring a value of the second state from the second party through the synchronization mechanism;
updating both the first and second states to a schedulable state if it is determined that the values are both reserved;
and in response to the value of the first state being a schedulable state, scheduling the first Pod group to the first computing node to perform the privacy computing task.
2. The method of claim 1, further comprising:
and updating task Pod state changes acquired from the second party under the second namespace by the synchronization mechanism, wherein the task Pod state changes indicate that the second Pod group is scheduled.
3. The method of claim 1, wherein after said updating each to a schedulable state, further comprising:
and synchronizing the updated value of the second state into the second Kubernetes cluster through the synchronization mechanism.
4. The method of claim 1, wherein a first synchronization controller corresponding to the first party is deployed in the first Kubernetes cluster, and a second synchronization controller corresponding to the second party is deployed in the second Kubernetes cluster; the synchronization mechanism is established by the following steps:
the second synchronous controller subscribes to the resource change under the second naming space from the first synchronous controller.
5. The method of claim 4, wherein the synchronizing the second resource into the second Kubernetes cluster comprises:
the first synchronous controller monitors that the second resource is created, and sends the second resource to the second synchronous controller, so that the second synchronous controller creates the received second resource under the naming space of the second party in the second Kubernetes cluster.
6. The method of claim 1, wherein a first set of controllers corresponding to the first party are deployed in the first Kubernetes cluster; the updating of each of them to a schedulable state includes:
the first set of controllers listens to set the values of the first and second states to a reserved state and updates the values of the first and second states to a schedulable state if it is determined that the number of participants of the reserved resource is greater than a predetermined threshold.
7. The method of claim 1, wherein a first set of controllers corresponding to the first party are deployed in the first Kubernetes cluster; after the setting the value of the first state to the reserved state, the method further comprises:
the first group of controllers determine that the timing reaches a first preset duration, and set the values of the first state and the second state as reserved resource failure states under the condition that the values of the second state are not monitored to be reserved;
the method further comprises the steps of:
and synchronizing the updated value of the second state into the second Kubernetes cluster through the synchronization mechanism.
8. The method of claim 1, wherein a first set of controllers corresponding to the first party are deployed in the first Kubernetes cluster; after the setting the value of the first state to the reserved state, the method further comprises:
The first group of controllers determine that the timing reaches a second preset duration, and set the values of the first state and the second state as failure states under the condition that the values of the first state and the second state are not monitored to be set as schedulable states;
the method further comprises the steps of:
and synchronizing the updated value of the second state into the second Kubernetes cluster through the synchronization mechanism.
9. The method of claim 1, wherein a first task Pod scheduler corresponding to the first party is deployed in the first Kubernetes cluster; the description information comprises first Pod information and second Pod information;
the creating of the first and second resources for running the privacy computing task, respectively, includes:
setting a scheduler name field in the first Pod information as a first identifier of the first task Pod scheduler, so that the first Pod group schedules through the first task Pod scheduler;
and setting the name of the scheduler in the second Pod information as other identifiers, so that the second Pod group is not scheduled by the first task Pod scheduler.
10. The method of claim 1, wherein the target requirement comprises a number of Pod of successfully reserved resources for the first Pod group not less than a Pod number threshold.
11. A cross-cluster privacy computing task execution method relates to a first party and a second party, which respectively correspond to a first Kubernetes cluster and a second Kubernetes cluster; the method is performed by the second party and comprises:
creating a second resource acquired from the first party under a namespace corresponding to the second party in the second Kubernetes cluster through a synchronization mechanism established between the second party and the second namespace, wherein the second resource comprises a second Pod group and a second state; the second namespace is a namespace created for the second party in the first Kubernetes cluster;
when a second computing node with a resource condition meeting the target requirement in the description information exists in the second Kubernetes cluster, setting the value of the second state to be a reserved state;
synchronizing the value of the second state into the first Kubernetes cluster through the synchronization mechanism;
updating the value of the second state to a schedulable state through the synchronization mechanism;
and in response to the value of the second state being a schedulable state, scheduling the second Pod group to the second computing node to perform the privacy computing task.
12. A cross-cluster privacy computing task execution device disposed on a first party, the device comprising:
the creating unit is used for acquiring description information of the privacy computing task, and respectively creating first and second resources for running the privacy computing task under first and second namespaces corresponding to the first and second parties in a first Kubernetes cluster corresponding to the first party according to the description information, wherein the first resources comprise a first Pod group and a first state; the second resource includes a second Pod group and a second state; a synchronization mechanism is established between the second naming space and the second party;
the synchronization unit is used for synchronizing the second resource into a second Kubernetes cluster corresponding to the second party through the synchronization mechanism;
the setting unit is used for setting the value of the first state to be a reserved state when determining that a first computing node exists in the first Kubernetes cluster and the resource condition meets the target requirement in the description information;
an obtaining unit, configured to obtain, from the second party, a value of the second state through the synchronization mechanism;
an updating unit configured to update, in a case where it is determined that the values of the first and second states are both reserved states, both of them to schedulable states;
And the scheduling unit is used for scheduling the first Pod group to the first computing node to execute the privacy computing task in response to the value of the first state being a schedulable state.
13. A cross-cluster privacy computing task execution device disposed on a second party, comprising:
the creating unit is configured to create, by using a synchronization mechanism established between the second party and a second namespace, a second resource acquired from the first party under the namespace corresponding to the second party in a second Kubernetes cluster corresponding to the second party, where the second resource includes a second Pod group and a second state; the second namespace is a namespace created for the second party in a first Kubernetes cluster corresponding to the first party;
the setting unit is used for setting the value of the second state to be a reserved state when determining that a second computing node exists in the second Kubernetes cluster and the resource condition meets the target requirement in the description information;
a synchronization unit, configured to synchronize, by using the synchronization mechanism, the value of the second state into the first Kubernetes cluster;
an updating unit, configured to update, by using the synchronization mechanism, the value of the second state to a schedulable state;
And the scheduling unit is used for scheduling the second Pod group to the second computing node to execute the privacy computing task in response to the value of the second state being a schedulable state.
14. A computer readable storage medium having stored thereon a computer program, wherein the computer program, when executed in a computer, causes the computer to perform the method of any of claims 1-11.
15. A computing device comprising a memory and a processor, wherein the memory has executable code stored therein, which when executed by the processor, implements the method of any of claims 1-11.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311076224.6A CN117134960A (en) | 2023-08-24 | 2023-08-24 | Cross-cluster privacy computing task execution method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311076224.6A CN117134960A (en) | 2023-08-24 | 2023-08-24 | Cross-cluster privacy computing task execution method and device |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117134960A true CN117134960A (en) | 2023-11-28 |
Family
ID=88855860
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311076224.6A Pending CN117134960A (en) | 2023-08-24 | 2023-08-24 | Cross-cluster privacy computing task execution method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117134960A (en) |
-
2023
- 2023-08-24 CN CN202311076224.6A patent/CN117134960A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN102521044B (en) | Distributed task scheduling method and system based on messaging middleware | |
| CN106817408B (en) | Distributed server cluster scheduling method and device | |
| WO2019104713A1 (en) | Machine learning method, master node, work node, and system | |
| CN106126332A (en) | Distributed timing task scheduling system and method | |
| CN105468450A (en) | Task scheduling method and system | |
| EP3312723B1 (en) | Command processing method and server | |
| WO2021057514A1 (en) | Task scheduling method and apparatus, computer device, and computer readable medium | |
| CN110611707B (en) | Task scheduling method and device | |
| CN109062681A (en) | A kind of execution method, system, device and the storage medium of periodic cycle task | |
| CN107623731A (en) | A kind of method for scheduling task, client, service cluster and system | |
| CN110134533B (en) | System and method capable of scheduling data in batches | |
| CN106412088B (en) | Data synchronization method and terminal | |
| CN110569113A (en) | Method and system for scheduling distributed tasks and computer readable storage medium | |
| CN104410511A (en) | Server management method and system | |
| Pedarsani et al. | Scheduling tasks with precedence constraints on multiple servers | |
| CN111049900B (en) | Internet of things flow calculation scheduling method and device and electronic equipment | |
| CN103152428A (en) | Method for carrying out service communication among nodes on cloud platform | |
| CN112506658A (en) | Dynamic resource allocation and task scheduling method in service chain | |
| CN117134960A (en) | Cross-cluster privacy computing task execution method and device | |
| WO2016197858A1 (en) | Method and device for message notification | |
| CN110750362A (en) | Method and apparatus for analyzing biological information, and storage medium | |
| JP2013020440A (en) | Software license management system | |
| US20230266994A1 (en) | Migration of computational units in distributed networks | |
| CN113919821A (en) | Service transfer method, device, computer equipment and storage medium | |
| CN109634749B (en) | Distributed unified scheduling method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |