Private task scheduling method and device, equipment, storage medium and product

Abstract

The invention discloses a privacy task scheduling method and device, equipment, a storage medium and a product, and relates to the technical field of computers.The privacy task scheduling method comprises the steps that after a privacy task operation request is received, the privacy task operation request is split into a plurality of privacy subtasks in sequence; mapping the privacy subtasks to corresponding task container mirror images; and scheduling the task container mirror image to different privacy computing platforms to execute the privacy task. According to the method, the private task is decomposed into the independent sub-tasks, each sub-task of the appropriate type is dispatched to the appropriate platform through the task container mirror image, the resource characteristics of each platform can be fully utilized, resource waste is avoided, the overall task execution time is shortened, and the private task processing efficiency is improved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to privacy task scheduling methods, devices, equipment, storage media and products. Background Art

[0002] With the rapid development of information technology, privacy-preserving computing has become a key area for ensuring data security and privacy protection. The core goal of privacy-preserving computing is to enable data sharing and collaborative computing without leaking the original data.

[0003] However, existing technologies still face a number of challenges when handling privacy-related tasks. For example, existing privacy computing platforms are often tailored for specific application scenarios, with closed technical architectures and interfaces, making them difficult to adapt to external expansion and cross-platform collaboration. Different privacy computing platforms use different algorithms and protocols, lacking unified standards and interfaces, and lack a unified scheduling mechanism. This makes it difficult for data and tasks to flow between different platforms, limiting the optimal allocation of resources and the efficient execution of tasks. Furthermore, it is difficult to dynamically adjust the number of services based on task load, resulting in low efficiency in handling privacy-related tasks. Summary of the Invention

[0004] The main purpose of this application is to provide a privacy task scheduling method, device, equipment, storage medium and product, aiming to solve the technical problem of low processing efficiency of privacy tasks.

[0005] To achieve the above objectives, this application proposes a privacy task scheduling method, which includes:

[0006] After receiving a privacy task job request, split the privacy task job request into a number of privacy subtasks in a certain order;

[0007] Mapping the privacy subtask to the corresponding task container image;

[0008] Schedule the task container image to different privacy computing platforms to perform privacy tasks.

[0009] In one embodiment, the step of splitting the privacy task job request into a plurality of privacy subtasks in a sequential order includes:

[0010] Parsing the privacy task job request and determining the input and output relationships between components;

[0011] Sort the input and output relationships between the components to determine the order in which the components are executed;

[0012] Based on the execution order of the components, the privacy task job request is split into a number of privacy subtasks with a sequence.

[0013] In one embodiment, the step of mapping the privacy subtask to the corresponding task container image includes:

[0014] Query the algorithm type, participant role attributes, and security strength requirements for each privacy subtask;

[0015] According to the algorithm type, match the task container image corresponding to each privacy subtask from the preset container image library;

[0016] Constructing task variable information based on the role attributes and security strength requirements of the participants;

[0017] Inject the task variable information into the corresponding task container image.

[0018] In one embodiment, the step of scheduling the task container image to different privacy computing platforms to perform the privacy task includes:

[0019] Get the container image of the task to be executed;

[0020] According to the preset scheduling rules, the task container images are scheduled to different privacy computing platforms and the tasks are started synchronously, wherein each task container image is isolated from each other;

[0021] Monitor the task execution status of participating task container images.

[0022] In one embodiment, the step of monitoring the task execution status of all participants includes:

[0023] Get the task execution status of the participating task container image;

[0024] When an abnormal situation occurs, the preset countermeasures are executed according to the abnormality type;

[0025] If the exception type is a container crash or exceeding resource limits, the abnormal container will be automatically restarted;

[0026] If the exception type is caused by program or algorithm parameters, the error log is sent to the preset database.

[0027] In one embodiment, after receiving the privacy task job request, before the step of splitting the privacy task job request into a plurality of privacy subtasks in a sequential order, the step includes:

[0028] Encapsulate the algorithm logic into the corresponding task container image and upload it to the container image library;

[0029] Register the container image information corresponding to the task container image to each privacy computing platform.

[0030] In addition, to achieve the above-mentioned purpose, the present application also proposes a privacy task scheduling device, which includes: a splitting module, which is used to split the privacy task job request into a plurality of privacy subtasks in a certain order after receiving the privacy task job request;

[0031] A mapping module, configured to map the privacy subtask to a corresponding task container image;

[0032] A distribution module is used to schedule the task container image to different privacy computing platforms to perform privacy tasks.

[0033] In addition, to achieve the above-mentioned purpose, the present application also proposes a privacy task scheduling device, which includes: a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the computer program is configured to implement the steps of the privacy task scheduling method described above.

