Task flow processing method and apparatus based on edge computing

Abstract

The embodiments of the present application relate to the technical field of computers. Provided are a task flow processing method and apparatus based on edge computing, and an electronic device and a computer-readable storage medium. The method comprises: in response to a creation request for a task flow, a management node acquiring task flow information of the task flow, and displaying a visual page for creating the task flow; on the basis of at least one operator component added to the visual page and flow connections between the operator components, generating the task flow; determining a dependency component list of dependency components corresponding to the operator components; and sending the dependency component list and the task flow information to an edge node, such that the edge node executes the task flow on the basis of the dependency component list and the task flow information.

Description

Task flow processing method and apparatus based on edge computing

[0001] Related applications

[0002] This application claims priority to Chinese patent application No. 2024116125782, filed on November 12, 2024, entitled “Task Flow Processing Method and Apparatus Based on Edge Computing”, the entire contents of which are incorporated herein by reference. Technical Field

[0003] This application relates to the field of computer technology, and in particular to a task flow processing method and apparatus based on edge computing, an electronic device, and a computer-readable storage medium. Background Technology

[0004] With the rapid development of the Internet of Things (IoT), Artificial Intelligence (AI), and 5G communication technologies, edge computing, as a distributed computing architecture capable of processing and analyzing data near the data source, has become a key technology for handling massive amounts of multimodal data. Multimodal data typically includes data from various sensors, cameras, microphones, and other devices, such as video, audio, text, and sensor data.

[0005] In existing edge computing architectures, most solutions focus on the distribution and execution of single tasks, lacking overall management and optimized scheduling of multimodal tasks. Furthermore, existing edge node management mechanisms typically only provide simple monitoring and management of single devices or tasks, making it difficult to handle complex scenarios involving the parallel execution of multiple tasks. Summary of the Invention

[0006] This application discloses a task flow processing method based on edge computing, applied to a management node, the method comprising:

[0007] In response to a task flow creation request, the task flow information of the task flow is obtained, and a visualization page for creating the task flow is displayed;

[0008] A task flow is generated based on at least one operator component added to the visualization page, and the flow direction connections between the operator components.

[0009] Determine the list of dependent components for each operator component;

[0010] The list of dependent components and the task flow information are sent to the edge node so that the edge node executes the task flow based on the list of dependent components and the task flow information.

[0011] In one or more embodiments, it further includes:

[0012] Obtain the target dependent component acquisition request sent by the edge node; the target dependent component is the dependent component that the edge node is missing among the various dependent components;

[0013] Send the target dependent component to the edge node.

[0014] In one or more embodiments, sending the list of dependent components and the task flow information to the edge node includes:

[0015] Generate a tree structure for each of the operator components and each of the dependent components;

[0016] The dependent component list and task flow information of each dependent component are encapsulated according to the tree structure to obtain a data packet;

[0017] The data packet is sent to the edge node.

[0018] In one or more embodiments, prior to obtaining the task flow information of the task flow in response to the task flow creation request, the method further includes:

[0019] Detect whether there are new edge nodes;

[0020] If so, then register the new edge node.

[0021] In one or more embodiments, registering the new edge node includes:

[0022] If the network segment to which the new edge node belongs has configuration information, the configuration information is sent to the new edge node so that the new edge node can install the configuration information.

[0023] If a request to acquire an edge node client is received from the new edge node, then the installation package of the edge node client is sent to the new edge node so that the new edge node can acquire the installation package and install the installation package to obtain the edge node client. Also, when the edge node client is started, heartbeat information is sent.

[0024] Obtain the heartbeat information, and extract the node identifier of the new edge node from the heartbeat information;

[0025] Add the node identifier to the preset node management list.

[0026] In one or more embodiments, it further includes:

[0027] If the heartbeat information is not received within the preset time period, it is determined that the new edge node is abnormal.

[0028] In one or more embodiments, it further includes:

[0029] An operator component update instruction is sent to the edge node, so that the edge node updates the operator component to be updated in response to the operator component update instruction, and obtains the updated operator component.

[0030] This application discloses a task flow processing method based on edge computing, applied to edge nodes, including:

[0031] Once the list of dependent components and task flow information are obtained, start the edge node client;

[0032] Based on the list of dependent components, obtain the corresponding dependent components;

[0033] The task flow is executed in the edge node client using the various dependent components and the task flow information.

[0034] In one or more embodiments, obtaining the corresponding dependent components based on the dependent component list includes:

[0035] Based on the list of dependent components, the corresponding dependent components are obtained from other edge nodes; the other edge nodes belong to the same network segment as the edge node.

[0036] If the target dependent component is not obtained, a first request to obtain the target dependent component is generated; the target dependent component is the dependent component that is missing from the edge node among the various dependent components.

[0037] The first acquisition request is sent to the management node, so that the management node sends the target dependent component to the edge node based on the first acquisition request.

[0038] In one or more embodiments, before obtaining the list of dependent components and task flow information, the method further includes:

[0039] When the configuration information is obtained, install the configuration information;

[0040] Obtain the installation package of the edge node client from other edge nodes;

[0041] If successful, install the installation package to obtain the edge node client;

[0042] If the retrieval fails, a second retrieval request for the installation package is generated;

[0043] The second acquisition request is sent to the management node, so that the management node sends the installation package to the edge node based on the second acquisition request;

[0044] When the installation package is obtained, the installation package is installed to obtain the edge node client.

[0045] In one or more embodiments, prior to launching the edge node client, the method further includes:

[0046] Test the task flow based on the task flow information;

[0047] If the test passes, the edge node client is launched.

[0048] In one or more embodiments, executing the task flow in the edge node client using the respective dependent components and the task flow information includes:

[0049] The dependent components are merged according to the keys corresponding to each dependent component to obtain at least one operator component corresponding to the task flow;

[0050] The task flow is executed in the edge node client using each of the aforementioned operator components.

[0051] In one or more embodiments, it further includes:

[0052] When an update instruction for an operator component is received, the input to the operator component to be updated is blocked.

[0053] The operator component to be updated is updated using a preset update file;

