Scalable workflow engine with stateless orchestrator
By managing workflows and events through a stateless coordinator, the problems of scalability and state management in cross-cloud environments are solved, and the high efficiency, scalability and portability of distributed workflows are achieved.
Patent Information
- Application Number
- CN202010618278.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2020-07-01
- Publication Date
- 2024-11-29
- Estimated Expiration
- 2040-07-01
AI Technical Summary
Existing workflow engines struggle to scale across multi-cloud or hybrid cloud environments, and serverless event management lacks centralized control, making it difficult to obtain status information and impacting workflow scalability and portability.
A stateless coordinator manages workflows and events. Through a combination of coordinator, worker nodes, providers, and databases, a token mechanism ensures secure interaction and state independence between components, allowing for full scalability and portability of distributed workflows.
It achieves stateless management of workflows and events, ensuring the scalability and flexibility of the system, enabling efficient task processing in multi-cloud environments, and avoiding the limitations caused by state dependencies.
Smart Images

Figure CN112348302B_ABST
Abstract
Description
Background Art
[0001] The present disclosure relates to workflow engines, and more particularly to using a stateless orchestrator to run workflows and events. Summary of the invention
[0002] The present invention provides a computer-implemented method, system, and computer program product for running workflows and events using a stateless coordinator. The method may include receiving task data for a first task, wherein the task data is information required to perform the task. The method may also include sending a request for a worker node to a provider, wherein the provider creates a worker node. The method may also include receiving a request for task data from a worker node. The method may also include sending task data to a worker node, wherein the worker node performs the first task. The method may also include receiving a result of performing the first task from the worker node. The method may also include: in response to receiving the result, sending the result to a database.
[0003] The system may have one or more computer processors and may be configured to receive task data for a first task, wherein the task data is information necessary for performing the task. The system may also be configured to send a request for a worker node to a provider, wherein the provider creates the worker node. The system may also be configured to receive a request for task data from a worker node. The system may also be configured to send task data to a worker node, wherein the worker node performs the first task. The system may also be configured to receive a result of performing the first task from a worker node. The system may also be configured to send the result to a database in response to receiving the result.
[0004] The computer program product may include a computer-readable storage medium having program instructions embodied therein, the program instructions being executable by a server to cause the server to perform a method. The method may include receiving task data for a first task, wherein the task data is information required to perform the task. The method may also include sending a request for a worker node to a provider, wherein the provider creates a worker node. The method may also include receiving a request for task data from a worker node. The method may also include sending task data to a worker node, wherein the worker node performs the first task. The method may also include receiving a result of performing the first task from the worker node. The method may also include, in response to receiving the result, sending the result to a database.
[0005] The above summary is not intended to describe each illustrated embodiment or every implementation of the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS
[0006] The accompanying drawings included in this application are incorporated into the specification and form a part of the specification. They illustrate embodiments of the present disclosure and are used to explain the principles of the present disclosure together with the specification. The accompanying drawings are only illustrations of certain embodiments and do not limit the present disclosure.
[0007] Figure 1 Depicted is a flow diagram of a set of operations for running workflows and events using a stateless orchestrator in accordance with some embodiments.
[0008] Figure 2 Depicted is a schematic diagram of an example stateless coordinator environment and interactions between components in accordance with some embodiments.
[0009] Figure 3 Depicted is a block diagram of components of a system for running workflows and events using a stateless orchestrator, according to some embodiments.
[0010] Figure 4 A block diagram of an example computer system is depicted in accordance with some embodiments.
[0011] Figure 5 A cloud computing environment is depicted in accordance with some embodiments.
[0012] Figure 6 Abstract model layers according to some embodiments are depicted.
[0013] Although the present invention is subject to various modifications and alternative forms, details thereof have been shown by way of example in the drawings and will be described in detail. However, it should be understood that it is not intended to limit the present invention to the specific embodiments described. On the contrary, it is intended to cover all modifications, equivalents and alternatives that fall within the spirit and scope of the present invention. DETAILED DESCRIPTION
[0014] The present disclosure relates to workflow engines, and more particularly to using a stateless coordinator to run workflows and events. Although the present disclosure is not necessarily limited to such applications, various aspects of the present disclosure may be understood by discussing various examples using this context.
[0015] Workflow engines can be used to control and supervise the activities and processes of workflows or events. A workflow can be a series of tasks to be performed in order to complete a job or process. The events referred to here can be actions or activities corresponding to a specific process (e.g., keystrokes, mouse clicks, button selections, any type of user selection, etc.). A specific process may include a series of tasks to be performed or completed. In some cases, a workflow engine may have certain extended capabilities, but due to complex integration requirements between various environments, extension or use across multi-cloud or hybrid cloud environments may be difficult. In addition, serverless functions may have scalability, but events may be decentralized (i.e., there is no centralized control / authority), and information about the status of events may not be available. This can cause problems with various workflows, because it may be important to have a clear definition of the current state of the process (e.g., in a workflow or event).
[0016] Distributed workflows can be used to help determine the definition of the current state of a process, but conventional distributed workflows can be based on stateful services (i.e., services that require data to be stored and / or state to be saved) and defined orchestrators. Due to the use of stateful orchestrators and management systems, the full scale-out capabilities of the system (e.g., on-premise systems, cloud systems, etc.) may not be available.
[0017] Additionally, conventional workflow systems may use relational databases to attempt to determine the state of a process, but due to join and locking designs, relational databases may limit the scalability of the workflow engine or system.
[0018] The present disclosure provides a computer-implemented method, system and computer program product to run workflows and events using a stateless coordinator. In some embodiments, the coordinator manages all processes of the system. In order to ensure that the coordinator can be stateless, the system may include various components, including a coordinator, a worker node, a provider and a database. The worker node can perform the actual task defined in the process (e.g., determined / defined according to the workflow and / or event). In some embodiments, the worker node performs a single task at a time. In some embodiments, the provider manages the worker node. The provider can create nodes, delete nodes, and check the status of each node. In some embodiments, the coordinator controls all actions of the provider (e.g., through a defined interface). The database can store or represent information and dependent states of the workflow engine. In some embodiments, the database is a single state source for the workflow engine and is located outside the coordinator.
[0019] In some embodiments, the stateless coordinator allows for full scalability and portability of distributed workflows. Because the coordinator is stateless, the coordinator may be able to process or manage any event at any time. When multiple stateless coordinators are used, services can be replaced on each stateless coordinator at runtime.
[0020] In some embodiments, a token is generated for each interaction between the coordinator and other components (e.g., coordinator and worker nodes, coordinator and providers, etc.). The token can be used to authenticate actions between different components or microservices. In some embodiments, once the task is executed, the coordinator removes or deletes the token. In some embodiments, a process (e.g., from a workflow, an event, etc.) defines a time for which the token is valid, such as a time approximating the length of time required to perform the task, and the token remains valid until that length of time has passed. In some embodiments, the token is valid until the task has been executed or the length of time has passed, whichever comes first.
[0021] Reference now Figure 1 , shows a flowchart according to some embodiments, the flowchart shows a method 100 for running workflows and events using a stateless coordinator. In some embodiments, the method 100 is performed by a coordinator (e.g., coordinator 210 ( Figure 2 ) and / or coordinator 320 ( Figure 3 In some embodiments, the method 100 is implemented as a computer system (eg, computer system 400 ( Figure 4 )) or connected to the computer system. In some embodiments, the coordinator is a server. In some embodiments, the coordinator is a computer device, such as computer system / server 402 ( Figure 4 In some embodiments, the coordinator is a cloud computing environment (e.g., cloud computing environment 50 ( Figure 5 )) within a node (e.g., computing node 10 ( Figure 5 )).
[0022] In some embodiments, the coordinator is configured to perform operation 110 to receive task data. As discussed herein, the coordinator manages processes (e.g., corresponding to workflows and / or events). Each process can be decomposed into one or more tasks. The task data can be information / data required to perform a task (e.g., a first task in one or more tasks). In some embodiments, the coordinator sends a request to a database (e.g., database 310 ( Figure 3)) requests task data, and the database sends the task data to the coordinator. For security reasons, each request from the coordinator may represent an action and may require the creation of a new token. Tokens and the exchange of tokens between various components are discussed further in this article and in Figure 2 Depicted in.
[0023] In some embodiments, receiving task data may include receiving an event or an indication that an event has occurred. As discussed herein, an event may correspond to one or more processes (e.g., a defined process). In response to receiving the event, the coordinator may request task data from a database. The task may correspond to a defined process or be part of a defined process. For example, a user may have selected a specific action (e.g., pay a bill) on a user interface (e.g., by a mouse click). The specific action may correspond to a process with multiple tasks that complete the process when executed. In this example, the completed process may be that the user's bill has been paid. The process may be decomposed into multiple tasks, and the coordinator may request the data required for completing the first task in the multiple tasks from the database. The database may send the requested data to the coordinator.
[0024] In some embodiments, the coordinator is configured to perform operation 120 to request a worker node. In some embodiments, the worker node will perform a specific task. In order to request a worker node, the coordinator may send a request for a worker node to a provider. As discussed herein, a provider may create, monitor, and remove nodes. Once a provider receives a request for a worker node, the provider may create a worker node. In some embodiments, creating a worker node includes creating a container (i.e., a containerized application) and deploying / running the container on a dedicated machine (i.e., a worker machine). The worker machine may have a local container provider and / or an external container provider.
[0025] In some embodiments, once a worker node is created, the worker node will send a request for task data to the coordinator. The initial worker node (i.e., the newly created worker node) may not have any task data or process instance information stored on the node. In order to perform the task, the worker node needs the necessary data, so the worker node can request the task data from the coordinator.
[0026] In some embodiments, the coordinator is configured to perform operation 130 to receive a request for task data. As discussed herein, the request for task data may come from a worker node. In some embodiments, the coordinator is configured to perform operation 140 to send task data to the worker node. Once the worker node requests task data, the coordinator may transmit or send the task data to the worker node. As discussed herein, the task data may be data necessary for performing the task. Unnecessary data may be retained in a database. Once the worker node receives the task data, the worker node may perform the task.
[0027] In some embodiments, the coordinator is configured to perform operation 150 to receive the result of performing the task. After the worker node performs the task, the worker node can transmit or send the execution result to the coordinator. By sending the result to the coordinator, the worker node may not store any task data or result data on the worker node, which can allow the worker node to remain stateless. In some embodiments, the coordinator receives the execution result from the worker node. In order to make the database be maintained as the only state source of the workflow engine, the worker or worker node can perform a single task (for example, for a single process instance or a shared process instance), and there may not be any process instance information. The worker can only access the data required for performing a single task, and once the task has been performed, data can be deleted from the worker. In some embodiments, the worker is a simple execution environment for the actual task (for example, sent by the coordinator). In some embodiments, the worker is a dedicated sandbox.
[0028] In some embodiments, the coordinator is configured to perform operation 160 to send the results to the database. In order to keep the coordinator stateless, the coordinator can transmit or send the execution results to the database. By sending the results to the database, the database can store the results, thereby maintaining state. The coordinator may not store any results or task data; therefore, the coordinator can remain stateless.
[0029] In some embodiments, method 100 also includes operation 170, to send a request to remove a worker node. Once the worker node has performed a task, the worker node may no longer be needed. Therefore, after the coordinator receives the execution result (indicating that the task has been performed), the coordinator can transmit / send a request to delete the worker node to the provider. The provider can then remove the worker node. In some embodiments, removing the worker node includes removing the created container from the dedicated machine. Once the worker node is removed, the worker node has the free ability to run other tasks (e.g., tasks from another coordinator) if necessary.
[0030] In some embodiments, the coordinator is configured to perform operation 180 to receive task data for the second task. As discussed herein, a process may correspond to a series of tasks. In some embodiments, the coordinator may be managing a process with multiple tasks. Once the first task is completed, the coordinator may start the second task. In some embodiments, the coordinator may manage multiple processes, and the second task may correspond to the second process. The coordinator may request task data for the second task from a database. In response to receiving the request, the database may transmit or send task data or data required to perform the second task to the coordinator.
[0031] In some embodiments, the coordinator is configured to perform operation 190 to request a second worker node. In order to perform the second task, the coordinator may transmit or send a request to the second worker node to the provider. The second worker node may be a worker node that performs the second task. In response to receiving the request, the provider may create a second worker node. Similar to the operations 130-160 of method 100, the coordinator may then receive a request for task data for the second task from the second worker node, send the task data to the second worker node, receive the result of performing the second task, and transmit the result of the second task to the database. In addition, similar to operation 170, the coordinator may send a request to remove the second worker node. This process may be repeated for any number of tasks that the coordinator is managing.
[0032] In some embodiments, method 100 may be performed on a non-structured query language (NoSQL) database. NoSQL databases can be extended across multiple nodes. In some embodiments, when there are enough network and physical resources available, each component (e.g., coordinator, provider, and worker) can be independently and automatically extended and deployed on different nodes. Because the coordinator may not have a state (as discussed herein), it can be extended or redeployed by adding multiple coordinators. For example, when a coordinator manages multiple processes, other coordinators (e.g., one for each process) may be created to extend the coordinator. In some embodiments, the coordinator may receive multiple events. Each event in the multiple events may correspond to a defined process. In order to extend the coordinator so as to manage multiple events, multiple coordinators may be created. In some embodiments, the multiple coordinators manage the multiple events. In some embodiments, each coordinator from the multiple coordinators manages corresponding events from the multiple events.
[0033] In addition, if there are multiple tasks to be performed, the coordinator can create multiple local or external providers, which in turn can create multiple worker nodes (e.g., multiple container instances on a dedicated computer). In some embodiments, the coordinator can instruct a single provider to create multiple worker nodes. In some embodiments, if the coordinator is deployed in a cloud environment, the database can also be scaled by including external nodes in the database cluster.
[0034] refer to Figure 2 , according to some embodiments, depicts a schematic diagram or example stateless coordinator environment 200 and the interactions between components. The stateless coordinator environment 200 may include a coordinator 210, a provider 240, and a worker 230. In some embodiments, the coordinator 210 performs the method 100 ( Figure 1 ). As discussed herein, the coordinator 210 interacts with the providers 240 and the workers 230 in order to maintain the stateless coordinator 210. Additionally, to ensure security / authentication, interactions between the coordinator and various other components may use generated tokens.
[0035] In some embodiments, the coordinator 210 may perform operation 211 to request a worker node. Operation 211 may correspond to operation 110 ( Figure 1 ). In some embodiments, requesting a worker node (211) or transmitting a request for a worker node to a provider may include generating a first token (212). Since the coordinator will interact with the provider 240 and then with the worker node 230, the first token may be generated to maintain data security and authentication. In some embodiments, when requesting a worker node (211) or transmitting a request for a worker node to a provider, the first token may also be transmitted to the provider.
[0036] In some embodiments, in response to receiving a request for a worker node 211 along with a first token (i.e., token 1), the provider 240 may perform operation 242 to create a worker node. When the provider 240 creates the worker node 230 (242), the provider 240 may inject the first token into the worker node 230. Injecting the first token into the worker node 230 may provide the first token to the worker node 230, thereby allowing the worker node 230 to have proper authentication of the necessary data. In some embodiments, the provider 240 creates the worker node 230 by reusing an existing worker node and executing the current process instance corresponding to the task on the existing worker node (operation 242). For example, the provider 240 may notify the coordinator 210 of the existing worker node, and the coordinator may send the task data to the existing worker node (e.g., operation 216). Since the provider 240 may not need to create a new worker node, utilizing the existing worker node may improve efficiency (e.g., save time and speed up processing). In some embodiments, the requirements of the system may determine whether to allow the reuse of an existing worker node.
[0037] In some embodiments, the worker 230 may perform an operation 232 of requesting task data from the coordinator 210. When requesting task data (232), the coordinator may transmit or send the first token along with the request. In some embodiments, when the coordinator 210 receives a request for task data from a worker node (e.g., Figure 1 In operation 130 ), the coordinator 210 also receives a first token (eg, token 1 ) from the worker node 230 .
[0038] In some embodiments, in response to receiving a request for task data from a worker node 230, in operation 213, the coordinator 210 may determine whether the first token is a valid token. The token data may be stored in a database, thus maintaining a stateless coordinator 210. In some embodiments, a token is only valid when defined in a process, so determining whether the first token is a valid token may include identifying the time defined from the process. In some embodiments, the coordinator may monitor or track which tokens have not been removed. Therefore, determining whether the first token is a valid token may include determining whether the first token has been removed (e.g., the original token has been removed, but a duplicate has been created—the duplicate is invalid). In some embodiments, the coordinator may determine that the first token or token 1 is a valid token. Because the first token is a valid token, the worker node 230 may have the correct authentication for the task data. Therefore, transmitting the task data (operation 216) may be in response to determining that the first token is a valid token.
[0039] In some embodiments, once the first token has been validated, the first token may be removed or invalidated in operation 214. In some embodiments, the first token is automatically removed or invalidated once a time defined in the process has passed (i.e., after a first time period, a first time period defined in the process). In some embodiments, the coordinator 210 may invalidate the first token after it has been used. Invalidating a token removes it from the database so that another coordinator may not be able to recreate or replicate the same task.
[0040] In some embodiments, a second token may be generated (operation 215). Since the coordinator 210 may be interacting with a worker and therefore performing another action, the coordinator may create a new token for the action. In some embodiments, when the coordinator 210 transmits the task data to the worker node 230 (operation 216), transmitting the task data may include transmitting the second token to the worker node. The worker node 230 may then perform operation 234 to perform the task. Once the worker node 230 has performed the task (234), the worker node 230 may send or transmit the task execution results to the coordinator 210 in operation 236. In some embodiments, the worker node 230 may send the second token along with the task execution results. Thus, the coordinator 210 receives the results of performing the task (e.g., Figure 1 Operation 150) may further include receiving a second token from the worker node 230.
[0041] In some embodiments, in operation 217, after receiving the second token from the worker node, the coordinator 210 may determine whether the second token is valid. If the second token is invalid, the task execution result may be invalid (e.g., a duplicate result, a result from an incorrect worker node, etc.), and therefore may not be transmitted to the database. If the second token is valid, the coordinator 210 may send the execution result to the database.
[0042] In some embodiments, once the second token has been validated, the second token may be removed, or invalidated in operation 218 to remove the second token from the database so that it is not used by another coordinator. In some embodiments, once a time defined in the process has passed (i.e., after a second time period, a second time period defined in the process), the second token is automatically removed or invalidated. In some embodiments, the coordinator 210 may invalidate the second token after it has been used.
[0043] In some embodiments, as discussed herein, once a worker node is no longer needed (e.g., after execution results have been received by coordinator 210), coordinator 210 may request removal of the worker node (e.g., Figure 1Operation 170 of ). In some embodiments, the interaction between the coordinator 210 and the provider 240 to delete the worker node may warrant another token. Therefore, in some embodiments, the coordinator 210 may perform operation 219 to generate a third token or token 3. In some embodiments, when the coordinator requests to remove the worker node in operation 220, the coordinator may further send the third token to the provider 240. Once the provider 240 receives the removal request, which in some cases includes the third token, the provider 240 may perform operation 244 to delete the worker node.
[0044] In some embodiments, tokens are generated only for interactions or actions between coordinator 210 and workers 230. These actions can be direct or indirect (e.g., through provider 240). In some embodiments, tokens are generated for all interactions of coordinator 210 with other components.
[0045] In some embodiments, the interaction between the coordinator 210, the provider 240, and the worker 230 may be repeated for additional tasks and / or processes. For example, once the first task is performed, the coordinator 210 may have additional tasks for execution, and the coordinator may repeat the operation for the new task (e.g., starting from operation 211).
[0046] refer to Figure 3 , a block diagram of components of an example system 300 for using a stateless coordinator is depicted, according to some embodiments. System 300 may include a database 310, a coordinator 320, a provider 330, and a worker 340. In some embodiments, coordinator 320 corresponds to coordinator 210, provider 330 corresponds to provider 240, and worker 340 corresponds to Figure 2 In some embodiments, the coordinator 320 performs Figure 1 Method 100 in .
[0047] In some embodiments, the coordinator 320 may receive an event (or workflow) 350. In response to receiving the event, the coordinator may request and receive task data (for the task corresponding to the event) from the database 310. The coordinator 320 may send a request for a new worker node to the provider 330. In response to receiving the request from the coordinator 320, the provider may create and start a new worker node 340. In some embodiments, the worker node 340 requests the coordinator for task data in order to perform the task. The coordinator may send the task data to the worker node 340. In some embodiments, once the task has been executed, the worker node 340 may send the execution result to the coordinator 320. The coordinator 320 may then send the execution result to the database 310 in order to maintain a stateless coordinator 320.
[0048] refer to Figure 4 , according to some embodiments, computer system 400 is a computer system / server 402 shown in the form of a general purpose computing device. In some embodiments, computer system / server 402 is located on a linking device. In some embodiments, computer system 402 is connected to a linking device. Components of computer system / server 402 may include, but are not limited to, one or more processors or processing units 410, system memory 460, and bus 415 coupling various system components including system memory 460 to processor 410.
[0049] Bus 415 represents any one or more of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example and not limitation, such architectures include an Industry Standard Architecture (ISA) bus, a Micro Channel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, and a Peripheral Component Interconnect (PCI) bus.
[0050] Computer system / server 402 typically includes a variety of computer system readable media. Such media can be any available media that can be accessed by computer system / server 402, and it includes volatile and nonvolatile media, removable and non-removable media.
[0051] The system memory 460 may include computer system readable media in the form of volatile memory, such as random access memory (RAM) 462 and / or cache memory 464. The computer system / server 402 may further include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, a storage system 465 may be provided for reading and writing non-removable non-volatile magnetic media (not shown and generally referred to as a "hard drive"). Although not shown, a disk drive for reading and writing to a removable non-volatile disk (e.g., a "floppy disk"), and an optical drive for reading and writing to a removable non-volatile optical disk (CD-ROM, DVD-ROM or other optical media) may be provided. In this case, each drive may be connected to the bus 415 via one or more data media interfaces. As will be further depicted and described below, the memory 460 may include at least one program product having a set (e.g., at least one) of program modules that are configured to perform the functions of an embodiment of the present disclosure.
[0052] A program / utility 468 having a set (at least one) of program modules 469 and an operating system, one or more application programs, other program modules, and program data, as examples and not limitations, may be stored in memory 460. Each or some combination of the operating system, one or more application programs, other program modules, and program data may include an implementation of a networking environment. Program modules 469 generally perform the functions and / or methods of embodiments of the present invention as described herein.
[0053] The computer system / server 402 may also communicate with one or more external devices 440 (e.g., keyboard, pointing device, display 430, etc.); with one or more devices that enable a user to interact with the computer system / server 402; and / or any device that enables the computer system / server 402 to communicate with one or more other computing devices (e.g., network card, modem, etc.). Such communication may occur via input / output (I / O) interface 420. Furthermore, the computer system / server 402 may communicate with one or more networks (such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet)) via a network adapter 450. As shown, the network adapter 450 communicates with other components of the computer system / server 402 via bus 415. It should be understood that, although not shown in the figure, other hardware and / or software components may be used in conjunction with the computer system / server 402. Examples include, but are not limited to, microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems.
[0054] First, it should be understood that although the present disclosure includes a detailed description about cloud computing, the implementation of the technical solutions recorded therein is not limited to a cloud computing environment, but can be implemented in combination with any other type of computing environment now known or later developed.
[0055] Cloud computing is a service delivery model for convenient, on-demand network access to a shared pool of configurable computing resources. Configurable computing resources are resources that can be quickly deployed and released with minimal management cost or interaction with the service provider, such as networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services. This cloud model can include at least five characteristics, at least three service models, and at least four deployment models.
[0056] Features include:
[0057] On-demand self-service: Cloud consumers can unilaterally and automatically deploy computing capabilities such as server time and network storage on demand without human interaction with the service provider.
[0058] Broad network access: Computing power can be accessed over the network through standard mechanisms that facilitate the use of the cloud through different types of thin-client or thick-client platforms (e.g., mobile phones, laptops, personal digital assistants (PDAs)).
[0059] Resource pool: The computing resources of the provider are grouped into resource pools and serve multiple consumers through a multi-tenant model, where different physical and virtual resources are dynamically allocated and reallocated on demand. Generally, consumers cannot control or even know the exact location of the provided resources, but can specify the location (such as country, state or data center) at a higher level of abstraction, so it is location-independent.
[0060] Rapid elasticity: The ability to quickly and elastically (sometimes automatically) deploy computing power to scale up quickly, and quickly release it to scale down quickly. To consumers, the computing power available for deployment often appears to be unlimited, and any amount of computing power can be accessed at any time.
[0061] Measurable services: Cloud systems automatically control and optimize resource usage by leveraging metering capabilities at a level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency to both service providers and consumers.
[0062] The service model is as follows:
[0063] Software as a Service (SaaS): The capability provided to consumers is to use the provider's applications running on a cloud infrastructure. Applications can be accessed from a variety of client devices through a thin client interface such as a web browser (e.g., web-based email). Aside from limited user-specific application configuration settings, consumers neither manage nor control the underlying cloud infrastructure including networks, servers, operating systems, storage, or even individual application capabilities.
[0064] Platform as a Service (PaaS): The capability provided to consumers is to deploy applications created or acquired by consumers on the cloud infrastructure, which are created using programming languages and tools supported by the provider. Consumers neither manage nor control the underlying cloud infrastructure including networks, servers, operating systems or storage, but have control over the applications they deploy and may also have control over the configuration of the application hosting environment.
[0065] Infrastructure as a Service (IaaS): The capabilities provided to consumers are processing, storage, network, and other basic computing resources on which consumers can deploy and run arbitrary software including operating systems and applications. Consumers neither manage nor control the underlying cloud infrastructure, but have control over the operating system, storage, and applications they deploy, and may have limited control over selected network components (such as host firewalls).
[0066] The deployment model is as follows:
[0067] Private Cloud: Cloud infrastructure is run solely for an organization. The cloud infrastructure can be managed by the organization or a third party and can exist inside or outside the organization.
[0068] Community Cloud: A cloud infrastructure is shared by several organizations and supports a specific community with common interests (e.g., mission, security requirements, policies, and compliance considerations). A community cloud can be managed by multiple organizations within the community or by a third party and can exist inside or outside the community.
[0069] Public cloud: Cloud infrastructure is provided to the public or to large industry groups and is owned by an organization that sells cloud services.
[0070] Hybrid cloud: A cloud infrastructure consisting of two or more clouds (private, community or public) in a deployment model that remain distinct entities but are bound together by standardized or proprietary technologies (such as cloud burst sharing for load balancing between clouds) that enable data and application portability.
[0071] The cloud computing environment is service-oriented, with characteristics centered on statelessness, low coupling, modularity, and semantic interoperability. The core of cloud computing is the infrastructure that includes a network of interconnected nodes.
[0072] Reference now Figure 5 , according to some embodiments, an exemplary cloud computing environment 50 is shown. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 with which a local computing device used by a cloud computing consumer can communicate, and the local computing device can be, for example, a personal digital assistant (PDA) or a mobile phone 54A, a desktop computer 54B, a laptop computer 54C and / or an automobile computer system 54N. The cloud computing nodes 10 can communicate with each other. The cloud computing nodes 10 can be physically or virtually grouped in one or more networks including but not limited to private clouds, community clouds, public clouds or hybrid clouds, or a combination thereof as described above (not shown in the figure). In this way, cloud consumers can request infrastructure as a service (IaaS), platform as a service (PaaS) and / or software as a service (SaaS) provided by the cloud computing environment 50 without having to maintain resources on local computing devices. It should be understood that Figure 6 The various types of computing devices 54A-N shown are merely illustrative, and the cloud computing node 10 and the cloud computing environment 50 may communicate with any type of computing device on any type of network and / or network-addressable connection (eg, using a web browser).
[0073] Reference now Figure 6 , according to some embodiments, wherein a cloud computing environment 50 ( Figure 5 ) provides a set of functional abstraction layers 600. First, it should be understood that Figure 6 The components, layers, and functions shown are only exemplary and the embodiments of the present invention are not limited thereto. Figure 6 As shown, the following layers and corresponding functions are provided:
[0074] The hardware and software layer 60 includes hardware and software components. Examples of hardware components include: host 61; server 62 based on RISC (Reduced Instruction Set Computer) architecture; server 63; blade server 64; storage device 65; network and network components 66. Examples of software components include: network application server software 67 and database software 68.
[0075] The virtualization layer 70 provides an abstraction layer that can provide examples of the following virtual entities: virtual servers 71 , virtual storage 72 , virtual networks 73 (including virtual private networks), virtual applications and operating systems 74 , and virtual clients 75 .
[0076] In one example, the management layer 80 may provide the following functions: Resource provisioning function 81: providing dynamic acquisition of computing resources and other resources for performing tasks in a cloud computing environment; Metering and pricing function 82: tracking the cost of resource usage within the cloud computing environment and providing bills and invoices for this purpose. In one example, the resource may include an application software license. Security function: providing identity authentication for cloud consumers and tasks, and providing protection for data and other resources. User portal function 83: providing access to the cloud computing environment for consumers and system administrators. Service level management function 84: providing allocation and management of cloud computing resources to meet the required service levels. Service level agreement (SLA) planning and fulfillment function 85: providing pre-arrangement and provision for future demand for cloud computing resources predicted according to the SLA.
[0077] The workload layer 90 provides examples of functions that may be implemented in a cloud computing environment. In this layer, examples of workloads or functions that may be provided include: mapping and navigation 91; software development and lifecycle management 92; virtual classroom teaching provision 93; data analysis processing 94; transaction processing 95; and event and workflow processing 96.
[0078] At any possible technical detail combination level, the present invention may be a system, method and / or computer program product. The computer program product may include a computer-readable storage medium carrying computer-readable program instructions for causing a processor to implement various aspects of the present invention.
[0079] A computer-readable storage medium may be a tangible device that can hold and store instructions used by an instruction execution device. A computer-readable storage medium may be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples of computer-readable storage media (a non-exhaustive list) include: a portable computer disk, a hard disk, a random access memory (RAM), a static random access memory (SRAM), a portable compact disk read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanical encoding device, such as a punch card or a raised structure in a groove on which instructions are stored, and any suitable combination of the foregoing. The computer-readable storage medium used herein is not to be interpreted as a transient signal itself, such as a radio wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a waveguide or other transmission medium (e.g., a light pulse through a fiber optic cable), or an electrical signal transmitted through a wire.
[0080] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device, or downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network can include copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in the computer-readable storage medium in each computing / processing device.
[0081] The computer program instructions for performing the operation of the present invention may be assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, integrated circuit configuration data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages, such as Smalltalk, C++, etc., and procedural programming languages, such as "C" language or similar programming languages. Computer-readable program instructions may be executed entirely on a user's computer, partially on a user's computer, as an independent software package, partially on a user's computer, partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., using an Internet service provider to connect via the Internet). In some embodiments, an electronic circuit, such as a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may be personalized by utilizing the state information of the computer-readable program instructions, and the electronic circuit may execute the computer-readable program instructions, thereby realizing various aspects of the present invention.
[0082] Various aspects of the present invention are described herein with reference to the flow charts and / or block diagrams of the methods, devices (systems) and computer program products according to embodiments of the present invention. It should be understood that each box of the flow chart and / or block diagram and the combination of each box in the flow chart and / or block diagram can be implemented by computer-readable program instructions.
[0083] These computer-readable program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, thereby producing a machine, so that when these instructions are executed by the processor of the computer or other programmable data processing device, a device that implements the functions / actions specified in one or more boxes in the flowchart and / or block diagram is generated. These computer-readable program instructions can also be stored in a computer-readable storage medium, and these instructions cause the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable medium storing the instructions includes a manufactured product, which includes instructions for implementing various aspects of the functions / actions specified in one or more boxes in the flowchart and / or block diagram.
[0084] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device so that a series of operating steps are performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions executed on the computer, other programmable data processing apparatus, or other device to implement the functions / actions specified in one or more boxes in the flowchart and / or block diagram.
[0085] The flow chart and block diagram in the accompanying drawings show the possible architecture, function and operation of the system, method and computer program product according to multiple embodiments of the present invention. In this regard, each square box in the flow chart or block diagram can represent a part of a module, program segment or instruction, and a part of the module, program segment or instruction includes one or more executable instructions for realizing the specified logical function. In some alternative implementations, the function marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two continuous square boxes can actually be executed substantially in parallel, and they can sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs the specified function or action, or can be implemented with a combination of special hardware and computer instructions.
[0086] The embodiments of the present invention have been described above, and the above description is exemplary, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terms used herein are selected to best explain the principles of the embodiments, practical applications, or technical improvements to the technology in the market, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.
Claims
1. A computer-implemented method comprising: receiving first task data for a first task, wherein the first task data is information required to perform the first task; generating a first token; sending a request for a worker node and the first token to a provider, wherein the provider creates the worker node; receiving, from the worker node, a request for the first task data and the first token; In response to receiving the request, determining whether the first token is a valid token; In response to determining that the first token is a valid token, invalidating the first token; generating a second token; sending the first task data and the second token to the worker node, wherein the worker node performs the first task; receiving a result of executing the first task from the worker node; and In response to receiving the results, the results are sent to a database.
2. The method according to claim 1, further comprising: In response to receiving the result, a request to delete the worker node is sent to the provider.
3. The method according to claim 2, further comprising: receiving second task data for a second task, wherein the second task data is information required to perform the second task; and A request for a second worker node is sent to the provider.
4. The method according to claim 1, wherein: The provider injects the first token into the worker node.
5. The method according to claim 4, in, Sending the first task data is performed in response to determining that the first token is a valid token.
6. The method according to claim 1, wherein: Receiving the result of executing the first task also includes: receiving the second token from the worker node.
7. The method according to claim 1, wherein: Receiving the first task data includes: receiving an event, wherein the event corresponds to a defined process; and In response to receiving the event, the first task data is requested from the database, wherein the first task is part of the defined process.
8. The method according to claim 1, further comprising: receiving a plurality of events, wherein each event of the plurality of events corresponds to a defined process; and A plurality of coordinators are created, wherein the plurality of coordinators manage the plurality of events.
9. A system having one or more computer processors, the system being configured to perform the steps of the method according to any one of claims 1 to 8.
10. A computer system comprising a model for performing the steps of the method according to any one of claims 1 to 8.
11. A computer program product, comprising a computer-readable storage medium, wherein the computer-readable storage medium embodies program instructions, wherein the program instructions can be executed by a server to enable the server to perform the method according to any one of claims 1 to 8.
Citation Information
Patent Citations
Executing stored procedures at parallel databases
CN105164677A