[0034] In addition, to achieve the above-mentioned purpose, the present application also proposes a storage medium, which is a computer-readable storage medium. A computer program is stored on the storage medium, and when the computer program is executed by the processor, the steps of the privacy task scheduling method described above are implemented.

[0035] In addition, to achieve the above-mentioned purpose, the present application also provides a computer program product, which includes a computer program, and when the computer program is executed by a processor, it implements the steps of the privacy task scheduling method described above.

[0036] One or more technical solutions proposed in this application have at least the following technical effects:

[0037] In contrast to related technologies, different privacy computing platforms use different algorithms and protocols, lack unified standards and interfaces, and lack a unified scheduling mechanism. This makes it difficult for data and tasks to flow between different platforms, limiting the optimal allocation of resources and the efficient execution of tasks. Furthermore, it is difficult to dynamically adjust the number of services based on task load, resulting in low processing efficiency for privacy tasks. In contrast, this application decomposes privacy tasks into multiple independent subtasks and schedules each subtask of the appropriate type to the appropriate platform through a task container image. This fully utilizes the resource characteristics of each platform, avoids resource waste, shortens overall task execution time, and improves the efficiency of privacy task processing. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0039] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, for ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0040] Figure 1 A flowchart of the first embodiment of the privacy task scheduling method of this application is provided;

[0041] Figure 2 A flowchart of the second embodiment of the privacy task scheduling method of this application is provided;

[0042] Figure 3 A brief flowchart of the privacy task scheduling method provided in Example 2 of this application;

[0043] Figure 4 This is a schematic diagram of the module structure of the privacy task scheduling device according to an embodiment of the present application;

[0044] Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the privacy task scheduling method in the embodiment of the present application.

[0045] The purpose, features and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. DETAILED DESCRIPTION

[0046] It should be understood that the specific embodiments described herein are merely used to explain the technical solutions of the present application and are not intended to limit the present application.

[0047] In order to better understand the technical solution of the present application, a detailed description will be given below in conjunction with the accompanying drawings and specific implementation methods.

[0048] The main solutions of the embodiments of this application are:

[0049] After receiving a privacy task job request, split the privacy task job request into a number of privacy subtasks in a certain order;

[0050] Mapping the privacy subtask to the corresponding task container image;

[0051] Schedule the task container image to different privacy computing platforms to perform privacy tasks.

[0052] In this embodiment, this application uses a privacy task scheduling device as the execution entity. For the sake of convenience, it is specifically described below as "device".

[0053] Because existing privacy computing platforms are often tailored for specific application scenarios, their technical architectures and interfaces are closed, making them difficult to adapt to external expansion and cross-platform collaboration. Different privacy computing platforms use different algorithms and protocols, lacking unified standards and interfaces, and lack a unified scheduling mechanism. This makes it difficult for data and tasks to flow between different platforms, limiting the optimal allocation of resources and the efficient execution of tasks. It also makes it difficult to dynamically adjust the number of services based on task load, resulting in low processing efficiency for privacy tasks.

[0054] This application provides a solution. By decomposing privacy tasks into multiple independent subtasks and scheduling each subtask of the appropriate type to the appropriate platform through a task container image, this application can fully utilize the resource characteristics of each platform, avoid resource waste, thereby shortening the overall task execution time and improving the efficiency of privacy task processing.

[0055] Based on this, the embodiment of the present application provides a privacy task scheduling method, referring to Figure 1 , Figure 1 This is a flow chart of the first embodiment of the privacy task scheduling method of this application.

[0056] In this embodiment, the privacy task scheduling method includes steps S10 to S30:

[0057] Step S10: After receiving the privacy task operation request, split the privacy task operation request into a plurality of privacy subtasks in a certain order;

[0058] It should be noted that a privacy-preserving task job request refers to a request that includes specific privacy-preserving computing requirements, requiring the execution of a series of computing tasks while protecting data privacy. It typically includes input data, expected computational results, and privacy-preserving parameters.

[0059] The privacy subtask is a single or multiple task units after the privacy task job request is split. Each subtask has clear input, processing logic and output, and has a specific execution order in the overall task.

[0060] The sequence refers to the specific order that privacy subtasks need to follow during execution. This order is determined by the dependencies between tasks to ensure the correct flow of data and the correct execution of calculations.

[0061] As you can see, the device first receives a privacy-preserving task request, which contains a computational task to be completed in a privacy-preserving environment. After receiving the privacy-preserving task request, the device then breaks it down into a number of sequentially executed privacy-preserving subtasks. This allows complex tasks to be broken down into smaller, more manageable components, while ensuring that the execution order of each subtask complies with the logical requirements of the overall task.

