Process node processing method and device, storage medium and electronic equipment

Abstract

The invention discloses a process node processing method and device, a storage medium and electronic equipment. The method comprises the steps that a task pulling request sent by a service client in a workflow engine is obtained, the task pulling request is sent to a group of clusters in the workflow engine, a first cluster is determined according to a feedback result of the group of clusters, and the first cluster is formed by deploying a target process instance in the group of clusters; and sending a first task identifier to the service client according to the cluster in which the target process node is in the to-be-activated state, so as to indicate the service client to execute the target task according to the first task identifier, and setting the target process node to be in an activated state. The technical problems that the processing efficiency of the flow node in the cluster is difficult to guarantee and the processing mode of the flow node is not flexible enough due to the fact that the cluster cannot realize dynamic capacity expansion and contraction are solved.

Description

Technical Field

[0001] This application relates to the field of computers, and in particular, to a method and apparatus for processing process nodes, a storage medium, and an electronic device. Background Art

[0002] Currently, some workflow engines generally operate in a cluster mode, and each node in the cluster forms a cluster network. In the cluster network, the nodes have the same responsibilities. To increase the fault tolerance of the cluster network, data can be backed up between the nodes of the cluster network. For example, the data stored in the cluster is divided into multiple partitions, and multiple replicas are set for each partition. In related technologies, the business access of the workflow engine needs to pass through the software development kit provided by the official. However, the software development kit only supports connecting to a single cluster, resulting in the inability to achieve dynamic scaling in the cluster dimension. Moreover, when creating a cluster, since the number of partitions has been determined, it is impossible to modify and expand it later. Therefore, for some emergency scenarios, due to the inability of the cluster to achieve dynamic scaling, it is difficult to ensure the processing efficiency of the process nodes in the cluster, and the processing method of the process nodes is not flexible enough.

[0003] For the above problems, no effective solution has been proposed yet. Summary of the Invention

[0004] An embodiment of this application provides a method and apparatus for processing process nodes, a storage medium, and an electronic device, so as to at least solve the technical problem that it is difficult to ensure the processing efficiency of process nodes in a cluster and the processing method of process nodes is not flexible enough due to the inability of the cluster to achieve dynamic scaling.

[0005] According to one aspect of the embodiments of this application, a method for processing process nodes is provided, including: obtaining a task pulling request sent by a service client in a workflow engine, where the task pulling request indicates that the service client is allowed to execute a target task; sending the task pulling request to a group of clusters in the workflow engine, and determining a first cluster according to the feedback result of the group of clusters, where the first cluster is a cluster in the group of clusters where a target process instance is deployed and the target process node is in a to-be-activated state, and the target process node being in the to-be-activated state means that the target process instance is waiting to execute the target task; sending a first task identifier to the service client to instruct the service client to execute the target task according to the first task identifier, and setting the target process node to an activated state, where the feedback result includes the first task identifier, and the first task identifier is used to instruct the service client to execute the target task related to the first cluster, and the target process node being in the activated state means that the target process instance is executing the target task.

[0006] According to another aspect of the embodiments of the present application, there is also provided a processing device for process nodes, including: an acquisition module, configured to acquire a task pulling request sent by a service client in a workflow engine, where the task pulling request indicates that the service client allows to execute a target task; a processing module, configured to send the task pulling request to a group of clusters in the workflow engine, and determine a first cluster according to the feedback results of the group of clusters, where the first cluster is a cluster in the group of clusters where a target process instance is deployed and the target process node is in a to-be-activated state, and the target process node being in the to-be-activated state means that the target process instance is waiting to execute the target task; a setting module, configured to send a first task identifier to the service client to instruct the service client to execute the target task according to the first task identifier, and set the target process node to be in an activated state, where the feedback result includes the first task identifier, and the first task identifier is used to instruct the service client to execute the target task related to the first cluster, and the target process node being in the activated state means that the target process instance is executing the target task.

[0007] Optionally, the device is configured to send the task pulling request to a group of clusters in the workflow engine and determine the first cluster according to the feedback results of the group of clusters in the following manner: acquire the number of clusters in the group of clusters, and copy the task pulling request according to the number of clusters; send the task pulling request to each cluster in the group of clusters respectively; determine the first cluster according to the feedback results of the group of clusters.

[0008] Optionally, the device is configured to determine the first cluster according to the feedback results of the group of clusters in the following manner, including: receive the feedback results corresponding to the task pulling request sent by each cluster, and determine the first task identifier from the feedback results, where the first task identifier includes a cluster identifier character for indicating the first cluster and a partition identifier character for indicating a target partition associated with the target process node in the first cluster; determine the first cluster and the target partition according to the cluster identifier character and the partition identifier character.

[0009] Optionally, the device is further configured to: obtain an initial task identifier generation logic of the workflow engine, where the initial task identifier generation logic indicates that a task identifier in the workflow engine includes a first identifier area and a second identifier area, where the first identifier area indicates a partition to which a corresponding task belongs, and the second identifier area represents a unique identifier of the corresponding task; modify the initial task identifier generation logic into a target task identifier generation logic, where the target task identifier generation logic indicates that a task identifier corresponding to the workflow engine includes the first identifier area and the second identifier area, a first sub-area of the first identifier area is used to indicate a cluster to which a corresponding task belongs, a second sub-area of the first identifier area is used to indicate a partition to which a corresponding task belongs, and the first identifier area is composed of the first sub-area and the second sub-area.

[0010] Optionally, the device is further configured to: obtain the task pulling request through a remote call framework, and send the task pulling request to each of the group of clusters through the remote call framework, where the remote call framework represents a default call framework of the workflow engine; obtain a task processing result corresponding to the task pulling request from the service client through the Hypertext Transfer Protocol; and send the task processing result to a second cluster through the remote call framework, where the second cluster represents a cluster in the first cluster where the task processing result has appeared.

[0011] Optionally, the device is configured to obtain a task processing result corresponding to the task pulling request from the service client through the Hypertext Transfer Protocol in the following manner: when the target task related to the first cluster is a first task and the first task has been executed successfully, obtain the task processing result indicating that the first task has been executed successfully from the service client through the Hypertext Transfer Protocol; when the target task related to the first cluster is a second task and the second task has been executed failed, obtain the task processing result indicating that the second task has been executed failed from the service client through the Hypertext Transfer Protocol.

[0012] Optionally, the device is configured to send the task processing result to the second cluster through the remote call framework in the following manner: parse the task processing result received each time to determine a second task identifier, where the second task identifier represents a task identifier where the task processing result has appeared; determine the second cluster according to the second task identifier, and send the task processing result to the second cluster.

[0013] Optionally, the device is further configured to: after sending the task processing result to the second cluster through the remote call framework, when the second cluster receives the task processing result, set the target process node of the second cluster to the ended state, where the target process node being in the ended state indicates that the target process instance has completed the target task; when there is a subsequent process node in the second cluster, set the subsequent process node to the to-be-activated state, where the subsequent process node represents a node adjacent to the target process node in the target process instance and that has not been executed yet.

[0014] Optionally, the device is further configured to: connect to a target service proxy using a software development kit, where when the workflow engine is configured to use the software development kit, the service client is allowed to directly connect to a cluster, the target service proxy is regarded as the target main cluster to which the service client connects using the software development kit, and the set of clusters is regarded as a set of sub-clusters of the target main cluster; connect to an initial cluster and a replica cluster through the target service proxy, where the same process instance is pre-deployed in the initial cluster and the replica cluster, and the set of sub-clusters includes the initial cluster and the replica cluster; modify the process instance deployed in the replica cluster to obtain the updated replica cluster, where the updated replica cluster modifies some process nodes relative to the initial cluster; when the workflow engine meets a preset cluster switching condition, replace the initial cluster with the updated replica cluster.

[0015] According to another aspect of the embodiments of the present application, there is also provided a computer-readable storage medium storing a computer program, where the computer program is configured to execute the above-mentioned processing method of the process node when running.

[0016] According to another aspect of the embodiments of the present application, there is provided a computer program product or a computer program, the computer program product or the computer program including computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, causing the computer device to execute the processing method of the process node as described above.

[0017] According to another aspect of the embodiments of the present application, there is also provided an electronic device including a memory and a processor, where a computer program is stored in the memory, and the processor is configured to execute the above-mentioned processing method of the process node through the computer program.

[0018] In an embodiment of the present application, a task pulling request sent by a service client in a workflow engine is obtained. The task pulling request indicates that the service client allows the execution of a target task. The task pulling request is sent to a group of clusters in the workflow engine, and a first cluster is determined according to the feedback results of the group of clusters. The first cluster is a cluster in the group of clusters where the target process instance is deployed and the target process node is in a to-be-activated state. The target process node being in a to-be-activated state means that the target process instance is waiting to execute the target task. A first task identifier is sent to the service client to instruct the service client to execute the target task according to the first task identifier, and the target process node is set to the activated state. The feedback result includes the first task identifier, and the first task identifier is used to instruct the service client to execute the target task related to the first cluster. The target process node being in the activated state means that the target process instance is executing the target task. By adding a proxy layer in front of the access layer and using the proxy layer to complete the task data forwarding between the service client and the group of clusters, the purpose of building a multi-cluster architecture for task processing is achieved, thereby realizing the dynamic expansion of the workflow engine, improving the processing efficiency of process nodes, and enriching the processing methods of process nodes. Furthermore, the technical problem that the processing efficiency of process nodes in the cluster is difficult to guarantee and the processing methods of process nodes are not flexible enough due to the inability of the cluster to achieve dynamic scaling is solved.