[0054] When the update is complete, the updated operator component is obtained, and the blockage is released.

[0055] In one or more embodiments, it further includes:

[0056] The execution results of the task flow are recorded and sent to the management node;

[0057] If the number of execution failures in the execution results exceeds the threshold, the execution of the task flow will be terminated.

[0058] Accordingly, this application discloses a task flow processing device based on edge computing, applied to a management node, the device comprising:

[0059] The first acquisition module is used to acquire the task flow information of the task flow in response to the task flow creation request;

[0060] The display module is used to show a visual page for creating the task flow;

[0061] A generation module is used to generate a task flow based on at least one operator component added to the visualization page, and the flow direction connection between the various operator components;

[0062] The first determining module is used to determine the list of dependent components for each dependent component corresponding to each operator component;

[0063] The first sending module is used to send the list of dependent components and the task flow information to the edge node, so that the edge node executes the task flow based on the list of dependent components and the task flow information.

[0064] In one or more embodiments, the first acquisition module is further configured to acquire a target dependency component acquisition request sent by the edge node; the target dependency component is a dependency component that the edge node lacks among the various dependency components;

[0065] The first sending module is further configured to send the target dependent component to the edge node.

[0066] In one or more embodiments, the first sending module is specifically used for:

[0067] Generate a tree structure for each of the operator components and each of the dependent components;

[0068] The dependent component list and task flow information of each dependent component are encapsulated according to the tree structure to obtain a data packet;

[0069] The data packet is sent to the edge node.

[0070] In one or more embodiments, it further includes:

[0071] The detection module is used to detect whether there are new edge nodes before the task flow information of the task flow is obtained in response to the task flow creation request;

[0072] The registration module is used to register the new edge node if the condition is met.

[0073] In one or more embodiments, the registration module is specifically used for:

[0074] If the network segment to which the new edge node belongs has configuration information, the configuration information is sent to the new edge node so that the new edge node can install the configuration information.

[0075] If a request to acquire an edge node client is received from the new edge node, then the installation package of the edge node client is sent to the new edge node so that the new edge node can acquire the installation package and install the installation package to obtain the edge node client. Also, when the edge node client is started, heartbeat information is sent.

[0076] Obtain the heartbeat information, and extract the node identifier of the new edge node from the heartbeat information;

[0077] Add the node identifier to the preset node management list.

[0078] In one or more embodiments, it further includes:

[0079] The second determining module is used to determine that the new edge node is abnormal if the heartbeat information is not received within a preset time period.

[0080] In one or more embodiments, the first sending module is further configured to send an operator component update instruction to the edge node, so that the edge node updates the operator component to be updated in response to the operator component update instruction, and obtains the updated operator component.

[0081] Accordingly, embodiments of this application disclose a task flow processing device based on edge computing, applied to edge nodes, including:

[0082] The startup module is used to start the edge node client when the list of dependent components and task flow information are obtained;

[0083] The second acquisition module is used to acquire each corresponding dependency component based on the dependency component list;

[0084] An execution module is used to execute a task flow in the edge node client using the various dependent components and the task flow information.

[0085] In one or more embodiments, the second acquisition module is specifically used for:

[0086] Based on the list of dependent components, the corresponding dependent components are obtained from other edge nodes; the other edge nodes belong to the same network segment as the edge node.

[0087] If the target dependent component is not obtained, a first request to obtain the target dependent component is generated; the target dependent component is the dependent component that is missing from the edge node among the various dependent components.

[0088] The first acquisition request is sent to the management node, so that the management node sends the target dependent component to the edge node based on the first acquisition request.

[0089] In one or more embodiments, it further includes:

[0090] The installation module is used to install the configuration information when the configuration information is obtained, before obtaining the list of dependent components and task flow information;

[0091] The second acquisition module is further configured to acquire the installation package of the edge node client from other edge nodes;

[0092] The installation module is also used to install the installation package to obtain the edge node client if the acquisition is successful;

[0093] A generation module is used to generate a second request to obtain the installation package if the acquisition fails.

[0094] The second sending module is used to send the second acquisition request to the management node, so that the management node sends the installation package to the edge node based on the second acquisition request;

[0095] The installation module is also used to install the installation package to obtain the edge node client when the installation package is obtained.

[0096] In one or more embodiments, it further includes:

[0097] The testing module is used to test the task flow based on the task flow information before the edge node client is launched;

[0098] The startup module is also used to start the edge node client if the test passes.

[0099] In one or more embodiments, the execution module is specifically used for:

[0100] The dependent components are merged according to the keys corresponding to each dependent component to obtain at least one operator component corresponding to the task flow;

[0101] The task flow is executed in the edge node client using each of the aforementioned operator components.

[0102] In one or more embodiments, it further includes:

[0103] The blocking module is used to block the input of the operator component to be updated when an update instruction for the operator component is received.

[0104] The update module is used to update the operator component to be updated using a preset update file;

[0105] The release module is used to obtain the updated operator component and release the blockage when the update is complete.

[0106] In one or more embodiments, it further includes:

[0107] A recording module is used to record the execution results of the task flow;

[0108] The second sending module is used to send the execution result to the management node;

[0109] The termination module is used to terminate the execution of the task flow if the number of execution failures in the execution results exceeds a threshold.

[0110] Accordingly, this application discloses an electronic device, including: a processor, a memory, and a computer program stored in the memory and capable of running on the processor. When the computer program is executed by the processor, it implements the various steps of the above-described edge computing-based task flow processing method embodiments.

[0111] Accordingly, this application discloses a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the various steps of the above-described edge computing-based task flow processing method embodiments.

[0112] Details of one or more embodiments of this application are set forth in the following drawings and description. Other features, objects, and advantages of this application will become apparent from the specification, drawings, and claims. Attached Figure Description

[0113] Figure 1 is a flowchart of the steps of a task flow processing method based on edge computing according to an embodiment of this application;

[0114] Figure 2 is a schematic diagram of the architecture of the management node and edge node in this application;

[0115] Figure 3 is a logical diagram of the task creation flow in this application;

[0116] Figure 4 is a schematic diagram of the tree structure of the operator components and dependent components of this application;