[0062] For example, the system receives a job request submitted by a user, which includes the algorithm parameters and input-output relationships for each component. The request is then parsed to determine the job requirements, task type, and required algorithm components. Based on the detailed configuration in the job, such as the algorithm parameters and input-output relationships for each component, the system then splits the job into multiple, sequentially ordered subtasks.

[0063] In a feasible implementation, step S10 may include:

[0064] Parsing the privacy task job request and determining the input and output relationships between components;

[0065] Sort the input and output relationships between the components to determine the order in which the components are executed;

[0066] Based on the execution order of the components, the privacy task job request is split into a number of privacy subtasks with a sequence.

[0067] It should be noted that the input-output relationship between components refers to the description of the data flow and dependencies between various components (such as algorithms or data processing steps) in a privacy task job request. The output of each component may serve as the input of another component. These relationships define the order and dependencies of component execution.

[0068] The order in which components are executed is determined by the data dependencies between them. This order ensures that when executing privacy tasks, the execution of any component is not hindered by the lack of necessary input data.

[0069] As you can understand, the device first parses the privacy task job request, identifying all components included in the request, their functions, and requirements. Based on this parsing, the device further determines the data flows and dependencies between components. This includes identifying which components' outputs require the inputs of other components, and which components can execute independently or in parallel.

[0070] Based on the data dependencies between components, the device sorts the order in which the components are executed.

[0071] Finally, based on the determined order of component execution, the device splits the privacy task job request into several privacy subtasks with a clear order. These subtasks are further mapped to corresponding task container images and executed on the privacy computing platform.

[0072] Specifically, the scheduling API (Application Programming Interface) parses the user's request and identifies the required computing resources and algorithms. Once the job is received, the scheduler optimizer splits the job into a number of sequential tasks based on the Directed Acyclic Graph (DAG) configuration in the request, which describes the component assembly process.

[0073] Specifically, refer to Figure 2 After the job interface is called, the entire task scheduling and management process will gradually unfold. First, the SchedulerOptimizer will perform a detailed analysis based on the job configuration to determine the dependencies and execution order between tasks. The specific implementation steps are as follows:

[0074] Resolve dependencies between components based on the DAG configuration (part of the job configuration);

[0075] The order of tasks is obtained by arranging the components based on the relationship between input and output. The input of the first component is the original data, the input data of the second component is the output data of the first component, and so on.

[0076] In this embodiment, the privacy task job request is split into several privacy subtasks with a sequence, ensuring that the tasks in the privacy job can be executed in the correct order, thereby avoiding resource conflicts or execution errors.

[0077] Step S20: Map the privacy subtask to the corresponding task container image;

[0078] It should be noted that the task container image is an executable software package that contains the code, runtime environment, libraries, environment variables, and configuration files required to run a specific privacy subtask. Container images are designed for rapid and consistent deployment and execution across various computing environments.

[0079] It is understandable that the device first identifies the various subtasks in the privacy task job request. These subtasks may be divided based on data flow, computing requirements or business logic. For each privacy subtask, the device needs to select a suitable task image from the preset container image library. This selection process is based on the technical requirements of the subtask, including the algorithm type, the role attributes of the participants and the security strength requirements. According to the specific requirements of the privacy subtask, the device constructs the task variable information, which may include environment variables, configuration parameters or other data required for runtime. The constructed task variable information is injected into the corresponding task container image, ensuring that the container image can receive the correct parameters and configurations when it is started, so that the privacy subtask can be executed correctly.

[0080] After mapping is complete, the task container image is scheduled for execution on different privacy-preserving computing platforms. This scheduling process takes into account resource optimization, load balancing, and privacy protection requirements. The entire mapping and execution process emphasizes privacy protection and security, ensuring that all subtasks are executed in an environment that meets privacy and security standards.

[0081] In a feasible implementation, step S20 may include:

[0082] Query the algorithm type, participant role attributes, and security strength requirements for each privacy subtask;

[0083] According to the algorithm type, match the task container image corresponding to each privacy subtask from the preset container image library;

[0084] Constructing task variable information based on the role attributes and security strength requirements of the participants;

[0085] Inject the task variable information into the corresponding task container image.

[0086] It should be noted that the algorithm type refers to the specific algorithm or computational logic required to execute within a privacy-preserving subtask. This may include, but is not limited to, encryption algorithms, data mining algorithms, and machine learning models. Each algorithm type has specific functions and application scenarios. The participant role attributes describe the roles and permissions of each participant in a privacy-preserving computing task (e.g., data provider, computation provider, result user, etc.). These attributes determine each party's behavior within the task and their level of access to data.