[0019] In addition, by modifying the operation interaction protocol, the task processing results can be converged uniformly and proxied to different clusters as needed, increasing flexibility, controllability, and observability.

[0020] On the other hand, by modifying the task identifier encoding rule and adding a cluster identifier parsing logic, the problem of task identifier conflicts in a multi-cluster architecture can be solved.

[0021] On yet another hand, by shunting the task pulling request through the proxy layer, the short board effect caused by request timeouts in a multi-cluster mode is avoided, and the activation response efficiency of the tasks corresponding to the process nodes is improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] The drawings described herein are used to provide a further understanding of the present application and form a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation to the present application. In the drawings:

[0023] Figure 1 is a schematic diagram of the application environment of an optional method for processing process nodes according to an embodiment of the present application;

[0024] Figure 2 is a flowchart of an optional method for processing process nodes according to an embodiment of the present application;

[0025] Figure 3 It is a schematic diagram of a processing method for an optional process node according to an embodiment of the present application;

[0026] Figure 4 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0027] Figure 5 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0028] Figure 6 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0029] Figure 7 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0030] Figure 8 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0031] Figure 9 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0032] Figure 10 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0033] Figure 11 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0034] Figure 12 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0035] Figure 13 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0036] Figure 14 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0037] Figure 15 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0038] Figure 16 It is a schematic diagram of another processing method for an optional process node according to an embodiment of the present application;

[0039] Figure 17It is a schematic structural diagram of a processing device for an optional process node according to an embodiment of the present application;

[0040] Figure 18 It is a schematic structural diagram of a processed product for an optional process node according to an embodiment of the present application;

[0041] Figure 19 It is a schematic structural diagram of an optional electronic device according to an embodiment of the present application. Detailed implementation manners

[0042] In order to enable those skilled in the art to better understand the solutions of the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present application.

[0043] It should be noted that the terms "first", "second", etc. in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects, and do not necessarily need to describe a specific order or sequence. It should be understood that such data can be interchanged under appropriate circumstances so that the embodiments of the present application described here can be implemented in an order other than those illustrated or described here. In addition, the terms "comprising" and "having" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units does not necessarily need to be limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or are inherent to these processes, methods, products, or devices.

[0044] First, some nouns or terms that appear in the process of describing the embodiments of the present application are applicable to the following explanations:

[0045] Zeebe engine: An open-source distributed workflow engine for microservice orchestration.

[0046] Dynamic scaling: It can dynamically expand and compress the size of the system while the system is running.

[0047] Zeebe-gateway: The gateway access layer of the Zeebe workflow engine.

[0048] Poller proxy layer: The proxy layer that pulls tasks in the workflow engine.

[0049] Client SDK: Client software development kit.

[0050] gRPC: (Google Remote Procedure Calls) is an open-source, high-performance, cross-language, and general RPC open-source software framework. It uses the HTTP / 2 protocol and Proto Buffer as the tool for serialization and deserialization.

[0051] Http: HyperText Transfer Protocol.

[0052] clusterID: The identification ID of the cluster.

[0053] activateJob: A request in the zeebe workflow engine for the client to pull tasks and activate them.

[0054] Requettimeout: The time for request timeout.

[0055] Job: Refers to the task activated and executed in the process instance.

[0056] POD: The container for deploying the zeebe engine node.

[0057] The present application will be described below in conjunction with the embodiments:

[0058] According to one aspect of the embodiments of the present application, a method for processing process nodes is provided. Optionally, in this embodiment, the above method for processing process nodes can be applied to a hardware environment composed of a server 101 and a terminal device 103 as shown in Figure 1 the figure. As shown in Figure 1As shown in the figure, the server 101 is connected to the terminal device 103 through a network and can be used to provide services for the terminal device or the application installed on the terminal device. The application can be a video application, an instant messaging application, a browser application, an educational application, a game application, etc. The database 105 can be set on the server or independently of the server and is used to provide data storage services for the server 101. For example, a game data storage server. The above network can include, but is not limited to: a wired network and a wireless network. Among them, the wired network includes: a local area network, a metropolitan area network, and a wide area network. The wireless network includes: Bluetooth, WIFI, and other networks that implement wireless communication. The terminal device 103 can be a terminal configured with an application and can include, but is not limited to, at least one of the following: a mobile phone (such as an Android mobile phone, an iOS mobile phone, etc.), a laptop computer, a tablet computer, a handheld computer, a MID (Mobile Internet Devices), a PAD, a desktop computer, a smart TV, a smart voice interaction device, a smart home appliance, a vehicle-mounted terminal, an aircraft, a virtual reality (VR) terminal, an augmented reality (AR) terminal, a mixed reality (MR) terminal, and other computer devices. The above server can be a single server, a server cluster composed of multiple servers, or a cloud server.

[0059] Combined with Figure 1 As shown in the figure, the processing method of the above process node can be executed by an electronic device, which can be a terminal device or a server. The processing method of the above process node can be implemented separately by the terminal device or the server, or jointly implemented by the terminal device and the server.

[0060] The above is only an example, and this embodiment is not specifically limited.

[0061] Optionally, as an alternative implementation, as Figure 2 shown in the figure, the processing method of the above process node includes:

[0062] S202, obtaining a task pulling request sent by a service client in a workflow engine, where the task pulling request indicates that the service client allows the execution of a target task;

[0063] Optionally, in this embodiment, the above workflow engine can be understood as the logical layer of an application or application process. In other words, the above workflow engine can be represented as a service-oriented architecture, which can be a component model that links different functional units (referred to as services) of an application through well-defined interfaces and contracts between these services. The interfaces are defined in a neutral manner. The workflow engine enables services built in various systems to interact in a unified and general way. Specifically, it can include, but is not limited to, the Zeebe workflow engine.

[0064] Optionally, in this embodiment, the above service client can be understood as an application or application process. That the service client allows the execution of a target task can be understood as an application or application process executes the above target task through a deployed function or service. The above task pull request can be understood as a task pull request sent by an application or application process in real time or periodically to request pulling a target task for execution from a deployed cluster.

[0065] It should be noted that the application environment involved in the embodiments of this application can be a distributed system formed by connecting a client and multiple nodes (any form of computing device accessing the network, such as a server, user terminal) through network communication.

[0066] Taking the distributed system as a blockchain system as an example, Figure 3 is a schematic diagram of a processing method for an optional process node according to an embodiment of this application. Refer to Figure 3 , an optional structural diagram of the distributed system 100 provided by the embodiments of this application applied to a blockchain system, formed by multiple nodes 200 (any form of computing device accessing the network, such as a server, user terminal) and a client 300. A peer-to-peer network is formed between the nodes. The peer-to-peer protocol is an application layer protocol running on top of the Transmission Control Protocol (TCP). In a distributed system, any machine such as a server or a terminal can join and become a node. A node includes a hardware layer, an intermediate layer, an operating system layer, and an application layer.

[0067] Refer to Figure 3 shows the functions of each node in the blockchain system. The functions involved include:

[0068] 1) Routing, a basic function of a node, used to support communication between nodes.

[0069] In addition to the routing function, a node can also have the following functions:

[0070] 2) An application, which is used to be deployed in a blockchain, implements specific services according to actual business requirements, records data related to the implemented functions to form recorded data, carries a digital signature in the recorded data to indicate the source of the task data, and sends the recorded data to other nodes in the blockchain system. When other nodes verify the source and integrity of the recorded data successfully, they add the recorded data to a temporary block. For example, the services implemented by the application include:

[0071] 2.1) A wallet, which is used to provide the function of conducting electronic currency transactions, including initiating a transaction, sending the transaction record of the current transaction to other nodes in the blockchain system. After other nodes verify successfully, as a response to acknowledging the validity of the transaction, they deposit the recorded data of the transaction into the temporary block of the blockchain. Of course, the wallet also supports querying the remaining electronic currency in the electronic currency address.

[0072] 2.2) A shared ledger, which is used to provide functions such as storage, query, and modification of account data. It sends the recorded data of operations on the account data to other nodes in the blockchain system. After other nodes verify its validity, as a response to acknowledging the validity of the account data, they deposit the recorded data into the temporary block and can also send a confirmation to the node that initiated the operation.

[0073] 2.3) A smart contract, which is a computerized protocol that can execute the terms of a certain contract. It is implemented by code deployed on the shared ledger and used to execute under certain conditions. According to actual business requirements, the code is used to complete automated transactions, such as querying the logistics status of goods purchased by a buyer and transferring the buyer's electronic currency to the merchant's address after the buyer signs for the goods. Of course, smart contracts are not limited to executing contracts for transactions but can also execute contracts for processing received information.