[0117] Figure 5 is a flowchart of the steps in a second embodiment of a task flow processing method based on edge computing according to this application;

[0118] Figure 6 is a flowchart of the steps in a third embodiment of a task flow processing method based on edge computing according to this application;

[0119] Figure 7 is a logical diagram of the merging of dependent components in this application;

[0120] Figure 8 is a logical diagram of the update operator component of this application;

[0121] Figure 9 is a structural block diagram of a first embodiment of a task flow processing device based on edge computing according to this application;

[0122] Figure 10 is a structural block diagram of a second embodiment of a task flow processing device based on edge computing according to this application. Detailed Implementation

[0123] To make the above-mentioned objectives, features and advantages of this application more apparent and understandable, the application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0124] One of the core concepts of this application's embodiments lies in the fact that, through task flow orchestration, task flows for multimodal data processing tasks can be realized. This not only unifies the management of information from edge nodes but also unifies the distribution of various orchestrated multimodal data processing flows. Since the task flows are already orchestrated, this application's embodiments can support both real-time and offline task processing. Moreover, through this orchestration mechanism, users can flexibly define task flows, supporting the operation of multiple modal data processing operator components on edge nodes, thereby achieving dynamic adjustment of the data processing chain.

[0125] Referring to Figure 1, a flowchart illustrating the steps of an embodiment of the task flow processing method based on edge computing according to this application is shown, applied to a management node. Referring to Figure 2, a schematic diagram of the architecture of the management node and edge nodes is shown. The management node can be deployed in a management center. The number of management nodes can be one or multiple. In practical applications, the number of management nodes can be adjusted according to actual needs, and this embodiment does not impose any limitations on this. The management node is responsible for the global control and management of the system, including the discovery, registration, monitoring, task distribution, and upgrade management of edge nodes. Multiple management nodes can be highly available to each other. In a cloud environment, they can also be deployed on a cloud server.

[0126] Furthermore, gateways are deployed in the management center, and each management node connects to a gateway. Simultaneously, multiple gateways are deployed in the edge node network segment, each gateway connecting to multiple edge nodes; that is, multiple edge nodes connected to the same gateway are in the same network segment. Edge nodes represent independent computing units, responsible for receiving and executing task flows issued by the management center, reporting node status metrics, and updating actual tasks.

[0127] The gateway in the management center is connected to each gateway in the edge node network segment. In this way, each management node can communicate with each edge node through the gateway in the management center and the gateways in the edge node network segment. In practical applications, the number of gateways in the edge node network segment and the number of edge nodes in each segment can be configured according to actual needs, and this embodiment does not impose any limitations on this.

[0128] This method may specifically include the following steps:

[0129] Step 101: In response to the task flow creation request, obtain the task flow information of the task flow and display a visualization page for creating the task flow.

[0130] Specifically, users can access the management node and send a creation request to it to create a task flow. Upon receiving the request, the management node provides an interface for obtaining task flow information, which users can then input. This task flow information may include: task tag, version information, task template, abstract parameters, whether it is bound to a specific network segment for automatic task distribution, and the task's effective time. Of course, the task flow information may also include other information. In practical applications, the specific information included in the task flow information can be set according to actual needs, and this embodiment does not impose any limitations on this.

[0131] Furthermore, the management node can also display a visual interface to users, where users can create task flows. A task flow can include multiple subtasks, which are processed sequentially to form the flow. The data processed by the task flow can be multimodal data.

[0132] It should be noted that the visualization interface can be displayed before or after the task flow information is obtained. In other words, the order of displaying the visualization interface and obtaining the task flow information can be adjusted according to actual needs, and this application embodiment does not limit this.

[0133] Step 102: Generate a task flow based on at least one operator component added to the visualization page, and the flow direction connections between the various operator components.

[0134] The displayed visualization interface may include an interface for an operator component library and a canvas. The operator component library may include multiple pre-configured operator components. Users can then add at least one operator component to the canvas for executing task flows via the interface. Users can then configure the input / output flow connections for each operator component on the canvas and configure the relevant parameters for each operator, thereby obtaining a task flow composed of the various operators and flow connections.

[0135] Referring to Figure 3, a logical diagram of task flow creation is shown. The types of operator components in the operator plugin library can include decision operators, text operators, video operators, and audio operators.

[0136] The decision operator component is used to trigger the next operator component based on the data, and to trigger a NeverBreakException to interrupt the task flow when an infinite loop occurs, thereby breaking out of the infinite loop.

[0137] Text operators are used to process text-type data.

[0138] Video operators are used to process video data.

[0139] Audio operators are used to process audio data.

[0140] Decision operator components may include value judgment and filtering operators, enumeration judgment operators, aggregation operators, splitting operators, etc.; text operator components may include feature deduplication operators, text conversion operators, sensitive information processing operators, encryption and decryption operators, etc.; video operator components may include video denoising operators, dynamic enhancement operators, format conversion operators, frame extraction operators, etc.; audio operator components may include format conversion operators, audio denoising operators, human voice splitting operators, corruption filtering operators, etc.

[0141] Of course, the operator component library may also include other types of operator components, and each type of operator component may also include other operator components. In practical applications, the specific type of operator component can be set according to actual needs, and this application embodiment does not limit this.

[0142] Furthermore, users can add operator components from the operator component library to the canvas via the interface. These components can be added to the canvas by dragging, pulling, or dropping, or by other methods. In practical applications, the specific method of addition can be set according to actual needs, and this embodiment does not impose any restrictions on this.

[0143] After adding operator components to the canvas, you can set the input and output of multimodal data streams, and then the user can connect the input and output directions of each operator component.

[0144] Since each operator component has standard inputs and outputs, when a user performs a flow connection between any two operator components, if the output of the upstream operator component does not meet the input requirements of the downstream operator component, then the two operator components cannot be flow-connected. Simultaneously, an error message can be displayed to the user to indicate that the two operator components cannot be flow-connected. It should be noted that the input to the decision operator component is arbitrary data, and the output inherits from the input.

[0145] Furthermore, the operator component library also provides an extension interface, through which users can customize operator components to develop new operator components. The newly developed operator components can be stored in the operator component library for reuse when creating task flows in the future.