[0087] The security strength requirements refer to a series of standards and requirements established to ensure the security and data protection of privacy subtasks. This includes specifications for security measures such as encryption levels, access control, and data isolation. The task container image library stores a collection of pre-set container images that can be used to execute different privacy subtasks. Each image contains the environment and dependencies required to execute a specific algorithm. The task variable information refers to the parameters and environment variables required to execute a specific privacy subtask. This information may include algorithm parameters, security settings, input and output data paths, etc.

[0088] For example, refer to Figure 2 Once the execution order of tasks is determined, the TaskScheduler (scheduling executor) takes over the specific execution process of the tasks. The TaskScheduler is responsible not only for starting and stopping tasks but also for real-time monitoring and synchronization of task status. It ensures that task status is always accurately updated and consistent with the status of components in other node systems through polling interface queries or active component reporting.

[0089] When starting a task, TaskScheduler calls multiple underlying clients, including K8s Client (k8s scheduler), Docker Client (image scheduler), and MySQL Client (database scheduler). K8s Client is primarily responsible for interacting with the Kubernetes cluster, deploying tasks to the cluster in the form of Pods, and selecting appropriate nodes to run these Pods based on resource requirements and scheduling strategies. Docker Client is responsible for handling container-level operations, such as pulling the Docker image required for the task. MySQL Client is used to store the execution status of the task and other related information in the database in real time, thereby providing data support for subsequent monitoring and analysis.

[0090] Specifically, considering the characteristics of each platform as well as the attributes and requirements of the task, the subtasks in sequence are mapped to the corresponding platform or algorithm components.

[0091] Specifically, when creating a cloud-native container, the task variable information constructed in real time is dynamically injected into the container. The entire process does not require manual intervention, which improves the efficiency of computing task operations under the premise of multi-party collaboration.

[0092] Step S30: Schedule the task container image to different privacy computing platforms to execute the privacy task.

[0093] It should be noted that a privacy-preserving computing platform is a computing environment specifically designed to perform privacy-preserving computing tasks, providing the necessary hardware and software resources to support the operation of privacy-preserving algorithms and data processing. These platforms can ensure that personal or sensitive information is not leaked during data processing and analysis.

[0094] Privacy tasks are computing tasks that must be completed while protecting data privacy. These tasks typically involve processing sensitive data and require the use of encryption, anonymization, or other privacy-preserving technologies to comply with data protection regulations and standards.

[0095] As you can understand, the scheduling process begins by obtaining the task container images to be executed. These images already contain all the information and dependencies required to execute a specific privacy subtask. Based on preset scheduling rules, the device determines which privacy computing platform to assign each task container image to. These rules may be based on factors such as resource availability, task priority, expected execution time, platform load, and privacy protection requirements. The scheduling system ensures that each task container image can be launched synchronously on its assigned privacy computing platform and is isolated from other task container images to protect the independence of task execution and data privacy.

[0096] The privacy computing platform plays a key role in the scheduling process, providing the computing resources and privacy protection environment required to perform privacy tasks. A variety of privacy protection technologies may be deployed on the platform, such as homomorphic encryption, secure multi-party computing (SMPC) or blockchain technology, to ensure privacy security during data processing. After the task container image is scheduled and started, the device monitors the execution status of each participating task container image to ensure that the task proceeds as planned and any anomalies are detected and handled in a timely manner. The monitoring process includes obtaining the task execution status, identifying anomalies, and executing preset countermeasures based on the anomaly type, such as automatically restarting crashed containers or sending error logs to a database.

[0097] In a feasible implementation, step S30 may include:

[0098] Get the container image of the task to be executed;

[0099] According to the preset scheduling rules, the task container images are scheduled to different privacy computing platforms and the tasks are started synchronously, wherein each task container image is isolated from each other;

[0100] Monitor the task execution status of participating task container images.

[0101] It should be noted that the preset scheduling rules are a set of predefined rules designed to optimize resource utilization, ensure task execution order, and meet privacy protection requirements. These rules may include task priority, resource allocation strategy, execution time window, privacy protection level, etc., and are used to guide scheduling decisions for task container images.

[0102] Isolation between task container images means that during execution, each task container image runs independently, without sharing environments or data with other container images. This ensures task independence and data isolation. This isolation helps prevent data leakage and unauthorized access, enhancing system security.

[0103] The task execution status refers to the real-time status of the task container image during execution, including status such as start, run, complete, and fail. Monitoring the task execution status helps to promptly identify and resolve problems during execution, ensuring the smooth progress of the task.

[0104] As you can understand, during the execution of a privacy-preserving computing task, the device first needs to identify and retrieve task container images that are ready and awaiting execution. The device then distributes these task container images to different privacy-preserving computing platforms based on pre-defined scheduling rules. These rules ensure that tasks are executed in the optimal environment, taking into account resource optimization, execution efficiency, and privacy protection requirements. Task container images are launched synchronously to ensure that all related tasks proceed in a coordinated and consistent manner.