[0074] 3) A blockchain includes a series of blocks (Blocks) that are sequentially connected in the order of generation. Once a new block is added to the blockchain, it will not be removed again. The block records the recorded data submitted by nodes in the blockchain system.

[0075] Figure 4 It is a schematic diagram of another optional processing method for process nodes according to an embodiment of the present application. Refer to Figure 4, An optional schematic diagram of the block structure provided by the embodiments of the present application. Each block includes the hash value of the transaction records stored in this block (the hash value of this block), as well as the hash value of the previous block. Each block is connected through the hash value to form a blockchain. In addition, the block may also include information such as the timestamp when the block is generated. A blockchain, essentially a decentralized database, is a series of data blocks generated by using cryptographic methods. Each data block contains relevant information for verifying the validity of the information (anti-counterfeiting) and generating the next block.

[0076] Optionally, in this embodiment, the above-mentioned server may be an independent physical server, or a server cluster or distributed system composed of multiple physical servers. It may also be a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms. The terminal may be a smart phone, a tablet computer, a notebook computer, a desktop computer, a smart speaker, a smart watch, etc., but is not limited thereto. The terminal and the server may be directly or indirectly connected through wired or wireless communication methods, and the present application does not make any restrictions here.

[0077] It should be noted that the present application may include but is not limited to being implemented based on cloud technology:

[0078] Cloud technology is the general term for network technology, information technology, integration technology, management platform technology, application technology, etc. applied based on the cloud computing business model. It can form a resource pool, be used on demand, and is flexible and convenient. Cloud computing technology will become an important support. The background services of the technical network system require a large amount of computing and storage resources, such as video websites, picture websites, and more portal websites. With the highly developed application of the Internet industry, in the future, each item may have its own identification mark and needs to be transmitted to the background system for logical processing. Data at different levels will be processed separately, and various industry data requires a powerful system back-end support, which can only be achieved through cloud computing.

[0079] Cloud computing refers to the delivery and usage model of IT infrastructure, which means obtaining the required resources through the network in a demand-driven and easily scalable manner; in a broad sense, cloud computing refers to the delivery and usage model of services, which means obtaining the required services through the network in a demand-driven and easily scalable manner. Such services can be related to IT and software, the Internet, or other services. Cloud computing is the product of the development and integration of traditional computer and network technologies such as grid computing, distributed computing, parallel computing, utility computing, network storage technologies, virtualization, and load balance.

[0080] With the development of the Internet, real-time data streams, and the diversification of connected devices, as well as the promotion of demands such as search services, social networks, mobile commerce, and open collaboration, cloud computing has developed rapidly. Different from the previous parallel distributed computing, the emergence of cloud computing will drive a revolutionary change in the entire Internet model and enterprise management model conceptually.

[0081] A database, in short, can be regarded as an electronic filing cabinet, that is, a place for storing electronic files. Users can perform operations such as adding, querying, updating, and deleting data in the files. The so-called "database" is a data set stored together in a certain way, shared by multiple users, with the smallest possible redundancy, and independent of application programs.

[0082] A database management system (English: Database Management System, abbreviated as DBMS) is a computer software system designed to manage databases. Generally, it has basic functions such as storage, interception, security guarantee, and backup. Database management systems can be classified according to the database models they support, such as relational, XML (Extensible Markup Language); or according to the types of computers they support, such as server clusters, mobile phones; or according to the query languages they use, such as SQL (Structured Query Language), XQuery; or according to the key points of performance impulse, such as the maximum scale, the highest running speed; or other classification methods. No matter which classification method is used, some DBMS can cross categories. For example, they can support multiple query languages at the same time.

[0083] S204. Send a task pulling request to a group of clusters in the workflow engine, and determine the first cluster according to the feedback results of the group of clusters. The first cluster is the cluster in the group of clusters where the target process instance is deployed and the target process node is in a to-be-activated state. The target process node being in a to-be-activated state means that the target process instance is waiting to execute the target task.

[0084] Optionally, in this embodiment, the above group of clusters includes at least two clusters. The above task pulling request can be understood as sending the above task pulling request to each of the above at least two clusters to pull the above target task. The above feedback result can be understood as the result feedback by each cluster in the above group of clusters according to the above task pulling request, and this feedback result is used to indicate whether there is a target process node in a to-be-activated state in the process instances deployed by each cluster.

[0085] In an exemplary embodiment, Figure 5 It is a schematic diagram of another optional processing method for process nodes according to an embodiment of the present application. As Figure 5 shown, to solve the single-point risk and high-availability problems brought by the single-cluster architecture and provide a more stable workflow service for the business, the above group of clusters can be understood as jointly forming a large cluster, which is composed of 3 sub-clusters. Each cluster allows 18 pods ( Figure 5 node0 to nonde17 shown), each pod has 3 replicas, and the cluster 2 is logically divided into 18 partitions. Each partition includes a Leader node (L) and two Follow nodes (F). For each sub-cluster, because it is multi-partition and multi-replica, the abnormality of a single pod will not affect the normal operation of the cluster. For the entire large cluster, it is composed of 3 geographically separated sub-clusters. Therefore, the unavailability of a single cluster does not affect the overall workflow service. At the same time, to better ensure the stable operation of large customers of the workflow, business isolation can also be performed according to the user's key level, and the cluster where the business is located can be dynamically adjusted as needed.

[0086] Optionally, in this embodiment, the above computer device can orchestrate the business processing tasks to be completed into a target process instance including multiple process nodes, and execute each process node in the target process instance through the workflow engine, so as to automate the execution of business processing tasks, reduce manual execution success, and realize intelligent task execution. The workflow engine is used to execute the process nodes in the target process instance so that each process node in the target process instance is executed. The workflow engine can also perform important function management such as node management, flow management, and process sample management on the target process instance.

[0087] Specifically, the computer device can obtain the node status of the process nodes that have not been completed in the target process instance through the application process in the workflow engine. The node status can refer to the node identifier of the process node and can represent the current status of the target process node. Among them, the node database stores the node status of the process nodes that have not been completed in one or more process instances, and the target process instance belongs to any one of the one or more process instances.

[0088] Furthermore, after the computer device reads the node status of the target process node (i.e., the process node that has not been completed) in the target process instance through the application process in the workflow engine, it can obtain the execution information of the target process node from the status database according to the node status. The execution information can include information such as the execution status of the target process instance to which the target process node belongs, the node type of the target process node, the execution logic, and the execution status. Among them, the status database includes the node status, execution status, and execution information of each process node included in one or more process instances.

[0089] Furthermore, after the computer device obtains the node status of the target process node, it can execute the target process node according to the node status of the target process node through the application process in the workflow engine, so that the target process node reaches the completed execution state. Among them, during the process of the computer device executing the target process node in the target process instance through the application process in the workflow engine, it can obtain the node status in real time or periodically.

[0090] Optionally, in this embodiment, the above-mentioned target process node being in a pending activation state can be understood as the target process instance deployed in the cluster proceeding to this target process node. That is, currently, the task that the target process instance needs to execute is the target task. In other words, the above-mentioned target process instance is waiting to execute the target task.

[0091] In an exemplary embodiment, Figure 6 is a schematic diagram of another optional processing method for process nodes according to an embodiment of the present application, as Figure 6As shown, taking Cluster 1 as an example, it is pre-divided into 8 partitions, and a certain number of process nodes are deployed in each partition to facilitate the execution of application processes in the workflow engine. The workflow engine may include multiple application processes. The computer device can call the application processes in the workflow engine in one of the following two ways or a combination of both. Method 1: Determine the application process according to the business type corresponding to the target process instance. Different application processes may have different business processing capabilities. For example, the application processes include Application Process 1 and Application Process 2. Application Process 1 has the business processing capability for handling business of the financial business type, and Application Process 2 has the business processing capability for handling business of the social business type. Therefore, the application process for executing the target process node can be determined according to the business type corresponding to the target process node, which can improve the accuracy of business processing. Among them, the business processing capabilities of the application process are determined according to the success rate, processing efficiency, etc. of the application process in processing business in the historical time period. Method 2: The computer device can obtain the number of target process nodes of each application process, and determine the application process for executing the target process nodes of the target process instance according to the number of target process nodes, which can achieve load balancing of each application process and improve business processing efficiency.