[0146] Step 103: Determine the list of dependent components for each operator component.

[0147] Since each operator component has a corresponding version number and at least one dependent component, once the user adds each operator component to the canvas, the dependent components corresponding to each operator component can be determined, thus obtaining a list of dependent components.

[0148] Step 104: Send the list of dependent components and the task flow information to the edge node so that the edge node executes the task flow based on the list of dependent components and the task flow information.

[0149] After determining the list of dependent components, the list of dependent components and task flow information can be sent to the edge nodes that need to execute the task flow. After the edge nodes obtain the list of dependent components and task flow information, they can execute the task flow according to the list of dependent components and task flow information.

[0150] In this embodiment of the application, sending the list of dependent components and the task flow information to the edge node includes:

[0151] Generate a tree structure for each of the operator components and each of the dependent components;

[0152] The dependent component list and task flow information of each dependent component are encapsulated according to the tree structure to obtain a data packet;

[0153] The data packet is sent to the edge node.

[0154] Specifically, after identifying each dependent component, the operator components and dependent components can be generated into a tree structure. Since multiple operator components may have the same dependent components, generating a tree structure can remove duplicate dependent components; only one instance of the same dependent component is needed.

[0155] Referring to Figure 4, a schematic diagram of the tree structure of operator components and dependent components is shown. Operator component A includes dependent component A, dependent component B, dependent component C, and dependent component D. Operator component B includes dependent component D and dependent component E. If a tree structure is not generated, then two dependent components D need to be retained; however, after generating the tree structure, only one dependent component D needs to be retained.

[0156] After generating the tree structure, the list of dependent components and task flow information can be encapsulated according to the tree structure to obtain a data packet, which can then be sent to the edge node.

[0157] It's important to note that at this stage, the management node doesn't need to send the dependent components to the edge nodes; it only needs to send the list of dependent components. The edge nodes can then retrieve the dependent components from other edge nodes within the same network segment based on the list. If any dependent components are still missing, they can then retrieve them from the management node. This improves the efficiency of the edge nodes in retrieving dependent components.

[0158] In this embodiment, the management node responds to a task flow creation request, obtains the task flow information of the task flow, and displays a visualization page for creating the task flow; generates a task flow based on at least one operator component added to the visualization page and the flow connections between the operator components; determines a list of dependent components corresponding to each operator component; and sends the list of dependent components and the task flow information to the edge node, so that the edge node executes the task flow based on the list of dependent components and the task flow information. Through the above task flow orchestration method, task flows for multimodal data processing tasks can be realized. This not only allows for unified management of edge node information but also unified distribution of various orchestrated multimodal data processing flows. Since the task flow has been orchestrated, this embodiment supports both real-time and offline task processing. Moreover, through this orchestration mechanism, users can flexibly define task flows, supporting the operation of multiple modal data processing operator components on edge nodes, thereby achieving dynamic adjustment of the data processing link.

[0159] Referring to Figure 5, a flowchart of a second embodiment of a task flow processing method based on edge computing according to this application is shown. Applied to a management node, it may specifically include the following steps:

[0160] Step 501: Detect whether there are new edge nodes.

[0161] Before receiving a task flow creation request, the management node can detect whether a new edge node has joined. This detection can be proactive, such as through network segment liveness detection. For example, the management node scans each monitored network segment and sends communication commands to each segment, broadcasting them within the segment to detect the presence of a new edge node.

[0162] Step 502: If yes, then register the new edge node.

[0163] If a new edge node is detected, it can be registered so that the management node can control it. If no new edge node is detected, then step 503 can be executed.

[0164] In this embodiment of the application, registering the new edge node includes:

[0165] If the network segment to which the new edge node belongs has configuration information, the configuration information is sent to the new edge node so that the new edge node can install the configuration information.

[0166] If a request to acquire an edge node client is received from the new edge node, then the installation package of the edge node client is sent to the new edge node so that the new edge node can acquire the installation package and install the installation package to obtain the edge node client. Also, when the edge node client is started, heartbeat information is sent.

[0167] Obtain the heartbeat information, and extract the node identifier of the new edge node from the heartbeat information;

[0168] Add the node identifier to the preset node management list.

[0169] Specifically, when the network segment to which the new edge node belongs has configuration information for the edge node, the network segment can proactively send the configuration information to the new edge node, and the new edge node can initialize after obtaining the configuration information.

[0170] After a new edge node is initialized, it can send a request to the management node to obtain the edge node client. Upon receiving the request, the management node can send the edge node client installation package to the new edge node. The installation package can be sent via a TLS (Transport Layer Security) channel or other methods. In practical applications, the specific method of sending the installation package can be configured according to actual needs, and this embodiment does not impose any restrictions on this.

[0171] After obtaining the installation package, the new edge node can install the package to obtain the edge node client. Then, start the edge node client, carry local information to communicate with the management node and register, confirm its own identity information, obtain configuration parameters and start a second time. After the second start, it can send heartbeat information to the management node.

[0172] After receiving the heartbeat information, the management node can parse the UDP-NetBIOS-NS query packet within the heartbeat to obtain the node identifier of the new edge node, such as NetBIOS Names information. Once the node identifier is obtained, it can be added to a pre-defined node management list for management of the new edge node.

[0173] Furthermore, when detecting whether a new edge node has been connected, in addition to scanning all network segments, scanning can also be performed based on a whitelist of network segments. In practical applications, whether or not a whitelist of network segments needs to be set can be determined according to actual needs, and this application embodiment does not impose any restrictions on this. In this way, edge nodes are automatically registered through network segment detection and the corresponding configuration information is distributed, thereby effectively handling the dynamic addition and removal of edge nodes and adapting to large-scale edge computing environments.

[0174] In this embodiment of the application, if the management node does not receive heartbeat information from any edge node within a preset time period, it can be determined that the edge node is abnormal.

[0175] Step 503: In response to the task flow creation request, obtain the task flow information of the task flow and display a visualization page for creating the task flow.

[0176] Step 504: Generate a task flow based on at least one operator component added to the visualization page, and the flow direction connections between the various operator components.