[0105] During execution, each task container image runs independently and is isolated from other container images. This isolation, achieved through container technology, ensures task independence and data security, preventing data leakage and cross-contamination. The device continuously monitors the execution status of participating task container images to ensure that tasks proceed as planned. This monitoring process includes obtaining real-time task status information and responding to anomalies with pre-defined countermeasures, such as restarting failed tasks or logging errors.

[0106] For example, refer to Figure 2 The TaskScheduler (scheduling executor) continuously monitors the running status of each task, including whether the task started normally, encountered any exceptions, and completed successfully. Status is obtained in two ways: one is to actively query the pod status through the K8s interface, and the other is for the algorithm component to actively report the status through the agreed interface. Once the task status changes, the TaskScheduler immediately synchronizes these changes to the system database. This real-time status synchronization mechanism ensures that the system can obtain the latest status of the task at any time and trigger corresponding subsequent operations as needed, such as task retry and resource recycling.

[0107] Specifically, the system uses the Kubernetes API to launch the corresponding Pod to execute the subtask. Each Pod runs an independent task container image, ensuring that the task is executed in an isolated environment with clear resource limits.

[0108] In a feasible implementation manner, the step of monitoring the task execution status of all participants includes:

[0109] Get the task execution status of the participating task container image;

[0110] When an abnormal situation occurs, the preset countermeasures are executed according to the abnormality type;

[0111] If the exception type is a container crash or exceeding resource limits, the abnormal container will be automatically restarted;

[0112] If the exception type is caused by program or algorithm parameters, the error log is sent to the preset database.

[0113] It should be noted that the task execution status refers to the specific status of the task container image during execution, including but not limited to the task's start, running, completion, or failure status. An exception refers to any unexpected event that occurs during task execution, such as system errors, insufficient resources, or external interference, which can cause task execution to be interrupted or fail. The exception type is a classification based on the nature and cause of the exception, which is used to determine the appropriate pre-defined countermeasures.

[0114] Preset countermeasures refer to pre-defined processing measures for specific types of abnormal situations. These countermeasures are designed to respond to abnormalities quickly to minimize the impact on system performance and task execution. Container crash refers to a situation where a task container image terminates unexpectedly during execution and is unable to continue the task. This may be caused by internal errors, resource exhaustion, or other serious problems. Resource limits refer to the upper limit of computing resources (such as CPU (central processing unit), memory, etc.) allocated to the task container image. Exceeding these limits will cause the container to be forcibly stopped or crashed by the system. Error logs refer to log files that record detailed information about abnormal situations, including but not limited to the type of exception, time, possible cause and impact, etc.

[0115] Specifically, the execution progress of each task is monitored in real time, and information such as task progress and resource usage is collected and analyzed through the K8s API interface or component active reporting. Coordinate the pace of task execution between different platforms to ensure that the entire job proceeds smoothly as expected. When a Pod crashes or exceeds resource limits, K8s will automatically restart the Pod or reschedule the task to other nodes for execution to ensure the self-healing ability of the task. If a fault or code anomaly occurs during task execution, the component container orchestration and management system must handle it in a timely manner, and synchronize the task status and query and report the error log according to the preset strategy. After all tasks are completed, the status results returned by each platform are summarized, the job status is merged and reported to complete the entire job process.

[0116] Specifically, refer to Figure 2 The scheduling executor will poll and call the k8s interface to obtain the pod status, and the polling query algorithm component will actively report the persisted task status. When there is an abnormal situation, there are two processing flows. One is when the pod crashes or exceeds the resource limit. The k8s third-party package provides a method parameter for automatic restart; the other is an exception caused by program or algorithm parameters, and the error log will be persisted to the database.

[0117] This embodiment provides a privacy task scheduling method. By decomposing a privacy task into multiple independent subtasks and scheduling each subtask of the appropriate type to the appropriate platform through a task container image, the resource characteristics of each platform can be fully utilized to avoid resource waste, thereby shortening the overall task execution time and improving the efficiency of privacy task processing.

[0118] In a feasible implementation manner, before step S10, the following steps may be included:

[0119] Encapsulate the algorithm logic into the corresponding task container image and upload it to the container image library;

[0120] Register the container image information corresponding to the task container image to each privacy computing platform.

[0121] It should be noted that container image information registration refers to the process of recording the metadata and related information of the task container image to the privacy computing platform. This includes the image name, version, algorithm type, security attributes, etc., so that the platform can identify and manage these images.