[0092] In another exemplary embodiment, Figure 7 is a schematic diagram of another optional method for processing process nodes according to an embodiment of the present application, as Figure 7As shown in the figure, the workflow engine is a part of the cloud delivery platform. The cloud delivery platform includes a basic layer, which includes a status database, a node database, and a message queue. The status database is used to store information related to each process instance (such as execution status, execution logic, instance identifier, etc.) and information related to each process node in each process instance (such as execution status, execution logic, node identifier, etc.). The message queue is used to store the to-be-executed process nodes in the node database that need to update their status, that is, the to-be-executed process nodes that have not been completed in the node database, and has a first-in, first-out order. Among them, the cloud delivery platform includes an atomic task layer, which includes a virtual machine task module and a disk task module. The virtual machine task module and the disk task module are used to determine the process instance of the business processing task to be executed. The atomic task layer also includes a node setting module and a deployment execution module. The node setting module is used to set the process nodes in the process instance, and the deployment execution module is used to deploy the execution order of the process nodes in the process instance. Among them, the cloud delivery platform also includes a controller layer, which includes an atomic task controller, a deployment progress tree updater, an orchestration generator, and a workflow engine. Among them, the atomic task controller is used to control the generated process instance, the deployment progress tree updater is used to update the process node tree according to the execution situation of the process instance, the orchestration generator is used to orchestrate and generate a process instance according to the business processing task, and the workflow engine is used to execute the process instance. Among them, the cloud delivery platform also includes an API (that is, a call interface left by the operating system for applications) layer, which stores the business processing interface information in the cloud delivery platform. Among them, the cloud delivery platform can also be connected to a third-party system to manage the business processing in the third-party system.

[0093] For example, a processing task Q is set in the cloud delivery platform. The computer device can determine the execution logic and execution order of the process nodes in the processing task Q through the node setting module and the deployment execution module in the cloud delivery platform. Further, the computer device can orchestrate the processing task Q through the orchestration generator in the cloud delivery platform to generate a process instance q. The process instance q includes four process nodes: material preparation, configuration preparation, application deployment, and service registration. Further, the computer device can manage the execution of the four process nodes in the process instance q through the workflow engine in the cloud delivery platform, so that the four process nodes in the process instance q reach the execution completion state, and then complete the execution management of the process instance q.

[0094] S206, send the first task identifier to the service client to instruct the service client to execute the target task according to the first task identifier and set the target process node to the activated state. The feedback result includes the first task identifier, and the first task identifier is used to instruct the service client to execute the target task related to the first cluster. The target process node being in the activated state indicates that the target process instance is executing the target task.

[0095] Optionally, in this embodiment, the above first task identifier can be understood as a task identifier generated by the first cluster, which is used to indicate that the first cluster currently needs to execute the target task. By sending this first task identifier to the service client, the service client can be made to execute the target task related to the first cluster.

[0096] It should be noted that the above first task identifier may have a field indicating the first cluster, so that the task processing result of the target task related to the first cluster can be returned to the first cluster according to this field through the API interface later.

[0097] In an exemplary embodiment, Figure 8 is a schematic diagram of another optional method for processing a process node according to an embodiment of the present application. As Figure 8 shown, the computer device can read the to-be-executed process nodes in the node database through coroutine 1, coroutine 2... coroutine n (i.e., application processes) in the workflow engine. The node database includes the to-be-executed process nodes of multiple process instances (i.e., the process nodes that have not been executed to completion). The node status of the to-be-executed process nodes in the process instances is stored in the node database. Coroutine 1 in the workflow engine can read the node status (such as the node identifier) of the to-be-executed process node 1 from the node database. Similarly, coroutine 2 in the workflow engine can obtain the node status of the to-be-executed process node 2 from the node database, that is, the coroutines in the workflow engine can respectively read the node status of a to-be-executed process node. Among them, when the coroutine in the workflow engine reads the to-be-executed process node from the node database, the node status of the read to-be-executed process node is removed from the node database. Taking coroutine 1 executing the to-be-executed process node 1 as an example, the process of the workflow engine executing the to-be-executed process node is described in detail. When coroutine 1 in the workflow engine reads the to-be-executed process node 1 from the node database, the node status of the to-be-executed process node can be removed from the node database.

[0098] Further, when the coroutine 1 reads the node status of the to-be-processed process node 1, it can obtain the execution information of the to-be-executed process node 1 in the status database. The execution information may include information such as the execution status, execution logic of the to-be-executed process node, and the execution status of the target process instance to which it belongs. The computer device can execute the to-be-executed process node 1 through the coroutine 1 in the workflow engine according to the execution information of the to-be-executed process node. When the coroutine 1 performs state transition (i.e., state update) on the to-be-executed process node 1 according to the execution information, it can update the initial execution status of the to-be-executed process node in the status database according to the execution status of the to-be-executed process node 1 after the state update. Further, the computer device can detect whether the to-be-executed process node after the state update is in an uncompleted execution state. If the to-be-executed process node after the state update is still in an uncompleted execution state, the node status of the to-be-executed process node after the state update is added to the node database, so that the coroutine in the subsequent workflow engine can continue to read the to-be-executed process node after the state update from the node database, and then the to-be-executed process node after the state update is executed to completion.

[0099] Optionally, in this embodiment, setting the above-mentioned target process node to the activated state can be understood as that the above-mentioned application process is executing the target task corresponding to the above-mentioned target process node. That is, the node status of the target process node is updated to the process node being executed.

[0100] Through this embodiment, by obtaining the task pull request sent by the service client in the workflow engine, where the task pull request indicates that the service client allows the execution of the target task, sending the task pull request to a group of clusters in the workflow engine, and determining the first cluster according to the feedback results of the group of clusters, where the first cluster is the cluster in the group of clusters where the target process instance is deployed and the target process node is in the to-be-activated state, and the target process node being in the to-be-activated state means that the target process instance is waiting to execute the target task, sending the first task identifier to the service client to instruct the service client to execute the target task according to the first task identifier, and setting the target process node to the activated state, where the feedback result includes the first task identifier, and the first task identifier is used to instruct the service client to execute the target task related to the first cluster, and the target process node being in the activated state means that the target process instance is executing the target task. By adding a proxy layer in front of the access layer and using the proxy layer to complete the task data forwarding between the service client and the group of clusters, the purpose of building a multi-cluster architecture for task processing is achieved, thereby realizing the dynamic expansion of the workflow engine, improving the processing efficiency of process nodes, and enriching the processing methods of process nodes. Furthermore, the technical problem that it is difficult to ensure the processing efficiency of process nodes in the cluster and the processing methods of process nodes are not flexible enough due to the inability of the cluster to achieve dynamic scaling is solved.

[0101] As an alternative solution, a task pulling request is sent to a group of clusters in the workflow engine, and a first cluster is determined according to the feedback results of the group of clusters, including: obtaining the number of clusters in the group of clusters, and replicating the task pulling request according to the number of clusters; sending the task pulling request to each cluster in the group of clusters respectively; determining the first cluster according to the feedback results of the group of clusters.

[0102] Optionally, in this embodiment, in the field of distributed computing, cluster technology is widely used in large-scale data processing and high-performance computing tasks. A cluster consists of multiple computing nodes, and each node can execute tasks independently. In some scenarios, it is necessary to distribute and schedule tasks for a group of clusters. By obtaining the number of clusters, it is possible to determine how many clusters the above-mentioned task pulling request needs to be sent to. This process can be achieved through a cluster management system, and the system can obtain the number of clusters by querying cluster registration information or through a network discovery mechanism. After obtaining the number of clusters, tasks can be replicated according to the number, that is, the task pulling request is replicated multiple times, and each request is sent to a cluster. During the task execution process, the cluster will send the feedback result generated based on the task pulling request to the intermediate proxy layer. By collecting the feedback results of the clusters, the first cluster that needs to execute the target task is determined. Specifically, the feedback result of the first cluster may include a first task identifier, and the cluster identifier of the first cluster is recorded through the first task identifier for subsequent processing.

[0103] In an exemplary implementation, Figure 9 is a schematic diagram of another alternative processing method for a process node according to an embodiment of the present application. As Figure 9 shown, an intermediate proxy layer can be deployed before the gateway access layer of the workflow engine to decouple operations related to services of the zeebe workflow engine, such as activatedJob, completeJob / failJob, etc., and control them through the intermediate proxy layer, including but not limited to the following steps:

[0104] S1, Task pulling: The task pulling requests of the same service client will be replicated equally according to the number of current backend clusters to ensure that tasks are obtained from all clusters;

[0105] S2, Task execution: The intermediate proxy layer identifies and forwards according to the cluster to which the specific job in the completeJob / failJob request belongs, so as to accurately forward the task processing result to the corresponding cluster.

[0106] As an alternative solution, determining the first cluster according to the feedback results of a group of clusters includes: receiving the feedback results corresponding to the task pulling requests sent by each cluster, and determining a first task identifier from the feedback results, where the first task identifier includes a cluster identifier character for indicating the first cluster and a partition identifier character for indicating the target partition associated with the target process node in the first cluster; determining the first cluster and the target partition according to the cluster identifier character and the partition identifier character.

[0107] Optionally, in this embodiment, the above first task identifier can be understood as a task identifier generated by the first cluster through a preset task identifier generation logic, and this task identifier can indicate that the task comes from the first cluster.

[0108] It should be noted that the generation method of the above first task identifier can be implemented by modifying the task identifier encoding rule of the workflow engine.

[0109] In an exemplary embodiment, Figure 10 is a schematic diagram of another alternative processing method for a process node according to an embodiment of the present application. As shown in Figure 10 the figure, the intermediate proxy layer can be identified and split through the unique identifiers of different clusters to achieve precise traffic proxy of the intermediate proxy layer. Specifically, by modifying the task identifier generation logic, the last 8 bits of the first 13 bits originally used to identify the partition are reserved for partition identification, and the first 5 bits are changed to cluster ID identification.