[0177] Step 505: Determine the list of dependent components for each operator component.

[0178] Step 506: Send the list of dependent components and the task flow information to the edge node so that the edge node executes the task flow based on the list of dependent components and the task flow information.

[0179] Steps 503 to 506 are essentially the same as steps 101 to 104, and will not be repeated here to avoid repetition.

[0180] It should be noted that the new edge node detected in steps 501 to 502 may be the same as the edge node executing the task flow in steps 503 to 506, or they may not be the same. In other words, whether or not a new edge node is needed to execute the task flow can be set according to actual needs, and this application embodiment does not impose any restrictions on this.

[0181] Step 507: Obtain the acquisition request of the target dependent component sent by the edge node; the target dependent component is the dependent component that the edge node is missing among the various dependent components.

[0182] Step 508: Send the target dependent component to the edge node.

[0183] Specifically, the management node may receive a request from the edge node to be executed to obtain the target dependent component, where the target dependent component is the missing dependent component among all the dependent components required by the edge node to be executed.

[0184] Once the management node receives the request, it can package the target dependent components and then send the packaged target dependent components to the edge nodes.

[0185] Step 509: Send an operator component update instruction to the edge node so that the edge node updates the operator component to be updated in response to the operator component update instruction, and obtains the updated operator component.

[0186] Specifically, when it is necessary to update the operator components in the edge nodes, the management node can send an operator component update command to the edge nodes. After receiving the operator component update command, the edge nodes can update the operator components to be updated, thereby obtaining the updated operator components.

[0187] It should be noted that step 509 can be executed after step 506 or after step 508. This embodiment of the application describes step 509 as being executed after step 508. In practical applications, the execution order of step 509 can be set according to actual needs, and this embodiment of the application does not limit this.

[0188] Referring to Figure 6, a flowchart of a third embodiment of a task flow processing method based on edge computing according to this application is shown. Applied to edge nodes, it may specifically include the following steps:

[0189] Step 601: When the list of dependent components and task flow information are obtained, start the edge node client.

[0190] Once the edge node obtains the list of dependent components and task flow information, it can start the edge node client for subsequent execution of the task flow.

[0191] In this embodiment of the application, before obtaining the list of dependent components and task flow information, the following steps are also included:

[0192] When the configuration information is obtained, install the configuration information;

[0193] Obtain the installation package of the edge node client from other edge nodes;

[0194] If successful, install the installation package to obtain the edge node client;

[0195] If the retrieval fails, a second retrieval request for the installation package is generated;

[0196] The second acquisition request is sent to the management node, so that the management node sends the installation package to the edge node based on the second acquisition request;

[0197] When the installation package is obtained, the installation package is installed to obtain the edge node client.

[0198] Specifically, when an edge node obtains the configuration information, it can install the configuration information and initialize. After initialization, the edge node can first try to obtain the edge node client installation package from other edge nodes in the same network segment. If the acquisition is successful, it can install the installation package to obtain the edge node client; if the acquisition fails, it can generate an acquisition request for the installation package (denoted as the "second acquisition request") and send the second acquisition request to the management node. After receiving the second acquisition request, the management node can send the installation package to the edge node, and the edge node can install the installation package to obtain the edge node client.

[0199] It should be noted that the edge nodes that obtain configuration information are mainly newly connected edge nodes.

[0200] Step 602: Obtain the corresponding dependent components based on the dependent component list.

[0201] After obtaining the list of dependent components, the edge node can retrieve the various dependent components used to execute the task flow based on the list.

[0202] In this embodiment of the application, obtaining the corresponding dependent components based on the dependent component list includes:

[0203] Based on the list of dependent components, the corresponding dependent components are obtained from other edge nodes; the other edge nodes belong to the same network segment as the edge node.

[0204] If the target dependent component is not obtained, a first request to obtain the target dependent component is generated; the target dependent component is the dependent component that is missing from the edge node among the various dependent components.

[0205] The first acquisition request is sent to the management node, so that the management node sends the target dependent component to the edge node based on the first acquisition request.

[0206] Specifically, an edge node can retrieve corresponding dependent components from other edge nodes based on a list of dependent components, where the other edge nodes belong to the same network segment as the current edge node. If some dependent components (denoted as "target dependent components") are not available from other edge nodes, a retrieval request (denoted as "first retrieval request") can be generated and sent to the management node. Once the management node receives the retrieval request, it can package the target dependent components and then send the packaged target dependent components to the edge node.

[0207] Edge nodes can obtain processes from other edge nodes on the same network segment via STUN (Session Traversal Utilities for NAT). During connection, mutual authentication is performed using the cluster key (each management center and each edge node form a cluster) and the public key of each edge node. If edge nodes belong to the same cluster, each edge node in each cluster possesses the same cluster key, as well as the private key obtained from the cluster when registering with it. Edge nodes can obtain the current time-based salt operation of the cluster using their private key, and can use this salt operation to decode the public keys of other edge nodes, thus achieving mutual trust. After successful mutual trust, the necessary dependent components can be obtained from nearby nodes.

[0208] Step 603: Execute the task flow in the edge node client using each of the dependent components and the task flow information.

[0209] Once the various dependent components required to execute the task flow are obtained, the task flow can be executed in the edge node client using the various dependent components and task flow information.

[0210] In this embodiment of the application, the step of executing the task flow in the edge node client using the various dependent components and the task flow information includes:

[0211] The dependent components are merged according to the keys corresponding to each dependent component to obtain at least one operator component corresponding to the task flow;

[0212] The task flow is executed in the edge node client using each of the aforementioned operator components.

[0213] Specifically, each operator component has a corresponding key, such as "multimodal-operator name-version number-MD5". Similarly, each dependent component also has a corresponding key, such as "dependent component-dependent component name-version number-MD5". Each key represents a minimum unit. Based on this, after obtaining the dependent components, the edge node can merge them according to the operator component's key and the dependent component's key to obtain the individual operator components. Merging dependent components can also be done using a tree structure.