[0122] It is understandable that system developers encapsulate specific algorithm logic and all its dependencies (such as libraries, frameworks, environment variables, etc.) into a task container image. This process ensures that the algorithm can be executed in a consistent manner in different environments while maintaining the isolation and security of the environment. The encapsulated task container image is uploaded to a centralized container image library. This library can quickly retrieve and deploy images when needed. In order for the privacy computing platform to be able to identify and schedule these task container images, the relevant information of the image (such as name, version, algorithm description, security requirements, etc.) needs to be registered on the platform.

[0123] This approach ensures that the algorithmic logic of privacy-preserving computing tasks is consistently and securely executed across different privacy-preserving computing platforms. This encapsulation and registration mechanism improves the flexibility and scalability of algorithm deployment while ensuring the privacy and security of algorithm execution.

[0124] For example, to help understand the implementation process of the privacy task scheduling method obtained by combining this embodiment with the above embodiment 1, please refer to Figure 3 , Figure 3 This paper provides a brief flowchart of a privacy task scheduling method, specifically:

[0125] 1. Cloud native framework authentication enhancement:

[0126] The scheduling service, based on the underlying communication channel encryption, double-encrypts the configuration payload, implementing a multi-encryption verification mechanism with the cloud-native API server. Regarding verification, it uses a random selection method of certificates, keys, and tokens, based on a one-time password, single-selection random verification method to enhance the security of authorized user identity information.

[0127] 2. Runtime environment variable construction and dynamic injection:

[0128] The scheduling service automatically parses the task DAG and intelligently constructs the task runtime environment variables based on the roles of the computing participants and the security strength requirements. When creating a cloud-native container, the real-time constructed task variable information is dynamically injected into the container. The entire process does not require manual intervention, which improves the efficiency of computing task operations under the premise of multi-party collaboration.

[0129] 3. Optimize the creation and configuration of runtime container objects:

[0130] Build the corresponding mapped container name based on the unique identifier of the job task, set the runtime container port mapping according to the task parameter configuration, and dynamically configure the firewall policy to achieve two-way network path construction and block unauthorized network traffic.

[0131] Support for multiple volume mounting methods, including NFS volumes (Network File System), HostPath volumes, and S3 volumes (Simple Storage Service), enables runtime container data persistence and resource isolation between parallel containers, improving the reliability and flexibility of algorithm containers. Runtime container resource threshold parameters are generated based on the number of participants in the job task, the amount of computed data, the algorithm complexity, and the algorithm parameters, ensuring overall resource balance at the host level.

[0132] 4. High availability of runtime container objects:

[0133] The scheduling service customizes different restart strategies according to the priority of the job task, such as Never and OnFailure, and uses the cloud native V1 JobSpec specification to set the validity period, number of failed retries, TTL time, etc., to improve the flexibility and controllability of task scheduling.

[0134] The scheduling service can globally set the parallelism and sharding of job tasks at the cluster level. Based on the algorithm characteristics and task scale, it sets reasonable parallelism and sharding strategies to improve the efficiency and performance of task processing.

[0135] 5. Runtime container automated monitoring:

[0136] The scheduling service uses a customized cloud-native approach to submit runtime containers in the resource pool to the specified monitoring domain. The status and progress of job tasks in the target monitoring domain will be automatically collected, and after analysis by the monitoring model, runtime visualization and risk alerts will be provided.

[0137] 6. Automatic destruction of containers at runtime:

[0138] The runtime container created by the scheduling service is automatically destroyed after the computing task is completed. Container resources (including CPU, memory, and storage volumes) are reclaimed by the cloud native framework to prevent resource leakage and waste. Automatically destroyed tasks are also tracked and managed by the monitoring system.

[0139] It should be noted that the above examples are only used to understand this application and do not constitute a limitation on the privacy task scheduling method of this application. More simple transformations based on this technical concept are all within the scope of protection of this application.

[0140] This application also provides a privacy task scheduling device, please refer to Figure 4 , the privacy task scheduling device includes:

[0141] A splitting module 10 is configured to receive a privacy task job request and split the privacy task job request into a plurality of privacy subtasks in a sequential order;

[0142] A mapping module 20, configured to map the privacy subtask to a corresponding task container image;

[0143] The distribution module 30 is used to schedule the task container image to different privacy computing platforms to perform privacy tasks.

[0144] Optionally, the splitting module 10 includes:

[0145] A first parsing module is used to parse the privacy task job request and determine the input and output relationship between components;

[0146] A first sorting module is used to sort the input and output relationships between the components to determine the order in which the components are executed;

[0147] The first splitting module is used to split the privacy task job request into a plurality of privacy subtasks with a sequence based on the sequence of execution of the components.

[0148] Optionally, the mapping module 20 includes:

[0149] The first query module is used to query the algorithm type, participant role attributes and security strength requirements of each privacy subtask;

[0150] A first matching module is configured to match the task container image corresponding to each privacy subtask from a preset container image library according to the algorithm type;