[0110] As an alternative solution, the above method further includes: obtaining the initial task identifier generation logic of the workflow engine, where the initial task identifier generation logic indicates that the task identifier in the workflow engine includes a first identifier area and a second identifier area, where the first identifier area indicates the partition to which the corresponding task belongs, and the second identifier area represents the unique identifier of the corresponding task; modifying the initial task identifier generation logic to a target task identifier generation logic, where the target task identifier generation logic indicates that the task identifier corresponding to the workflow engine includes a first identifier area and a second identifier area, the first sub-area of the first identifier area is used to indicate the cluster to which the corresponding task belongs, the second sub-area of the first identifier area is used to indicate the partition to which the corresponding task belongs, and the first identifier area is composed of the first sub-area and the second sub-area.

[0111] Optionally, in this embodiment, the first identifier area corresponding to the above initial task identifier generation logic is used to represent the partition to which the task belongs, and the second identifier area is used to uniquely identify the task, while the first identifier area corresponding to the above target task identifier generation logic is used to represent the partition and cluster to which the task belongs, and the second identifier area is also used to uniquely identify the task.

[0112] In other words, the difference between the above-mentioned initial task identifier generation logic and the target task identifier generation logic lies in that by further dividing the first identifier area, it is possible to use the first identifier area to identify both the partition corresponding to the task and the cluster corresponding to the task.

[0113] Specifically, taking the zeebe workflow engine as an example, it may include, but is not limited to, modifying the zeebe native ID encoding rule, rewriting the ID generation logic, retaining the last 8 bits of the first 13 bits originally used to identify the partition as the partition identification, and changing the first 5 bits of the first 13 bits to the cluster ID identification. In this way, the cluster where the job is located can be quickly identified through jobID parsing, and then the task can be forwarded at the intermediate proxy layer.

[0114] In addition, in addition to introducing the cluster ID in the source code to modify the encoding rule of the native ID, it is also possible to differentiate each zeebe sub-cluster by modifying the starting step size during the initialization of the zeebe broker: for example, modifying the bytecode object, changing the default starting step size in the zeebe version to be deployed from 0 to 10 billion, and determining that the job comes from a new cluster by the task ID being greater than 10 billion. Compared with modifying the encoding rule of the native ID, the above method can achieve the purpose of not needing to modify the zeebe source code. Only when deploying different zeebe clusters, the bytecode object needs to be modified respectively, and the initial step size in each cluster is differentiated to ensure that the ID range of each cluster falls within different intervals. Modifying the encoding rule of the native ID can save ID resources compared with modifying the bytecode object, facilitate accurately estimating the ID size range of each cluster, avoid ID conflicts resulting in different service serial numbers, and is simple to deploy. When expanding a new cluster each time, there is no need to modify the bytecode object of the zeebe broker.

[0115] In an exemplary embodiment, Figure 11 is a schematic diagram of another optional processing method for a process node according to an embodiment of the present application. As Figure 11 shown, through the parsing of the jobID, "00001" indicates the cluster with a cluster ID of 1, and "00000010" indicates the partition with a partition ID of 2, so as to quickly identify the cluster and partition corresponding to the jobID (par2-rep1-L), and then forward the task at the proxy layer.

[0116] As an alternative solution, the above method further includes: obtaining a task pulling request through a remote call framework, and sending the task pulling request to a group of clusters respectively through the remote call framework, where the remote call framework represents the default call framework of the workflow engine; obtaining a task processing result corresponding to the task pulling request from a service client through the Hypertext Transfer Protocol; and sending the task processing result to a second cluster through the remote call framework, where the second cluster represents the cluster in the first cluster where the task processing result has appeared.

[0117] Optionally, in this embodiment, the above remote call framework may be, but is not limited to, gRPC, a high-performance and open-source Remote Procedure Call (RPC) framework. It is based on the HTTP / 2 protocol and uses Protocol Buffers as the data transmission format, enabling efficient communication and service calls across different platforms. gRPC supports multiple programming languages and provides powerful features such as bidirectional streaming, authentication, load balancing, etc., making it the preferred remote call framework in many large-scale systems. gRPC supports multiplexing and header compression, which can reduce network latency and improve transmission efficiency. It can achieve cross-platform communication between different languages. gRPC supports bidirectional streaming communication, where the client and server can send and receive data simultaneously to achieve real-time interaction. It supports strongly typed definitions, improving data consistency and reliability. It provides pluggable authentication and load balancing mechanisms, allowing for selection of appropriate authentication and load balancing solutions according to requirements.

[0118] Optionally, in this embodiment, the above task pulling request can be understood as being sent by the service client to the middle proxy layer through the gRPC protocol. Then the middle proxy layer copies the task pulling request and sends the above task pulling request to a group of clusters respectively through the gRPC protocol. When the service client completes the processing of the target task, the task processing result is not sent using the gRPC protocol anymore. Instead, the task processing result carrying the first task identifier is sent to the interface service through the Hypertext Transfer Protocol. Then the interface service identifies the first task identifier to send the task processing result to the corresponding cluster, facilitating the cluster to update the node status of the process instance in a timely manner.

[0119] It should be noted that the above second cluster represents the cluster in the first cluster where the task has been submitted to the service client and the service client has completed the task. Among them, the above completed execution may include, but is not limited to, successful execution or failed execution.

[0120] In an exemplary embodiment, Figure 12 is a schematic diagram of another alternative method for processing a process node according to an embodiment of the present application, as Figure 12As shown in the figure, the intermediate proxy layer obtains the task pulling requests corresponding to jobtype-A, jobtype-B, jobtype-C, and jobtype-D from the service client through gRPC and sends them to a group of clusters respectively through gRPC. When the service client generates a task processing result, the intermediate proxy layer obtains the task processing result corresponding to the task pulling request from the service client through http, and then sends the task processing result to the second cluster (the cluster in which the task processing result appears in cluster 1 and / or cluster 2) in the group of clusters through gRPC.

[0121] As an optional solution, obtaining the task processing result corresponding to the task pulling request from the service client through the Hypertext Transfer Protocol includes: when the target task related to the first cluster is the first task and the first task has been executed successfully, obtaining the task processing result indicating that the first task has been executed successfully from the service client through the Hypertext Transfer Protocol; when the target task related to the first cluster is the second task and the second task has been executed failed, obtaining the task processing result indicating that the second task has been executed failed from the service client through the Hypertext Transfer Protocol.

[0122] Optionally, in this embodiment, the above task processing result includes that the task is executed successfully or the task is executed failed. For example, completeJob indicates that the task is executed successfully, and failJob indicates that the task is executed failed. That is to say, when the intermediate proxy layer obtains the completeJob message associated with cluster 1 through an http request, it can be determined that the target task indicated by the target process node associated with cluster 1 has been executed successfully. At this time, the node state of the target process node can be updated from the activated state to the completed state. When the intermediate proxy layer obtains the failJob message associated with cluster 2 through an http request, it can be determined that the target task indicated by the target process node associated with cluster 2 has been executed failed. At this time, the node state of the target process node can be updated from the activated state to the failed state.

[0123] As an optional solution, sending the task processing result to the second cluster through the remote call framework includes: parsing each received task processing result to determine the second task identifier, where the second task identifier represents the task identifier for which the task processing result has appeared; determining the second cluster according to the second task identifier and sending the task processing result to the second cluster.

[0124] Optionally, in this embodiment, the logic for parsing each received task processing result can be associated with the foregoing task identifier generation logic, that is, by parsing the task processing result, the second task identifier is obtained, and by identifying the second task identifier, the cluster and partition corresponding to the task processing result are determined.

[0125] In an exemplary embodiment, Figure 13 is a schematic diagram of another optional processing method for a process node according to an embodiment of the present application. For example, Figure 13 shown, taking the target task to be currently executed by the service client as jobtype-A, includes but is not limited to the following steps:

[0126] S1, the service client sends a task pulling request to the intermediate proxy layer (Poller service) through gRPC, indicating that the current service client is allowed to execute 10 target tasks;

[0127] S2, the intermediate proxy layer (Poller service) obtains the number of currently associated clusters, including but not limited to Cluster 1 and Cluster 2, and duplicates the task pulling request;

[0128] S2-1, the intermediate proxy layer (Poller service) sends a task pulling request to the cluster gateway of Cluster 1 through gRPC, indicating that the current service client can execute 10 jobtype-A;

[0129] S2-2, the intermediate proxy layer (Poller service) sends a task pulling request to the cluster gateway of Cluster 2 through gRPC, indicating that the current service client can execute 10 jobtype-A;

[0130] S3-1, the cluster gateway of Cluster 1 informs each partition of Cluster 1 that the current task to be executed is a target task and requests each partition to report tasks;

[0131] S3-2, the cluster gateway of Cluster 2 informs each partition of Cluster 2 that the current task to be executed is a target task and requests each partition to report tasks;

[0132] S4-1, Partition 1 of Cluster 1 reports to the cluster gateway of Cluster 1 that it currently needs to execute 10 jobtype-A;