[0214] Referring to Figure 7, a logical diagram of dependency component merging is shown. Dependency components A, B, C, and D are merged to obtain operator component A; dependency components D and E are merged to obtain operator component B; and dependency components F and G are merged to obtain operator component C. Operator components A and B are used to execute task A, and operator components B and C are used to execute task B. Tasks A and B constitute a task flow.

[0215] In this embodiment of the application, before starting the edge node client, the following steps are also included:

[0216] Test the task flow based on the task flow information;

[0217] If the test passes, the edge node client is launched.

[0218] Specifically, after obtaining the task flow information, the edge node can test the task flow based on this information. These tests include, but are not limited to, integrity testing and executability testing. If the test passes, the edge node client can be started. If the test fails, the process can be restarted.

[0219] It should be noted that the tests may include other tests in addition to those mentioned above. In practical applications, specific test items can be set according to actual needs, and this application embodiment does not impose any restrictions on this.

[0220] In this embodiment of the application, after step 603, the following may also be included:

[0221] When an update instruction for an operator component is received, the input to the operator component to be updated is blocked.

[0222] The operator component to be updated is updated using a preset update file;

[0223] When the update is complete, the updated operator component is obtained, and the blockage is released.

[0224] Specifically, when an edge node receives an operator component update instruction, it can block the input to the operator component to be updated. This clears the resource usage of the operator component to be updated, but retains the runtime information of the operator component. Then, the operator component to be updated is updated using a preset update file. When the update is complete, the updated operator component is obtained, and the input blocking of the updated operator component is released, thereby resuming the operation of the operator component.

[0225] Referring to Figure 8, a logical diagram of the update operator component is shown. Since the multimodal data processing flow consists of a loop graph composed of multiple operator components, and each operator component is independent, the various operator components can be logically connected through internal tunnels. The smallest processing unit in multimodal data processing can be called a Flowfile. A Flowfile may consist of multiple Records or a single Record, and a Record is the smallest unit of data.

[0226] The video frame extraction and transformation operator component converts the video stream input into an image for output, and places it into a logical Tunnel. The Tunnel may temporarily store multiple Flowfiles awaiting processing by the downstream Image license plate detection operator component.

[0227] The blocking command can pause all Tunnel output, causing all operator components to stop running subsequent Flowfile tasks. In this way, the processing flow of all operator components can be indirectly paused. Of course, it's also possible to block only a specific operator component, causing it to stop running.

[0228] The update implementation of the operator component is based on this mechanism. When upgrading the Image license plate detection operator component from V1.0.0 to V1.0.1, the blocking of the front Tunnel can be executed, blocking the input of the Image license plate detection operator component. When the Image license plate detection operator component has no input, the operator component stops and releases its resources. This implementation clears the operator component's resource usage but retains the operator component's runtime information. Then, the new version V1.0.1 component is hot-loaded, executing the operator component initialization implementation, loading the runtime information of V1.0.0, and starting it. At this time, the front Tunnel releases its blocking after the new version is ready, and multimodal data resumes to flow. The entire hot update process does not block other operator components on the same canvas; it only blocks the processing of the operator component that needs to be loaded.

[0229] Through the aforementioned isolation of operator components, logical connection of the Tunnel, and independent loading of operator components, an update and upgrade of the multimodal data processing stream was completed. This operation can not only specify an edge node for updating, but also update a group of edge nodes simultaneously. Therefore, it can achieve both canary rollout and unified management of the processing flow of edge node groups.

[0230] In this embodiment of the application, after step 603, the following may also be included:

[0231] The execution results of the task flow are recorded and sent to the management node;

[0232] If the number of execution failures in the execution results exceeds the threshold, the execution of the task flow will be terminated.

[0233] Specifically, when edge nodes execute task flows, they can record the execution results of the task flows, capture possible errors or abnormal states, and report the execution results to the management node.

[0234] Edge nodes can also judge the execution results. If the number of execution failures in the execution results exceeds the threshold, the execution of the task flow can be terminated.

[0235] When the edge node reports the execution result to the management node, it can use heartbeat information or other methods to report. In practical applications, the specific method of sending the execution result can be set according to actual needs, and this application embodiment does not limit it.

[0236] Furthermore, after obtaining the heartbeat information, the management node can generate feedback information and then send the feedback information to the edge node. If the edge node does not receive the feedback information within a preset time period, it can automatically perform the corresponding fault tolerance processing.

[0237] In this embodiment, when an edge node obtains a list of dependent components and task flow information, it starts an edge node client; it obtains each corresponding dependent component based on the list of dependent components; and it executes the task flow in the edge node client using each dependent component and the task flow information. Since the link between the edge node and the management node is relatively long, when obtaining dependent components, it can preferentially obtain them from other edge nodes in the same network segment, thereby reducing network transmission.

[0238] Furthermore, logical isolation tunnels are set between operator components. This logical isolation gives upstream and downstream operators a certain degree of independence and enables hot updates of a single operator component or a group of operator components without affecting other operator components. This not only enables grayscale upgrades of edge nodes, but also enables unified upgrades of edge node groups.

[0239] It should be noted that, for the sake of simplicity, the method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments of this application are not limited to the described order of actions, because according to the embodiments of this application, some steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also understand that the embodiments described in the specification are all preferred embodiments, and the actions involved are not necessarily required by the embodiments of this application.

[0240] Referring to Figure 9, a structural block diagram of a task flow processing device based on edge computing according to a first embodiment of this application is shown. This device is applied to a management node and may specifically include the following modules:

[0241] The first acquisition module 901 is used to acquire the task flow information of the task flow in response to the task flow creation request;

[0242] Display module 902 is used to display a visual page for creating the task flow;

[0243] The generation module 903 is used to generate a task flow based on at least one operator component added to the visualization page, and the flow direction connection between the various operator components;

[0244] The first determining module 904 is used to determine the list of dependent components corresponding to each operator component.

[0245] The first sending module 905 is used to send the list of dependent components and the task flow information to the edge node, so that the edge node executes the task flow based on the list of dependent components and the task flow information.

[0246] In this embodiment of the application, the first acquisition module is further configured to acquire the acquisition request of the target dependent component sent by the edge node; the target dependent component is the dependent component that the edge node lacks among the various dependent components;