[0151] A first construction module is used to construct task variable information according to the role attributes and security strength requirements of the participants;

[0152] The first injection module is used to inject the task variable information into the corresponding task container image.

[0153] Optionally, the distribution module 30 includes:

[0154] The first acquisition module is used to obtain the task container image to be executed;

[0155] A first scheduling module is used to schedule the task container images to different privacy computing platforms according to preset scheduling rules and to start the tasks synchronously, wherein each task container image is isolated from each other;

[0156] The first monitoring module is used to monitor the task execution status of the participating task container images.

[0157] Optionally, the first monitoring module includes:

[0158] The second acquisition module is used to obtain the task execution status of the participating task container image;

[0159] The first execution module is used to execute preset countermeasures according to the type of abnormality when an abnormality occurs;

[0160] The first restart module is used to automatically restart the abnormal container if the exception type is a container crash or exceeding resource limits;

[0161] The first sending module is used to send the error log to a preset database if the exception type is an exception caused by program or algorithm parameters.

[0162] Optionally, the privacy task scheduling device includes:

[0163] The first upload module is used to encapsulate the algorithm logic into the corresponding task container image and upload it to the container image library;

[0164] The first registration module is used to register the container image information corresponding to the task container image to each privacy computing platform.

[0165] The privacy task scheduling device provided in this application utilizes the privacy task scheduling method described in the aforementioned embodiments to address the technical issue of low privacy task processing efficiency. Compared to the prior art, the privacy task scheduling device provided in this application offers the same beneficial effects as the privacy task scheduling method described in the aforementioned embodiments. Other technical features of the privacy task scheduling device are the same as those disclosed in the aforementioned embodiments and are not further detailed here.

[0166] The present application provides a privacy task scheduling device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the privacy task scheduling method in the above-mentioned embodiment one.

[0167] Reference below Figure 5 , which shows a schematic diagram of the structure of a privacy task scheduling device suitable for implementing the embodiments of the present application. The privacy task scheduling device in the embodiments of the present application may include, but is not limited to, mobile terminals such as mobile phones, tablet computers, laptop computers, digital broadcast receivers, PDAs (Personal Digital Assistants), PMPs (Portable Media Players), in-vehicle terminals (such as in-vehicle navigation terminals), and fixed terminals such as digital televisions (Digital Televisions) and desktop computers. Figure 5The privacy task scheduling device shown is merely an example and should not limit the functions and scope of use of the embodiments of the present application.

[0168] like Figure 5 As shown, the privacy task scheduling device may include a processing device 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes based on programs stored in a read-only memory (ROM) 1002 or programs loaded from a storage device 1003 into a random access memory (RAM) 1004. RAM 1004 also stores various programs and data required for the operation of the privacy task scheduling device. Processing device 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to I / O interface 1006: input devices 1007 including, for example, a touch screen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage device 1003 including, for example, a magnetic tape, hard disk, etc.; and communication devices 1009. Communication device 1009 can allow the privacy task scheduling device to communicate with other devices wirelessly or wired to exchange data. Although the figure shows a privacy task scheduling device with various systems, it should be understood that it is not required to implement or have all of the systems shown. More or fewer systems may be implemented or have alternatively.

[0169] In particular, according to the embodiments disclosed in the present application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments disclosed in the present application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program comprising program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network via a communication device, or installed from a storage device 1003, or installed from a ROM 1002. When the computer program is executed by the processing device 1001, the above-mentioned functions defined in the method of the embodiment disclosed in the present application are executed.

[0170] The privacy task scheduling device provided in this application utilizes the privacy task scheduling method described in the aforementioned embodiment to address the technical issue of low privacy task processing efficiency. Compared to the prior art, the privacy task scheduling device provided in this application achieves the same beneficial effects as the privacy task scheduling method described in the aforementioned embodiment. Other technical features of the privacy task scheduling device are the same as those disclosed in the aforementioned embodiment and are not further detailed here.

[0171] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any one or more embodiments or examples in a suitable manner.

[0172] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

[0173] The present application provides a computer-readable storage medium having computer-readable program instructions (i.e., computer programs) stored thereon, and the computer-readable program instructions are used to execute the privacy task scheduling method in the above-mentioned embodiment.

[0174] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, systems or devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, 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 disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, system or device. The program code contained on the computer-readable storage medium may be transmitted using any appropriate medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0175] The above-mentioned computer-readable storage medium may be included in the privacy task scheduling device; or it may exist independently without being assembled into the privacy task scheduling device.

[0176] The computer-readable storage medium carries one or more programs. When the one or more programs are executed by the privacy task scheduling device, the privacy task scheduling device:

[0177] After receiving a privacy task job request, split the privacy task job request into a number of privacy subtasks in a certain order;