[0133] S4-2, Partition 1 of Cluster 2 reports to the cluster gateway of Cluster 2 that it currently needs to execute 3 jobtype-A;

[0134] S5-1, the cluster gateway of Cluster 1 reports to the intermediate proxy layer (Poller service) that Partition 1 of Cluster 1 currently needs to execute 10 jobtype-A;

[0135] S5-2, the cluster gateway of Cluster 2 reports to the intermediate proxy layer (Poller service) that Partition 1 of Cluster 2 currently needs to execute 3 jobtype-A;

[0136] S6-1. The intermediate proxy layer (Poller service) reports to the service client that Partition 1 of Cluster 1 needs to execute 10 jobtype-A jobs.

[0137] S6-2. The intermediate proxy layer (Poller service) reports to the service client that Partition 1 of Cluster 3 needs to execute 3 jobtype-A jobs.

[0138] As an optional solution, after sending the task processing result to the second cluster through the remote call framework, the above method further includes: when the second cluster receives the task processing result, setting the target process node of the second cluster to the ended state, where the target process node being in the ended state means that the target process instance has completed the target task; when there are subsequent process nodes in the second cluster, setting the subsequent process nodes to the to-be-activated state, where the subsequent process nodes refer to the nodes adjacent to the target process node in the target process instance and that have not been executed yet.

[0139] Optionally, in this embodiment, the above ended state means that the target process node has been executed successfully or failed, and it is necessary to execute subsequent process nodes or abort the target process instance. The above subsequent process nodes can be understood as the process nodes after the target process node. When the target process node is executed, the subsequent process nodes are adjusted to the to-be-activated state and wait for the service client to pull tasks.

[0140] It should be noted that the nodes adjacent to the target process node in the target process instance and that have not been executed yet can be understood as the subsequent process nodes are the nodes corresponding to the tasks that need to be executed after the target task corresponding to the target process node in the target process instance is completed.

[0141] As an optional solution, the above method further includes: connecting to the target service proxy using the software development kit. When the workflow engine is set to use the software development kit, the service client is allowed to directly connect to a cluster, and the target service proxy is regarded as the target main cluster to which the service client connects using the software development kit, and a group of clusters is regarded as a group of sub-clusters of the target main cluster; connecting to the initial cluster and the replica cluster through the target service proxy, where the initial cluster and the replica cluster have the same process instance pre-deployed, and a group of sub-clusters includes the initial cluster and the replica cluster; modifying the process instance deployed in the replica cluster to obtain an updated replica cluster, where the updated replica cluster has modified some process nodes compared to the initial cluster; when the workflow engine meets the preset cluster switching condition, replacing the initial cluster with the updated replica cluster.

[0142] Optionally, in this embodiment, when the above workflow engine is set to use a software development kit, the service client is allowed to directly connect to a cluster. It can be understood that when using the default software development kit for business access, the default software development kit only allows a single connection to one workflow engine. Therefore, only one cluster can run in the workflow engine. By setting the target service proxy as an intermediate proxy layer and using the software development kit to connect to the service proxy, the service proxy is used as the target main cluster in the workflow engine that the software development kit is singly connected to, so as to achieve dynamic expansion of the workflow engine.

[0143] Optionally, in this embodiment, the above initial cluster and replica cluster can be understood as clusters that deploy the same process instances and run as backups for each other in the workflow engine. Connecting the initial cluster and the replica cluster through the target service proxy can endow the workflow engine with natural disaster tolerance capabilities.

[0144] Exemplarily, Figure 14 is a schematic diagram of another optional method for processing a process node according to an embodiment of the present application. As Figure 14 shown, taking the zeebe engine as an example, since the zeebe engine is multi-node, multi-partition, and multi-replica, the cluster itself has some pod-level disaster tolerance capabilities. However, when all pods are abnormal (for example, if the deployed pod nodes are all in the same availability zone and the availability zone is abnormal, it will cause all pods to be unable to provide services), it will still lead to the unavailability of the entire workflow service. The multi-cluster architecture involved in the present application can achieve disaster tolerance capabilities at the zeebe sub-cluster level. When the intermediate proxy layer (L4) detects that the backend main cluster (corresponding to the aforementioned initial cluster) is unhealthy, it will automatically import the newly accessed process into the healthy backup cluster (corresponding to the aforementioned replica cluster) within seconds to ensure the normal operation of the business.

[0145] Optionally, in this embodiment, modifying the process instances deployed in the replica cluster can be understood as updating certain clusters. Since two identical clusters are deployed, therefore, the process instances of one cluster can be adjusted first. After one cluster is updated, the other cluster can be updated to complete the update and upgrade of the process instances without interrupting the service.

[0146] Exemplarily, Figure 15 is a schematic diagram of another optional method for processing a process node according to an embodiment of the present application. As Figure 15As shown, the business access of the Zeebe workflow needs to go through the Zeebe client SDK, but this SDK only supports a single-connected workflow engine. At the same time, the broker version iteration of the Zeebe engine does not support in-place upgrading. These two limitations make the version upgrade of the Zeebe cluster not smooth enough. The multi-cluster architecture of this application can meet the requirement of smooth business upgrade. It only needs to add the Zeebe engine to be upgraded as a sub-cluster to the large cluster, and at the same time enable the policy at the service proxy layer: newly created processes are published to the new version cluster. In this way, instances in the processes of the new and old clusters can continue to pull tasks at the service proxy layer, and at the same time, the existing / new tasks can be recognized by the API service as belonging to the cluster, and correct routing and forwarding can be completed. Finally, the smooth upgrade of the business is ensured. Figure 15 (upgraded from version 0.26.0 to version 1.2.4 as shown).

[0147] The following is a further explanatory description of this application in combination with specific examples:

[0148] This application can solve the single-point risk brought by the single-cluster architecture, avoid high-availability problems, and provide a more stable workflow service for the business. As Figure 5 shown, the large cluster is allowed to be composed of 3 sub-clusters, each cluster has 18 pods, and each pod has 3 replicas: for each sub-cluster, because it is multi-partition and multi-replica, the abnormality of a single pod will not affect the normal operation of the cluster; for the entire large cluster, because it is composed of 3 Zeebe sub-clusters deployed in different locations, the abnormality of a single availability zone does not affect the overall workflow service. At the same time, to better ensure the stable operation of large customers of the workflow, business isolation can also be carried out according to the key level of users, and the cluster where the business is located can be dynamically adjusted as needed.

[0149] It should be noted that in terms of the differential deployment of the Zeebe cluster, in addition to introducing ClusteId in the source code to modify the encoding rule of the native ID, each Zeebe sub-cluster can also be differentiated by modifying the starting step size during the initialization of the Zeebe broker:

[0150] Figure 16 is a schematic diagram of another optional processing method for process nodes according to an embodiment of this application. As Figure 16As shown, for example, use Javassist to modify the bytecode object, change the default starting step size in the Zeebe version to be deployed from 0 to 10 billion, and determine that a job comes from the new cluster by an ID greater than 10 billion. Modifying the bytecode object does not require modifying the Zeebe source code. Only when deploying different Zeebe clusters, use Javassist to modify the bytecode object respectively to differentiate the initial step size in each cluster, ensuring that the ID range of each cluster falls within different intervals; modifying the Zeebe source code can avoid waste of ID resources, accurately estimate the ID size range of each cluster, and avoid ID conflicts that cause different services to be misaligned. At the same time, the deployment is simple, and there is no need to modify the bytecode of the Zeebe broker when expanding a new cluster each time.

[0151] It can be understood that in the specific implementation of this application, it involves data such as user information. When the above embodiments of this application are applied to specific products or technologies, user permission or consent needs to be obtained, and the collection, use, and processing of relevant data need to comply with relevant laws, regulations, and standards in relevant countries and regions.

[0152] It should be noted that for the foregoing method embodiments, for the sake of simple description, they are all expressed as a series of action combinations. However, those skilled in the art should know that this application is not limited by the described action sequence, because according to this application, certain steps can be performed in other sequences or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

[0153] According to another aspect of the embodiments of this application, there is also provided a processing device for a process node for implementing the above-mentioned processing method of the process node. As Figure 17 shown, the device includes:

[0154] An obtaining module 1702, configured to obtain a task pulling request sent by a service client in a workflow engine, where the task pulling request indicates that the service client allows the execution of a target task;

[0155] A processing module 1704, configured to send a task pulling request to a group of clusters in the workflow engine, and determine a first cluster according to the feedback results of the group of clusters, where the first cluster is a cluster in the group of clusters where a target process instance is deployed and the target process node is in a to-be-activated state, and the target process node being in a to-be-activated state means that the target process instance is waiting to execute the target task;

[0156] A setting module 1706 is configured to send a first task identifier to a service client to instruct the service client to execute a target task according to the first task identifier and set the target process node to an activated state. The feedback result includes the first task identifier, which is used to instruct the service client to execute the target task related to the first cluster. The target process node being in the activated state indicates that the target process instance is executing the target task.