[0247] The first sending module is further configured to send the target dependent component to the edge node.

[0248] In this embodiment of the application, the first sending module is specifically used for:

[0249] Generate a tree structure for each of the operator components and each of the dependent components;

[0250] The dependent component list and task flow information of each dependent component are encapsulated according to the tree structure to obtain a data packet;

[0251] The data packet is sent to the edge node.

[0252] In this embodiment of the application, it also includes:

[0253] The detection module is used to detect whether there are new edge nodes before the task flow information of the task flow is obtained in response to the task flow creation request;

[0254] The registration module is used to register the new edge node if the condition is met.

[0255] In this embodiment of the application, the registration module is specifically used for:

[0256] If the network segment to which the new edge node belongs has configuration information, the configuration information is sent to the new edge node so that the new edge node can install the configuration information.

[0257] If a request to acquire an edge node client is received from the new edge node, then the installation package of the edge node client is sent to the new edge node so that the new edge node can acquire the installation package and install the installation package to obtain the edge node client. Also, when the edge node client is started, heartbeat information is sent.

[0258] Obtain the heartbeat information, and extract the node identifier of the new edge node from the heartbeat information;

[0259] Add the node identifier to the preset node management list.

[0260] In this embodiment of the application, it also includes:

[0261] The second determining module is used to determine that the new edge node is abnormal if the heartbeat information is not received within a preset time period.

[0262] In this embodiment of the application, the first sending module is further configured to send an operator component update instruction to the edge node, so that the edge node updates the operator component to be updated in response to the operator component update instruction, and obtains the updated operator component.

[0263] As the device embodiment is basically similar to the method embodiment, the description is relatively simple, and relevant parts can be found in the description of the method embodiment.

[0264] Referring to Figure 10, a structural block diagram of a second embodiment of a task flow processing device based on edge computing according to this application is shown. This device is applied to edge nodes and may specifically include the following modules:

[0265] Startup module 1001 is used to start the edge node client when the list of dependent components and task flow information are obtained;

[0266] The second acquisition module 1002 is used to acquire each corresponding dependent component based on the dependent component list;

[0267] The execution module 1003 is used to execute the task flow in the edge node client using the various dependent components and the task flow information.

[0268] In this embodiment of the application, the second acquisition module is specifically used for:

[0269] Based on the list of dependent components, the corresponding dependent components are obtained from other edge nodes; the other edge nodes belong to the same network segment as the edge node.

[0270] If the target dependent component is not obtained, a first request to obtain the target dependent component is generated; the target dependent component is the dependent component that is missing from the edge node among the various dependent components.

[0271] The first acquisition request is sent to the management node, so that the management node sends the target dependent component to the edge node based on the first acquisition request.

[0272] In this embodiment of the application, it also includes:

[0273] The installation module is used to install the configuration information when the configuration information is obtained, before obtaining the list of dependent components and task flow information;

[0274] The second acquisition module is further configured to acquire the installation package of the edge node client from other edge nodes;

[0275] The installation module is also used to install the installation package to obtain the edge node client if the acquisition is successful;

[0276] A generation module is used to generate a second request to obtain the installation package if the acquisition fails.

[0277] The second sending module is used to send the second acquisition request to the management node, so that the management node sends the installation package to the edge node based on the second acquisition request;

[0278] The installation module is also used to install the installation package to obtain the edge node client when the installation package is obtained.

[0279] In this embodiment of the application, it also includes:

[0280] The testing module is used to test the task flow based on the task flow information before the edge node client is launched;

[0281] The startup module is also used to start the edge node client if the test passes.

[0282] In this embodiment of the application, the execution module is specifically used for:

[0283] The dependent components are merged according to the keys corresponding to each dependent component to obtain at least one operator component corresponding to the task flow;

[0284] The task flow is executed in the edge node client using each of the aforementioned operator components.

[0285] In this embodiment of the application, it also includes:

[0286] The blocking module is used to block the input of the operator component to be updated when an update instruction for the operator component is received.

[0287] The update module is used to update the operator component to be updated using a preset update file;

[0288] The release module is used to obtain the updated operator component and release the blockage when the update is complete.

[0289] In this embodiment of the application, it also includes:

[0290] A recording module is used to record the execution results of the task flow;

[0291] The second sending module is used to send the execution result to the management node;

[0292] The termination module is used to terminate the execution of the task flow if the number of execution failures in the execution results exceeds a threshold.

[0293] As the device embodiment is basically similar to the method embodiment, the description is relatively simple, and relevant parts can be found in the description of the method embodiment.

[0294] This application also provides an electronic device, including:

[0295] It includes a processor, a memory, and a computer program stored in the memory and capable of running on the processor. When the computer program is executed by the processor, it implements the various processes of the above-described edge computing-based task flow processing method embodiments and achieves the same technical effect. To avoid repetition, it will not be described again here.

[0296] This application also provides a computer-readable storage medium storing a computer program. When the computer program is executed by a processor, it implements the various processes of the above-described edge computing-based task flow processing method embodiments and achieves the same technical effect. To avoid repetition, it will not be described again here.

[0297] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.

[0298] Those skilled in the art will understand that embodiments of this application can be provided as methods, apparatus, or computer program products. Therefore, embodiments of this application can take the form of entirely hardware embodiments, entirely software embodiments, or embodiments combining software and hardware aspects. Furthermore, embodiments of this application can take the form of computer program products implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0299] This application describes embodiments with reference to flowchart illustrations and / or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of this application. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing terminal device to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal device, create means for implementing the functions specified in one or more blocks of the flowchart illustrations and / or one or more blocks of the block diagrams.

[0300] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing terminal device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means that implement the functions specified in one or more flowcharts and / or one or more block diagrams.

[0301] These computer program instructions may also be loaded onto a computer or other programmable data processing terminal equipment to cause a series of operational steps to be performed on the computer or other programmable terminal equipment to produce a computer-implemented process, such that the instructions, which execute on the computer or other programmable terminal equipment, provide steps for implementing the functions specified in one or more flowcharts and / or one or more block diagrams.