[0178] Mapping the privacy subtask to the corresponding task container image;

[0179] Schedule the task container image to different privacy computing platforms to perform privacy tasks.

[0180] Computer program code for performing the operations of the present application may be written in one or more programming languages, or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on the remote computer or server. In cases involving 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 may be connected to an external computer (e.g., through the Internet using an Internet service provider).

[0181] The flow charts and block diagrams in the accompanying drawings illustrate the possible architecture, functions and operations of the systems, methods and computer program products according to various embodiments of the present application. In this regard, each box in the flow chart or block diagram can represent a module, program segment or a part of code, and the module, program segment or a part of code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order than that marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart can be implemented by a dedicated hardware-based system that performs the specified function or operation, or can be implemented by a combination of dedicated hardware and computer instructions.

[0182] The modules described in the embodiments of the present application may be implemented in software or hardware, wherein the name of a module does not necessarily limit the unit itself.

[0183] The computer-readable storage medium provided in this application stores computer-readable program instructions (i.e., a computer program) for executing the aforementioned privacy task scheduling method, thereby resolving the technical issue of low privacy task processing efficiency. Compared to the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the privacy task scheduling method provided in the aforementioned embodiments, and are not further elaborated here.

[0184] The present application also provides a computer program product, including a computer program, which implements the steps of the above-mentioned privacy task scheduling method when executed by a processor.

[0185] The computer program product provided in this application can address the technical issue of low processing efficiency for privacy-related tasks. Compared to the prior art, the beneficial effects of the computer program product provided in this application are the same as those of the privacy-related task scheduling method provided in the above-mentioned embodiments, and will not be further elaborated here.

[0186] The above description is only part of the embodiments of the present application and does not limit the patent scope of the present application. All equivalent structural transformations made by using the contents of the present application specification and drawings under the technical concept of the present application, or direct / indirect application in other related technical fields are included in the patent protection scope of the present application.

Claims

1. A privacy task scheduling method, characterized in that: The method includes: After receiving a privacy task job request, split the privacy task job request into a number of privacy subtasks in a certain order; Mapping the privacy subtask to the corresponding task container image; Schedule the task container image to different privacy computing platforms to perform privacy tasks.

2. The method according to claim 1, wherein The step of splitting the privacy task job request into a plurality of privacy subtasks in a certain order includes: Parsing the privacy task job request and determining the input and output relationships between components; Sort the input and output relationships between the components to determine the order in which the components are executed; Based on the execution order of the components, the privacy task job request is split into a number of privacy subtasks with a sequence.

3. The method according to claim 1, wherein The step of mapping the privacy subtask to the corresponding task container image includes: Query the algorithm type, participant role attributes, and security strength requirements for each privacy subtask; According to the algorithm type, match the task container image corresponding to each privacy subtask from the preset container image library; Constructing task variable information based on the role attributes and security strength requirements of the participants; Inject the task variable information into the corresponding task container image.

4. The method according to claim 1, wherein The step of scheduling the task container image to different privacy computing platforms to perform privacy tasks includes: Get the container image of the task to be executed; According to the preset scheduling rules, the task container images are scheduled to different privacy computing platforms and the tasks are started synchronously, wherein each task container image is isolated from each other; Monitor the task execution status of participating task container images.

5. The method according to claim 4, wherein The step of monitoring the task execution status of all participants includes: Get the task execution status of the participating task container image; When an abnormal situation occurs, the preset countermeasures are executed according to the abnormality type; If the exception type is a container crash or exceeding resource limits, the abnormal container will be automatically restarted; If the exception type is caused by program or algorithm parameters, the error log is sent to the preset database.

6. The method according to claim 1, wherein After receiving the privacy task job request, before the step of splitting the privacy task job request into a plurality of privacy subtasks in a sequential order, the step includes: Encapsulate the algorithm logic into the corresponding task container image and upload it to the container image library; Register the container image information corresponding to the task container image to each privacy computing platform.

7. A privacy task scheduling device, characterized in that: The device comprises: A splitting module is used to split the privacy task job request into a number of privacy subtasks in a certain order after receiving the privacy task job request; A mapping module, configured to map the privacy subtask to a corresponding task container image; A distribution module is used to schedule the task container image to different privacy computing platforms to perform privacy tasks.

8. A privacy task scheduling device, characterized in that: The device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program is configured to implement the steps of the privacy task scheduling method according to any one of claims 1 to 6.

9. A storage medium, characterized in that: The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, the steps of the privacy task scheduling method according to any one of claims 1 to 6 are implemented.

10. A computer program product, characterized in that The computer program product includes a computer program, which, when executed by a processor, implements the steps of the privacy task scheduling method according to any one of claims 1 to 6.

Images