[0157] As an alternative solution, the apparatus is configured to send a task pull request to a group of clusters in a workflow engine and determine the first cluster according to the feedback results of the group of clusters in the following manner: obtain the number of clusters in the group of clusters and copy the task pull request according to the number of clusters; send the task pull request to each cluster in the group of clusters respectively; and determine the first cluster according to the feedback results of the group of clusters.

[0158] As an alternative solution, the apparatus is configured to determine the first cluster according to the feedback results of the group of clusters in the following manner: receive the feedback results corresponding to the task pull request sent by each cluster and determine the first task identifier from the feedback results, where the first task identifier includes a cluster identifier character used to indicate the first cluster; and determine the first cluster according to the first task identifier.

[0159] As an alternative solution, the apparatus is configured to determine the first cluster according to the feedback results of the group of clusters in the following manner, including: receive the feedback results corresponding to the task pull request sent by each cluster and determine the first task identifier from the feedback results, where the first task identifier includes a cluster identifier character used to indicate the first cluster and a partition identifier character used to indicate the target partition associated with the target process node in the first cluster; and determine the first cluster and the target partition according to the cluster identifier character and the partition identifier character.

[0160] As an alternative solution, the apparatus is further configured to: obtain the initial task identifier generation logic of the workflow engine, where the initial task identifier generation logic indicates that the task identifier in the workflow engine includes a first identifier area and a second identifier area, where the first identifier area indicates the partition to which the corresponding task belongs and the second identifier area represents the unique identifier of the corresponding task; and modify the initial task identifier generation logic to a target task identifier generation logic, where the target task identifier generation logic indicates that the task identifier corresponding to the workflow engine includes a first identifier area and a second identifier area, a first sub - area of the first identifier area is used to indicate the cluster to which the corresponding task belongs, a second sub - area of the first identifier area is used to indicate the partition to which the corresponding task belongs, and the first identifier area is composed of the first sub - area and the second sub - area.

[0161] As an alternative, the device is further configured to: obtain a task pulling request through a remote call framework, and send the task pulling request to a group of clusters respectively through the remote call framework, where the remote call framework represents the default call framework of the workflow engine; obtain a task processing result corresponding to the task pulling request from a service client through the Hypertext Transfer Protocol; and send the task processing result to a second cluster through the remote call framework, where the second cluster represents the cluster in the first cluster where the task processing result has appeared.

[0162] As an alternative, the device is configured to obtain a task processing result corresponding to the task pulling request from a service client through the Hypertext Transfer Protocol in the following manner: when the target task related to the first cluster is the first task and the first task has been executed, obtain a task processing result indicating that the first task has been successfully executed from the service client through the Hypertext Transfer Protocol; when the target task related to the first cluster is the second task and the second task has failed, obtain a task processing result indicating that the second task has failed from the service client through the Hypertext Transfer Protocol.

[0163] As an alternative, the device is configured to send the task processing result to the second cluster through the remote call framework in the following manner: parse the task processing result received each time to determine a second task identifier, where the second task identifier represents the task identifier where the task processing result has appeared; determine the second cluster according to the second task identifier, and send the task processing result to the second cluster.

[0164] As an alternative, the device is further configured to: after sending the task processing result to the second cluster through the remote call framework, when the second cluster receives the task processing result, set the target process node of the second cluster to the ended state, where the target process node being in the ended state means that the target process instance has ended the target task; when there is a subsequent process node in the second cluster, set the subsequent process node to the to-be-activated state, where the subsequent process node represents the node adjacent to the target process node in the target process instance and that has not been executed yet.

[0165] As an alternative, the apparatus is further configured to: connect to a target service proxy using a software development kit (SDK). When the workflow engine is configured to use the SDK, the service client is allowed to directly connect to a cluster, the target service proxy is regarded as the target main cluster to which the service client connects using the SDK, and a group of clusters is regarded as a group of sub-clusters of the target main cluster; connect an initial cluster and a replica cluster through the target service proxy, where the same process instances are pre-deployed in the initial cluster and the replica cluster, and the group of sub-clusters includes the initial cluster and the replica cluster; modify the process instances deployed in the replica cluster to obtain an updated replica cluster, where the updated replica cluster modifies some process nodes compared to the initial cluster; and replace the initial cluster with the updated replica cluster when the workflow engine meets a preset cluster switching condition.

[0166] In the embodiments of the present application, the term "module" or "unit" refers to a computer program or a part of a computer program with a predetermined function, which works together with other related parts to achieve a predetermined goal, and can be fully or partially implemented by using software, hardware (such as a processing circuit or a memory), or a combination thereof. Similarly, one processor (or multiple processors or memories) can be used to implement one or more modules or units. In addition, each module or unit can be a part of an overall module or unit that includes the function of that module or unit.

[0167] Regarding the apparatus in the above embodiments, the specific manners in which each module performs operations have been described in detail in the embodiments related to the method, and will not be elaborated herein.

[0168] According to one aspect of the present application, there is provided a computer program product, which includes a computer program.

[0169] The serial numbers of the embodiments of the present application above are only for description and do not represent the advantages or disadvantages of the embodiments.

[0170] Figure 18 Schematically shown is a block diagram of a computer system of an electronic device for implementing the embodiments of the present application.

[0171] It should be noted that Figure 18 The computer system 1800 of the electronic device shown is only an example and should not impose any limitation on the functions and usage scope of the embodiments of the present application.

[0172] As Figure 18As shown, computer system 1800 includes a central processing unit 1801 (CPU), which can perform various appropriate actions and processes according to a program stored in a read-only memory 1802 (ROM) or a program loaded from a storage section 1808 into a random access memory 1803 (RAM). In the random access memory 1803, various programs and data required for system operation are also stored. The central processing unit 1801, the read-only memory 1802, and the random access memory 1803 are connected to each other via a bus 1804. An input / output interface 1805 (Input / Output interface, i.e., I / O interface) is also connected to the bus 1804.

[0173] The following components are connected to the input / output interface 1805: an input section 1806 including a keyboard, a mouse, etc.; an output section 1807 including, for example, a cathode ray tube (CRT), a liquid crystal display (LCD), etc. and a speaker, etc.; a storage section 1808 including a hard disk, etc.; and a communication section 1809 including a network interface card such as a local area network card, a modem, etc. The communication section 1809 performs communication processing via a network such as the Internet. A drive 1810 is also connected to the input / output interface 1805 as needed. A removable medium 1811, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 1810 as needed so that a computer program read from it can be installed into the storage section 1808 as needed.

[0174] In particular, according to an embodiment of the present application, the processes described in each method flowchart can be implemented as a computer software program. For example, an embodiment of the present application includes a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes program codes for performing the methods shown in the flowcharts. In such an embodiment, the computer program can be downloaded and installed from a network via the communication section 1809, and / or installed from the removable medium 1811. When the computer program is executed by the central processing unit 1801, various functions defined in the system of the present application are executed.

[0175] In such an embodiment, the computer program can be downloaded and installed from a network via the communication section 1809, and / or installed from the removable medium 1811. When the computer program is executed by the central processing unit 1801, various functions provided by the embodiment of the present application are executed.

[0176] According to another aspect of the embodiments of the present application, there is also provided an electronic device for implementing the processing method of the above process nodes. The electronic device may be Figure 1 the terminal device or server shown. In this embodiment, the electronic device is taken as an example of the terminal device for illustration. As Figure 19 shown, the electronic device includes a memory 1902 and a processor 1904. A computer program is stored in the memory 1902, and the processor 1904 is configured to execute the steps in any of the above method embodiments through the computer program.

[0177] Optionally, in this embodiment, the above electronic device may be at least one network device among multiple network devices in a computer network.

[0178] Optionally, in this embodiment, the above processor may be configured to execute the methods in the embodiments of the present application through a computer program.

[0179] Optionally, those of ordinary skill in the art can understand that Figure 19 the structure shown is only schematic, Figure 19 and it does not limit the structure of the above electronic device. For example, the electronic device may further include more or fewer components (such as a network interface, etc.) than those shown in Figure 19 , or have a different configuration from that shown in Figure 19 .

[0180] Among them, the memory 1902 can be used to store software programs and modules, such as the program instructions / modules corresponding to the processing method and device of the process nodes in the embodiments of the present application. The processor 1904 executes various functional applications and data processing by running the software programs and modules stored in the memory 1902, that is, implements the above processing method of the process nodes. The memory 1902 may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memories, or other non-volatile solid-state memories. In some instances, the memory 1902 may further include a memory remotely provided with respect to the processor 1904, and these remote memories can be connected to the terminal through a network. Examples of the above network include but are not limited to the Internet, enterprise intranet, local area network, mobile communication network, and their combinations. Among them, the memory 1902 can specifically but not limitedly be used for information such as task data. As an example, as Figure 19 shown, the above memory 1902 may include, but is not limited to, the acquisition module 1702, the processing module 1704, and the setting module 1706 in the processing device of the above process nodes. In addition, it may further include, but is not limited to, other module units in the processing device of the above process nodes, which will not be elaborated in this example.