[0302] Although preferred embodiments of the present application have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of the embodiments of the present application.

[0303] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or terminal device that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or terminal device. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or terminal device that includes said element.

[0304] The above provides a detailed description of a task flow processing method and a task flow processing device based on edge computing provided in this application. Specific examples have been used to illustrate the principles and implementation methods of this application. The description of the above embodiments is only for the purpose of helping to understand the method and core ideas of this application. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this application. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A task flow processing method based on edge computing, applied to a management node, the method comprising: In response to a task flow creation request, the task flow information of the task flow is obtained, and a visualization page for creating the task flow is displayed; A task flow is generated based on at least one operator component added to the visualization page, and the flow direction connections between the operator components. Determine the list of dependent components for each operator component; The list of dependent components and the task flow information are sent to the edge node so that the edge node executes the task flow based on the list of dependent components and the task flow information.

2. The task flow processing method based on edge computing according to claim 1, further comprising: Obtain the target dependent component acquisition request sent by the edge node; The target dependent component is the dependent component that is missing from the edge node among the various dependent components; Send the target dependent component to the edge node.

3. The task flow processing method based on edge computing according to claim 1, wherein sending the dependent component list and the task flow information to the edge node includes: Generate a tree structure for each of the operator components and each of the dependent components; The dependent component list and task flow information of each dependent component are encapsulated according to the tree structure to obtain a data packet; The data packet is sent to the edge node.

4. The task flow processing method based on edge computing according to claim 1, wherein before obtaining the task flow information of the task flow in response to the task flow creation request, the method further includes: Detect whether there are new edge nodes; If so, then register the new edge node.

5. The task flow processing method based on edge computing according to claim 4, wherein registering the new edge node includes: If the network segment to which the new edge node belongs has configuration information, the configuration information is sent to the new edge node so that the new edge node can install the configuration information. If a request to acquire an edge node client is received from the new edge node, then the installation package of the edge node client is sent to the new edge node so that the new edge node can acquire the installation package and install the installation package to obtain the edge node client. Also, when the edge node client is started, heartbeat information is sent. Obtain the heartbeat information, and extract the node identifier of the new edge node from the heartbeat information; Add the node identifier to the preset node management list.

6. The task flow processing method based on edge computing according to claim 5, further comprising: If the heartbeat information is not received within the preset time period, it is determined that the new edge node is abnormal.

7. The task flow processing method based on edge computing according to claim 1, further comprising: An operator component update instruction is sent to the edge node, so that the edge node updates the operator component to be updated in response to the operator component update instruction, and obtains the updated operator component.

8. A task flow processing method based on edge computing, applied to edge nodes, comprising: Once the list of dependent components and task flow information are obtained, start the edge node client; Based on the list of dependent components, obtain the corresponding dependent components; The task flow is executed in the edge node client using the various dependent components and the task flow information.

9. The task flow processing method based on edge computing according to claim 8, wherein obtaining the corresponding dependent components based on the dependent component list includes: Based on the list of dependent components, obtain the corresponding dependent components from other edge nodes; The other edge nodes belong to the same network segment as the edge node; If the target dependent component is not obtained, a first request to obtain the target dependent component is generated; the target dependent component is the dependent component that is missing from the edge node among the various dependent components. The first acquisition request is sent to the management node, so that the management node sends the target dependent component to the edge node based on the first acquisition request.

10. The task flow processing method based on edge computing according to claim 8, wherein before obtaining the list of dependent components and task flow information, it further includes: When the configuration information is obtained, install the configuration information; Obtain the installation package of the edge node client from other edge nodes; If successful, install the installation package to obtain the edge node client; If the retrieval fails, a second retrieval request for the installation package is generated; The second acquisition request is sent to the management node, so that the management node sends the installation package to the edge node based on the second acquisition request; When the installation package is obtained, the installation package is installed to obtain the edge node client.

11. The task flow processing method based on edge computing according to claim 8, wherein before starting the edge node client, it further includes: Test the task flow based on the task flow information; If the test passes, the edge node client is launched.

12. The task flow processing method based on edge computing according to claim 8, wherein executing the task flow in the edge node client using each of the dependent components and the task flow information includes: The dependent components are merged according to the keys corresponding to each dependent component to obtain at least one operator component corresponding to the task flow; The task flow is executed in the edge node client using each of the aforementioned operator components.

13. The task flow processing method based on edge computing according to claim 8, further comprising: When an update instruction for an operator component is received, the input to the operator component to be updated is blocked. The operator component to be updated is updated using a preset update file; When the update is complete, the updated operator component is obtained, and the blockage is released.

14. The task flow processing method based on edge computing according to claim 8, further comprising: The execution results of the task flow are recorded and sent to the management node; If the number of execution failures in the execution results exceeds the threshold, the execution of the task flow will be terminated.

15. A task flow processing device based on edge computing, applied to a management node, the device comprising: The first acquisition module is used to acquire the task flow information of the task flow in response to the task flow creation request; The display module is used to show a visual page for creating the task flow; A generation module is used to generate a task flow based on at least one operator component added to the visualization page, and the flow direction connection between the various operator components; The first determining module is used to determine the list of dependent components for each dependent component corresponding to each operator component; The first sending module is used to send the list of dependent components and the task flow information to the edge node, so that the edge node executes the task flow based on the list of dependent components and the task flow information.

16. A task flow processing device based on edge computing, applied to an edge node, comprising: The startup module is used to start the edge node client when the list of dependent components and task flow information are obtained; The second acquisition module is used to acquire each corresponding dependency component based on the dependency component list; An execution module is used to execute a task flow in the edge node client using the various dependent components and the task flow information.

17. An electronic device comprising: A processor, a memory, and a computer program stored in the memory and capable of running on the processor, wherein the computer program, when executed by the processor, implements the steps of the edge computing-based task flow processing method as described in any one of claims 1 to 7 or 8 to 14.

18. A computer-readable storage medium storing a computer program thereon, the computer program, when executed by a processor, implementing the steps of the edge computing-based task flow processing method as described in any one of claims 1 to 7 or 8 to 14.

Images