[0181] Optionally, the above-mentioned transmission device 1906 is used to receive or send data via a network. Specific examples of the above-mentioned network may include a wired network and a wireless network. In one example, the transmission device 1906 includes a network adapter (Network Interface Controller, NIC), which can be connected to other network devices and routers through network cables, so as to communicate with the Internet or a local area network. In one example, the transmission device 1906 is a Radio Frequency (RF) module, which is used to communicate with the Internet wirelessly.

[0182] In addition, the above-mentioned electronic device further includes: a display 1908, which is used to display the above-mentioned target process instance; and a connection bus 1910, which is used to connect each module component in the above-mentioned electronic device.

[0183] In other embodiments, the above-mentioned terminal device or server can be a node in a distributed system. Among them, the distributed system can be a blockchain system, and the blockchain system can be a distributed system formed by connecting the multiple nodes in the form of network communication. Among them, the nodes can form a peer-to-peer network, and any form of computing device, such as electronic devices such as servers and terminals, can become a node in the blockchain system by joining the peer-to-peer network.

[0184] According to one aspect of the present application, there is provided a computer-readable storage medium. The processor of the electronic device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the electronic device executes the processing method of the process node provided in various optional implementation manners of the above-mentioned processing of the process node.

[0185] Optionally, in this embodiment, the above-mentioned computer-readable storage medium can be set to store the methods for executing the embodiments of the present application.

[0186] Optionally, in this embodiment, those of ordinary skill in the art can understand that all or part of the steps in the above-mentioned various methods can be completed by instructing the relevant hardware of the terminal device through a program, and the program can be stored in a computer-readable storage medium. The storage medium may include: a flash drive, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk or an optical disc, etc.

[0187] The serial numbers of the above-mentioned embodiments of the present application are only for description and do not represent the advantages or disadvantages of the embodiments.

[0188] If the integrated units in the above embodiments are implemented in the form of software functional units and sold or used as independent products, they can be stored in the above computer-readable storage medium. Based on such understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of this technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions for causing one or more electronic devices to execute all or part of the steps of the methods described in various embodiments of this application.

[0189] In the above embodiments of this application, the descriptions of each embodiment have their own emphases. For the parts not detailed in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0190] In the several embodiments provided by this application, it should be understood that the disclosed application program can be implemented in other ways. Among them, the device embodiments described above are only illustrative. For example, the division of the units is only a logical function division. In actual implementation, there can be other division methods. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the displayed or discussed couplings or direct couplings or communication connections to each other can be through some interfaces. The indirect couplings or communication connections of units or modules can be in electrical or other forms.

[0191] The units described as separate components may or may not be physically separated. The components shown as units may or may not be physical units, that is, they can be located in one place, or distributed to multiple network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0192] In addition, the functional units in each embodiment of this application can be integrated in a processing unit, or each unit can exist physically alone, or two or more units can be integrated in one unit. The above integrated units can be implemented in the form of hardware or in the form of software functional units.

[0193] The above are only the preferred embodiments of this application. It should be noted that for those of ordinary skill in the art, without departing from the principle of this application, several improvements and refinements can still be made, and these improvements and refinements should also be regarded as the protection scope of this application.

Claims

1. A method for processing process nodes, characterized in that, it includes: Obtain a task pulling request sent by a service client in a workflow engine, where the task pulling request indicates that the service client allows the execution of a target task; Send the task pulling request to a group of clusters in the workflow engine, and determine a first cluster according to the feedback results of the group of clusters, where the first cluster is a cluster in the group of clusters where a target process instance is deployed and the target process node is in a to-be-activated state, and the target process node being in the to-be-activated state means that the target process instance is waiting to execute the target task; Send a first task identifier to the service client to instruct the service client to execute the target task according to the first task identifier, and set the target process node to an activated state, where the feedback result includes the first task identifier, and the first task identifier is used to instruct the service client to execute the target task related to the first cluster, and the target process node being in the activated state means that the target process instance is executing the target task.

2. The method according to claim 1, characterized in that, the sending the task pulling request to a group of clusters in the workflow engine and determining a first cluster according to the feedback results of the group of clusters includes: Obtain the number of clusters in the group of clusters, and copy the task pulling request according to the number of clusters; Send the task pulling request to each cluster in the group of clusters respectively; Determine a first cluster according to the feedback results of the group of clusters.

3. The method according to claim 2, characterized in that, the determining a first cluster according to the feedback results of the group of clusters includes: Receive the feedback results corresponding to the task pulling request sent by each cluster, and determine the first task identifier from the feedback results, where the first task identifier includes a cluster identifier character for indicating the first cluster and a partition identifier character for indicating a target partition associated with the target process node in the first cluster; Determine the first cluster and the target partition according to the cluster identifier character and the partition identifier character.

4. The method according to claim 3, characterized in that, the method further includes: Obtain the initial task identifier generation logic of the workflow engine, where the initial task identifier generation logic means that the task identifier in the workflow engine includes a first identifier area and a second identifier area, where the first identifier area indicates the partition to which the corresponding task belongs, and the second identifier area represents the unique identifier of the corresponding task; Modify the initial task identifier generation logic to a target task identifier generation logic, where the target task identifier generation logic indicates that the task identifier corresponding to the workflow engine includes the first identifier area and the second identifier area. The first sub-area of the first identifier area is used to indicate the cluster to which the corresponding task belongs, and the second sub-area of the first identifier area is used to indicate the partition to which the corresponding task belongs. The first identifier area is composed of the first sub-area and the second sub-area.

5. The method according to claim 1, wherein, the method further includes: Obtain the task pulling request through the remote call framework, and send the task pulling request to each of the group of clusters through the remote call framework, where the remote call framework represents the default call framework of the workflow engine; Obtain the task processing result corresponding to the task pulling request from the service client through the Hypertext Transfer Protocol; Send the task processing result to the second cluster through the remote call framework, where the second cluster represents the cluster in the first cluster where the task processing result has appeared.

6. The method according to claim 5, wherein, the obtaining the task processing result corresponding to the task pulling request from the service client through the Hypertext Transfer Protocol includes: In the case where the target task related to the first cluster is the first task and the first task has been executed successfully, obtain the task processing result indicating the successful execution of the first task from the service client through the Hypertext Transfer Protocol; In the case where the target task related to the first cluster is the second task and the second task has been executed unsuccessfully, obtain the task processing result indicating the failed execution of the second task from the service client through the Hypertext Transfer Protocol.

7. The method according to claim 5, wherein, the sending the task processing result to the second cluster through the remote call framework includes: Parse the task processing result received each time to determine the second task identifier, where the second task identifier represents the task identifier where the task processing result has appeared; Determine the second cluster according to the second task identifier, and send the task processing result to the second cluster.

8. The method according to claim 5, wherein, after the sending the task processing result to the second cluster through the remote call framework, the method further includes: In the case where the second cluster receives the task processing result, set the target process node of the second cluster to the ended state, where the target process node being in the ended state indicates that the target process instance has completed the target task; In the case where there is a subsequent process node in the second cluster, set the subsequent process node to the to-be-activated state, where the subsequent process node represents the node adjacent to the target process node in the target process instance and has not been executed yet.

9. The method according to claim 1, Characterized in that, The method further includes: Connecting a target service proxy using a software development kit, wherein when the workflow engine is set to use the software development kit, the service client is allowed to directly connect to a cluster, the target service proxy is regarded as the target main cluster to which the service client connects using the software development kit, and the group of clusters is regarded as a group of sub-clusters of the target main cluster; Connecting an initial cluster and a replica cluster through the target service proxy, wherein the same process instances are pre-deployed in the initial cluster and the replica cluster, and the group of sub-clusters includes the initial cluster and the replica cluster; Modifying the process instances deployed in the replica cluster to obtain the updated replica cluster, wherein the updated replica cluster modifies some process nodes relative to the initial cluster; Replacing the initial cluster with the updated replica cluster when the workflow engine meets a preset cluster switching condition.

10. A processing device for process nodes, Characterized in that, It includes: An acquisition module, configured to acquire a task pulling request sent by a service client in a workflow engine, wherein the task pulling request indicates that the service client is allowed to execute a target task; A processing module, configured to send the task pulling request to a group of clusters in the workflow engine and determine a first cluster according to the feedback result of the group of clusters, wherein the first cluster is a cluster in the group of clusters where a target process instance is deployed and the target process node is in a to-be-activated state, and the target process node being in the to-be-activated state means that the target process instance is waiting to execute the target task; A setting module, configured to send a first task identifier to the service client to instruct the service client to execute the target task according to the first task identifier and set the target process node to an activated state, wherein the feedback result includes the first task identifier, the first task identifier is used to instruct the service client to execute the target task related to the first cluster, and the target process node being in the activated state means that the target process instance is executing the target task.

11. A computer-readable storage medium, Characterized in that, The computer-readable storage medium includes a stored computer program, wherein the computer program, when run by an electronic device, executes the method described in any one of claims 1 to 9.

12. A computer program product, including a computer program, Characterized in that, When the computer program is executed by a processor, it implements the steps of the method described in any one of claims 1 to 9.

13. An electronic device, including a memory and a processor, Characterized in that, A computer program is stored in the memory, and the processor is configured to execute the method described in any one of claims 1 to 9 through the computer program.

Images