Method, device and equipment for managing assembly line process in server-free architecture application

Abstract

The invention relates to the technical field of cloud computing and software development, and discloses an assembly line process management method, device and equipment in a server-free architecture application, and the method comprises the steps: when a pause request of a user for a first assembly line in a server-free architecture is received, executing a first command which is used for capturing a process state of the first assembly line, generating a snapshot file based on the process state, and terminating the process of a first assembly line in the server-free architecture; and storing the snapshot file to a preset storage platform. According to the method provided by the invention, the first command is executed to capture the process state of the first assembly line, the snapshot file is generated, and the process of the first assembly line is terminated, so that the user does not need to continue payment and store the snapshot file to the preset storage platform because the first assembly line running in the server-free architecture is terminated; and subsequently, the target assembly line can be conveniently recovered by using the snapshot file, so that the cost during the pause period of the assembly line is effectively saved for the user.

Description

Technical Field

[0001] The present invention relates to the field of electronic technology, and in particular to a method, device and equipment for managing pipeline processes in serverless architecture applications. Background Art

[0002] With the increasing popularity of serverless architecture, more and more developers and enterprises are choosing to develop their services using serverless functions. Deploying a serverless function requires users to write the function code for each serverless function, compile and package it into an executable, create the serverless function, and then upload and deploy the package. Serverless applications provide an orchestrated way for one or more serverless functions to work together to implement services for specific scenarios. With a serverless application, users simply upload the source code for one or more functions to a remote repository in the distributed version control system Git. Then, they create a serverless application on the Function Compute platform and associate it with the repository. The Function Compute platform automatically creates and associates the relevant webhooks for the repository. Subsequently, when users make changes and commit code to the Git repository, a corresponding webhook event is triggered to the Function Compute platform, automatically fetching the code, compiling and packaging it, creating or updating the serverless function, and uploading and deploying the serverless function. These automated steps are completed by the serverless application build pipeline.

[0003] Currently, the Serverless application build pipeline supports two triggering methods: automatic WebHook triggering and manual user triggering. The Serverless application build pipeline supports customization of the pipeline's execution environment specifications. Users can configure pipeline parameters such as CPU and memory based on their business requirements, paying a small fee to the platform. Therefore, Serverless functions have become a way to implement this on-demand pipeline configuration, meaning the pipeline runs on Serverless functions. In a pipeline running on a Serverless function, a function instance is launched and executed only when triggered; otherwise, no function instance is launched. While the pipeline easily supports triggering builds and terminating execution, pausing the pipeline requires maintaining the function instance after the pause, which can result in high costs for users. Summary of the Invention

[0004] In view of this, the present invention provides a method, device and equipment for managing pipeline processes in serverless architecture applications to solve the problem in related technologies that when pausing the pipeline, it is necessary to maintain the Serverless function instance after the pause, which will bring high cost to users.

[0005] In a first aspect, the present invention provides a method for managing pipeline processes in a serverless architecture application, the method comprising: upon receiving a user's pause request for a first pipeline in the serverless architecture, executing a first command, the first command being used to capture the process status of the first pipeline, generating a snapshot file based on the process status, and terminating the process of the first pipeline in the serverless architecture; and storing the snapshot file to a preset storage platform.

[0006] The present invention provides a method for managing pipeline processes in a serverless architecture application. When a user's pause request for the first pipeline in the serverless architecture is received, a first command is executed. The first command is used to capture the process status of the first pipeline, generate a snapshot file based on the process status, and terminate the process of the first pipeline in the serverless architecture; the snapshot file is stored in a preset storage platform. The method provided by the present invention, when receiving a pause request for the first pipeline, captures the process status of the first pipeline by executing a first command, generates a snapshot file based on the process information, and terminates the process of the first pipeline. At this time, since the first pipeline running in the serverless architecture is terminated, the user does not need to continue to pay fees. The snapshot file is stored in the preset storage platform, which facilitates the subsequent use of the snapshot file to restore the target pipeline. During the pause period, there is no need to pull up a function instance to maintain the pipeline state, effectively saving the user the cost during the pipeline pause period.

[0007] In an optional embodiment, the method also includes: when receiving a user's request to restore the first pipeline, controlling the serverless architecture to create a second serverless architecture function; downloading a snapshot file from a preset storage platform; and restoring the process of the first pipeline based on the snapshot file and the second serverless architecture function to obtain a second pipeline.

[0008] The method provided by this optional implementation manner, when receiving a user's request to resume the first pipeline, creates a new second serverless architecture function, downloads a snapshot file from a preset storage platform in the second serverless architecture function environment, and executes a recovery command to quickly restore the first pipeline process to the state before suspension. There is no need to pull up a function instance to maintain the state during the period from suspension to recovery, and the user does not need to write additional suspension and recovery logic, thereby realizing the suspension and recovery operations of the pipeline.

[0009] In an optional embodiment, when a user's request to pause the first pipeline in the serverless architecture is received, before executing the first command step, the method also includes: when a build instruction of the user's serverless architecture application is received, controlling the serverless architecture to build a first serverless architecture function; controlling the first serverless architecture function to run to trigger the execution pipeline to obtain the first pipeline.

[0010] In the second aspect, the present invention provides a management system for pipeline processes in serverless architecture applications, the system comprising: a serverless architecture, a management platform and a preset storage platform; the management platform is connected to the serverless architecture and the preset storage platform respectively, and is used to execute the management method of pipeline processes in serverless architecture applications of the above-mentioned first aspect or any corresponding embodiment thereof.

[0011] The management system of the pipeline process in the serverless architecture application provided by the present invention includes a server architecture, a management platform and a preset storage platform. After receiving a pause request for the first pipeline, the management platform executes a first command to capture the process status of the first pipeline, generates a snapshot file based on the process information, and terminates the process of the first pipeline. At this time, since the first pipeline running in the serverless architecture is terminated, the user does not need to continue to pay fees. The snapshot file is stored in the preset storage platform, which facilitates the subsequent use of the snapshot file to restore the target pipeline. During the pause period, there is no need to pull up a function instance to maintain the pipeline status, which effectively saves the user the cost during the pipeline pause period.

[0012] In a third aspect, the present invention provides a management device for pipeline processes in a serverless architecture application, the device comprising: when receiving a user's pause request for a first pipeline in the serverless architecture, executing a first command, the first command is used to capture the process status of the first pipeline, generate a snapshot file based on the process status, and terminate the process of the first pipeline in the serverless architecture; and store the snapshot file to a preset storage platform.

[0013] In an optional embodiment, the above-mentioned device also includes: a first control module, which is used to control the serverless architecture to create a second serverless architecture function when receiving a user's recovery request for the first pipeline; a download module, which is used to download a snapshot file from a preset storage platform; and a recovery module, which is used to restore the process of the first pipeline based on the snapshot file and the second serverless architecture function to obtain a second pipeline.

[0014] In an optional embodiment, the above-mentioned device also includes: a second control module, which is used to control the serverless architecture to build a first serverless architecture function when receiving the user's serverless architecture application construction instruction; a third control module, which is used to control the operation of the first serverless architecture function to trigger the execution pipeline to obtain the first pipeline.

[0015] In a fourth aspect, the present invention provides a computer device comprising: a memory and a processor, the memory and the processor being communicatively connected to each other, the memory storing computer instructions, and the processor executing the computer instructions to execute the method for managing pipeline processes in a serverless architecture application of the above-mentioned first aspect or any corresponding embodiment thereof.

[0016] In a fifth aspect, the present invention provides a computer-readable storage medium having computer instructions stored thereon, the computer instructions being used to enable a computer to execute the method for managing pipeline processes in a serverless architecture application of the above-mentioned first aspect or any corresponding embodiment thereof.

[0017] In a sixth aspect, the present invention provides a computer program product comprising computer instructions, which are used to enable a computer to execute the method for managing pipeline processes in a serverless architecture application according to the first aspect or any corresponding embodiment thereof. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0019] Figure 1 1 is a flow chart of a method for managing pipeline processes in a serverless architecture application according to an embodiment of the present invention;

[0020] Figure 2 1 is a flow chart of another method for managing a pipeline process in a serverless architecture application according to an embodiment of the present invention;

[0021] Figure 3 1 is a flow chart of a method for managing a pipeline process in a serverless architecture application according to another embodiment of the present invention;

[0022] Figure 4 1 is a block diagram of a management system for pipeline processes in a serverless architecture application according to an embodiment of the present invention;

[0023] Figure 5 is a schematic diagram of a specific example of a management system for pipeline processes in a server architecture application according to an embodiment of the present invention;

[0024] Figure 6 is a structural block diagram of a management device for pipeline processes in a serverless architecture application according to an embodiment of the present invention;

[0025] Figure 7 Schematic diagram of the hardware structure of a computer device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0026] To make the purpose, technical solutions, and advantages of the embodiments of the present invention more clear, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without making creative efforts shall fall within the scope of protection of the present invention.

[0027] In related technologies, serverless application build pipelines support two triggering methods: automatic WebHook triggering and manual user triggering. Serverless application build pipelines support customization of the pipeline's execution environment specifications. Users can configure pipeline parameters such as CPU and memory based on their business requirements, paying a small fee to the platform. Therefore, serverless functions have become an implementation of this on-demand pipeline configuration, meaning the pipeline runs on serverless functions. In a pipeline running on a serverless function, a function instance is launched and executed only when triggered; otherwise, no function instance is launched. While pipelines easily support triggering builds and terminating execution, pausing a pipeline requires maintaining the function instance after the pause, which can result in high costs for users.

[0028] In view of this, a method for managing pipeline processes in a serverless architecture application provided in an embodiment of the present application can be applied to a server to implement the management of pipeline processes in a serverless architecture application. The method provided in an embodiment of the present application, upon receiving a pause request for the first pipeline, captures the process state of the first pipeline by executing a first command, generates a snapshot file based on the process information, and terminates the process of the first pipeline. At this time, since the first pipeline running in the serverless architecture is terminated, the user does not need to continue to pay fees, and the snapshot file is stored in a preset storage platform, which is convenient for subsequent use of the snapshot file to restore the target pipeline. During the pause period, there is no need to pull up a function instance to maintain the pipeline state, which effectively saves the user the cost during the pipeline pause period.

[0029] According to an embodiment of the present invention, an embodiment of a method for managing pipeline processes in a serverless architecture application is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in an order different from that shown here.

[0030] In this embodiment, a method for managing pipeline processes in a serverless architecture application is provided, which can be used for the above-mentioned server, in which a management platform is pre-integrated. Figure 1 is a flow chart of a method for managing pipeline processes in a serverless architecture application according to an embodiment of the present invention. Figure 1 As shown, the process includes the following steps:

[0031] In step S101, upon receiving a user's request to pause the first pipeline in the serverless architecture, a first command is executed, where the first command is used to capture the process state of the first pipeline, generate a snapshot file based on the process state, and terminate the process of the first pipeline in the serverless architecture.

[0032] For example, Serverless Architecture is an emerging cloud computing architecture model that allows developers to focus more on developing business logic without having to manage server infrastructure. A serverless application is a combination of one or more Serverless functions in a specific scenario to implement specific business. The first pipeline is the pipeline for building a Serverless application. The pipeline for building a Serverless application provides an automated pipeline service that triggers code download, compilation, construction, and deployment with one click to reduce users' deployment costs. Unlike traditional software building pipelines, the Serverless application building pipeline is a Serverless function instance. Since Serverless itself supports flexible on-demand configuration, users can create a pipeline operating environment with specific specifications as needed. A pipeline process refers to an instance of a Serverless application building pipeline.

[0033] In an embodiment of the present application, a user space checkpoint / restore tool helper (Checkpoint / Restore In Userspace, CRIU-Helper) component is pre-set in the management platform. The CRIU-Helper component encapsulates the CRIU core program to support the generation of snapshots (dump) and restoration (restore) operations on the target process. It provides start, pause, resume, and terminate interfaces to the outside world, which are exposed to users through the API gateway. When the user triggers the interface, the pipeline is ultimately managed by CRIU-Helper. The API gateway is a cloud platform component that provides API hosting services. In an embodiment of the present application, the API gateway is used to expose the CRIU-Helper interface. After receiving the user's pause request for the first pipeline in the serverless architecture, CRIU-Helper prepares to execute the first command to capture the information of the pipeline process, generate a snapshot file, and kill the pipeline process.

[0034] Step S102: storing the snapshot file in a preset storage platform.

[0035] Exemplarily, the preset storage platform may include but is not limited to an Object Storage Service (OSS) platform.

[0036] In the embodiment of the present application, assuming that the target pipeline process ID is 1234, the CRIU command to be executed is: criu dump-vvvv -o dump.log -t 1234 --shell-job. The main function of the criu dump command is to create a checkpoint for a process or process group, that is, to save the current state of the specified process and its child processes to the disk so that they can be restored from this state and continue to execute. -vvvv is an option for the log detail level. In CRIU, -v is used to control the detail level of the log output. The more v's after -v, the more detailed the log. -odump.log is used to specify the output path and file name of the log file. Here, the log information is output to a file named dump.log. By viewing this log file, you can understand the details of CRIU during the checkpoint operation, including whether any errors occurred, the execution results of each step, etc. The -t option in -t 1234 is used to specify the process ID (PID) of the target process to create a checkpoint. 1234 is the PID of the target process. CRIU will recursively save the status of this process and all its child processes, starting with this process. The overall purpose of this command is to save the status of the process with ID 1234 and its child processes to disk at the highest level of log detail. It will also specially handle status information related to shell jobs and record detailed logs of the operation in the dump.log file. After the command is executed, the process is killed (the corresponding Serverless function is also destroyed and recycled by the Function Compute platform), a snapshot file is generated, and the snapshot file is stored on the preset storage platform.

[0037] The present embodiment provides a method for managing pipeline processes in a serverless architecture application. When a pause request for a first pipeline is received, the method captures the process status of the first pipeline by executing a first command, generates a snapshot file based on the process information, and terminates the process of the first pipeline. At this time, since the first pipeline running in the serverless architecture is terminated, the user does not need to continue paying fees. The snapshot file is stored in a preset storage platform, which facilitates the subsequent use of the snapshot file to restore the target pipeline. During the pause period, there is no need to pull up a function instance to maintain the pipeline status, which effectively saves the user the cost during the pipeline pause period.

[0038] In this embodiment, a method for managing pipeline processes in a serverless architecture application is provided, which can be used for the above-mentioned server. Figure 2 is a flow chart of a method for managing pipeline processes in a serverless architecture application according to an embodiment of the present invention. Figure 2 As shown, the process includes the following steps:

[0039] Step S201: When receiving a user's request to pause the first pipeline in the serverless architecture, execute a first command, which is used to capture the process state of the first pipeline, generate a snapshot file based on the process state, and terminate the process of the first pipeline in the serverless architecture. Figure 1 Step S101 of the illustrated embodiment will not be described in detail here.

[0040] Step S202: Store the snapshot file in a preset storage platform. Figure 1 Step S102 of the illustrated embodiment will not be described in detail here.

[0041] Step S203: When receiving a user's request to resume the first pipeline, the serverless architecture is controlled to create a second serverless architecture function.

[0042] For example, in an embodiment of the present application, when receiving a user's request to resume the first pipeline, the management platform controls the function computing platform in the serverless architecture to create another Serverless function instance to prepare to run the new Serverless application build pipeline, and starts CRIU-Helper at the same time.

[0043] Step S204: Download the snapshot file from the preset storage platform.

[0044] Illustratively, in the embodiment of the present application, CRIU-Helper receives a recovery request and downloads a snapshot file from the OSS object storage.

[0045] Step S205: Restore the process of the first pipeline based on the snapshot file and the second serverless architecture function to obtain a second pipeline.

[0046] Exemplarily, CRIU-Helper restores the pipeline process to the state before executing CRIU dump from the snapshot file, so that the pipeline continues to execute.

[0047] In this embodiment, a method for managing pipeline processes in a serverless architecture application is provided, which can be used for the above-mentioned server. Figure 3 is a flow chart of a method for managing pipeline processes in a serverless architecture application according to an embodiment of the present invention. Figure 3 As shown, the process includes the following steps:

[0048] Step S301: upon receiving a construction instruction of a serverless architecture application from a user, controlling the serverless architecture to construct a first serverless architecture function.

[0049] For example, in this embodiment of the present application, a user creates a serverless application on the Function Compute platform and associates it with a remote Git repository. When the user updates the associated remote Git repository and a webhook automatically triggers the serverless application build pipeline, or when the user proactively initiates a serverless application build, the Function Compute platform creates a new serverless function instance to run, triggers the execution of the pipeline, and simultaneously launches the CRIU-Helper.

[0050] Step S302, controlling the first serverless architecture function to run to trigger the execution pipeline to obtain a first pipeline.

[0051] For example, in this embodiment of the present application, when the Serverless application build pipeline begins executing, the Function Compute console pulls up an instance to trigger the pipeline, causing the pipeline to run on the Serverless function. In this embodiment of the present application, the function instance is the running environment of the pipeline that needs to be paused.

[0052] Step S303: When receiving a user's request to pause the first pipeline in the serverless architecture, execute a first command, which is used to capture the process state of the first pipeline, generate a snapshot file based on the process state, and terminate the process of the first pipeline in the serverless architecture. Figure 2 Step S201 of the illustrated embodiment will not be described in detail here.

[0053] Step S304: Store the snapshot file in a preset storage platform. Figure 2 Step S202 of the illustrated embodiment will not be described in detail here.

[0054] This embodiment also provides a management system for pipeline processes in serverless architecture applications. Figure 4 is a principle block diagram of a management system for pipeline processes in a serverless architecture application according to an embodiment of the present invention, such as Figure 4 As shown, the system includes a serverless architecture 401, a management platform 402, and a preset storage platform 403. The management platform 402 is connected to the serverless architecture 401 and the preset storage platform 403, respectively, and is configured to execute the method for managing pipeline processes in a serverless architecture application according to the above embodiment. For example, the details are described in the above embodiment and will not be repeated here.

[0055] The management system of the pipeline process in the serverless architecture application provided by the embodiment of the present application includes a server architecture, a management platform and a preset storage platform. After receiving a pause request for the first pipeline, the management platform executes a first command to capture the process status of the first pipeline, generates a snapshot file based on the process information, and terminates the process of the first pipeline. At this time, since the first pipeline running in the serverless architecture is terminated, the user does not need to continue to pay fees. The snapshot file is stored in the preset storage platform, which facilitates the subsequent use of the snapshot file to restore the target pipeline. During the pause period, there is no need to pull up a function instance to maintain the pipeline status, which effectively saves the user the cost during the pipeline pause period.

[0056] The following describes a method for managing pipeline processes in a serverless architecture application provided by the present invention through a specific embodiment.

[0057] Example:

[0058] The system provided in the embodiment of the present application introduces the CRIU-Helper component in the Serverless function environment running in the Serverless application construction pipeline. Its overall architecture is as follows: Figure 5 The functions of the CRIU-Helper component and the details of its interaction with other components in the system context when the user pauses or resumes the pipeline operation are described below:

[0059] The CRIU-Helper component encapsulates the CRIU core program to support snapshot generation (dump) and restore operations from snapshots of the target process. It provides start, pause, resume, and terminate interfaces, exposed to users through the API gateway. When users trigger the interfaces, CRIU-Helper ultimately manages the pipeline.

[0060] API Gateway cloud platform component: provides API hosting services. In the present invention, the API Gateway is used to expose the CRIU-Helper interface.

[0061] Original Serverless Function Instance: When a Serverless application build pipeline begins executing, the Function Compute console launches an instance to trigger the pipeline. In this application, this function instance is the runtime environment for the paused pipeline.

[0062] New Serverless Function Instance: When a Serverless application build pipeline executes a build again, the Function Compute console launches another instance to run the pipeline. In this invention, this function instance is the runtime environment of the restored pipeline.

[0063] Pipeline process: A Serverless application builds a pipeline instance.

[0064] OSS object storage: A cloud platform component that supports file storage. In this invention, it is used to store snapshot files of pipeline process states for transfer between new and old function instances.

[0065] The following details the pause and resume process of a basic Serverless application build pipeline:

[0066] (1) The user completes creating a Serverless application on the Function Compute platform and associates it with a remote Git code repository.

[0067] (2) When the user updates the remote Git code repository associated with the above application and the Webhook automatically triggers the Serverless application build pipeline, or the user actively initiates the build of the Serverless application.

[0068] (3) The function computing platform creates a new Serverless function instance to run and start triggering the execution of the above pipeline, and starts CRIU-Helper at the same time.

[0069] (4) The above pipeline executes the build step.

[0070] (5) The user initiates a request to suspend the above pipeline.

[0071] (6) CRIU-Helper receives the pause request and prepares to execute the CRIU dump command to capture the pipeline process information and kill the pipeline process. Assume that the pipeline process ID is 1234 and the pipeline is executed to Figure 5 For step 2 shown in the figure, the CRIU command to be executed is: criu dump-vvvv-odump.log -t 1234 --shell-job. After the command is executed, the process is killed (the corresponding Serverless function is also destroyed and recycled by the Function Compute platform), and a snapshot file is generated.

[0072] (7) CRIU-Helper uploads the above snapshot file to OSS object storage.

[0073] (8) The user initiates a request to restore the above pipeline.

[0074] (9) The Function Compute platform creates another Serverless function instance to prepare for running the new Serverless application build pipeline and starts CRIU-Helper at the same time.

[0075] (10) CRIU-Helper receives the recovery request and downloads the snapshot file from the OSS object storage.

[0076] (11) CRIU-Helper restores the pipeline process from the snapshot file to the state before executing CRIU dump in step (6). At this time, the pipeline continues to execute step 2 and subsequent steps.

[0077] The system provided in the embodiments of the present application adds a CRIU-Helper component to the Serverless function of the Serverless application pipeline. When the user performs a pause operation, the criudump command is executed on the pipeline process in the original function environment to generate a snapshot file, and the snapshot is uploaded to the OSS object storage. When the user performs a restore operation, the snapshot file is downloaded from the OSS object storage in the newly started function environment, and the criu restore command is executed to quickly restore the pipeline process to the state before the pause. There is no need to pull up the function instance to maintain the state during the pause to restore period, and the user does not need to write additional pause and restore logic.

[0078] This embodiment also provides a device for managing pipeline processes in a serverless architecture application. The device is used to implement the above-mentioned embodiments and preferred implementations, and the details that have been described will not be repeated. As used below, the term "module" can refer to a combination of software and / or hardware that implements a predetermined function. Although the devices described in the following embodiments are preferably implemented in software, implementation using hardware, or a combination of software and hardware, is also possible and contemplated.

[0079] This embodiment provides a management device for pipeline processes in serverless architecture applications, such as Figure 6 Shown, including:

[0080] An execution module 601 is configured to, upon receiving a user's request to pause a first pipeline in the serverless architecture, execute a first command, wherein the first command is configured to capture a process state of the first pipeline, generate a snapshot file based on the process state, and terminate the process of the first pipeline in the serverless architecture;

[0081] The storage module 602 is used to store the snapshot file in a preset storage platform.

[0082] In some optional embodiments, the above device further includes:

[0083] The first control module is configured to control the serverless architecture to create a second serverless architecture function when receiving a user's request to resume the first pipeline;

[0084] Download module, used to download snapshot files from the preset storage platform;

[0085] The recovery module is used to recover the process of the first pipeline based on the snapshot file and the second serverless architecture function to obtain the second pipeline.

[0086] In some optional embodiments, the above device further includes:

[0087] The second control module is configured to control the serverless architecture to construct a first serverless architecture function upon receiving a construction instruction of a serverless architecture application from a user;

[0088] The third control module is used to control the operation of the first serverless architecture function to trigger the execution pipeline to obtain the first pipeline.

[0089] The further functional description of each of the above modules and units is the same as that of the above corresponding embodiments and will not be repeated here.

[0090] The management device of the pipeline process in the serverless architecture application in this embodiment is presented in the form of a functional unit, where the unit refers to an ASIC (Application Specific Integrated Circuit) circuit, a processor and memory that executes one or more software or fixed programs, and / or other devices that can provide the above functions.

[0091] The embodiment of the present invention also provides a computer device having the above Figure 6 The management device of the pipeline process in the serverless architecture application is shown.

[0092] See also Figure 7 , Figure 7 is a structural diagram of a computer device provided by an optional embodiment of the present invention, such as Figure 7 As shown, the computer device includes: one or more processors 10, a memory 20, and interfaces for connecting various components, including high-speed interfaces and low-speed interfaces. Various components utilize different buses to communicate with each other and can be installed on a common mainboard or installed in other ways as needed. The processor can process the instructions executed in the computer device, including instructions stored in or on the memory to display the graphical information of a GUI on an external input / output device (such as, a display device coupled to the interface). In some optional embodiments, if necessary, multiple processors and / or multiple buses can be used together with multiple memories. Equally, multiple computer devices can be connected, and each device provides part of the necessary operations (for example, as a server array, a group of blade servers, or a multi-processor system). Figure 7 A processor 10 is taken as an example.

[0093] The processor 10 may be a central processing unit, a network processor, or a combination thereof. The processor 10 may further include a hardware chip. The hardware chip may be an application-specific integrated circuit, a programmable logic device, or a combination thereof. The programmable logic device may be a complex programmable logic device, a field programmable gate array, a general purpose array logic, or any combination thereof.

[0094] The memory 20 stores instructions that can be executed by at least one processor 10, so that the at least one processor 10 executes the method shown in the above embodiment.

[0095] The memory 20 may include a program storage area and a data storage area, wherein the program storage area may store an operating system and application programs required for at least one function; the data storage area may store data created based on the use of the computer device, etc. In addition, the memory 20 may include a high-speed random access memory, and may also include a non-transient memory, such as at least one disk storage device, a flash memory device, or other non-transient solid-state storage device. In some optional embodiments, the memory 20 may optionally include a memory remotely located relative to the processor 10, and these remote memories may be connected to the computer device via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0096] The memory 20 may include a volatile memory, such as a random access memory; the memory may also include a non-volatile memory, such as a flash memory, a hard disk or a solid-state drive; the memory 20 may also include a combination of the above types of memory.

[0097] The computer device further includes a communication interface 30 for the computer device to communicate with other devices or a communication network.

[0098] The embodiment of the present invention also provides a computer-readable storage medium. The above-mentioned method according to the embodiment of the present invention can be implemented in hardware, firmware, or implemented as a computer code that can be recorded in a storage medium, or implemented as a computer code that is originally stored in a remote storage medium or a non-temporary machine-readable storage medium and downloaded through a network and will be stored in a local storage medium, so that the method described herein can be stored in such software processing on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. Among them, the storage medium can be a magnetic disk, an optical disk, a read-only storage memory, a random access memory, a flash memory, a hard disk or a solid-state drive, etc.; further, the storage medium can also include a combination of the above-mentioned types of memory. It can be understood that a computer, a processor, a microprocessor controller or programmable hardware includes a storage component that can store or receive software or computer code. When the software or computer code is accessed and executed by a computer, a processor or hardware, the method shown in the above embodiment is implemented.

[0099] A portion of the present invention may be applied as a computer program product, such as a computer program instruction, which, when executed by a computer, can call or provide the method and / or technical solution according to the present invention through the operation of the computer. Those skilled in the art should understand that the form in which the computer program instruction exists in a computer-readable medium includes, but is not limited to, a source file, an executable file, an installation package file, etc. Accordingly, the way in which the computer program instruction is executed by the computer includes, but is not limited to: the computer directly executes the instruction, or the computer compiles the instruction and then executes the corresponding compiled program, or the computer reads and executes the instruction, or the computer reads and installs the instruction and then executes the corresponding installed program. Here, the computer-readable medium may be any available computer-readable storage medium or communication medium that can be accessed by the computer.

[0100] Although the embodiments of the present invention have been described with reference to the accompanying drawings, those skilled in the art may make various modifications and variations without departing from the spirit and scope of the present invention. Such modifications and variations are all within the scope defined by the appended claims.

Claims

1. A method for managing pipeline processes in a serverless architecture application, characterized in that: The method comprises: Upon receiving a user's pause request for a first pipeline in the serverless architecture, executing a first command, the first command being used to capture a process state of the first pipeline, generate a snapshot file based on the process state, and terminate the process of the first pipeline in the serverless architecture; The snapshot file is stored in a preset storage platform.

2. The method according to claim 1, characterized in that The method further comprises: When receiving a user's request to resume the first pipeline, controlling the serverless architecture to create a second serverless architecture function; Downloading a snapshot file from the preset storage platform; The process of the first pipeline is restored based on the snapshot file and the second serverless architecture function to obtain a second pipeline.

3. The method according to claim 1 or 2, characterized in that Before the step of receiving a user's request to pause the first pipeline in the serverless architecture and executing the first command, the method further includes: Upon receiving a construction instruction of a serverless architecture application from a user, controlling the serverless architecture to construct a first serverless architecture function; Control the first serverless architecture function to run to trigger the execution pipeline to obtain the first pipeline.

4. A management system for pipeline processes in serverless architecture applications, characterized in that: The system includes: a serverless architecture, a management platform, and a preset storage platform; The management platform is connected to the serverless architecture and the preset storage platform respectively, and is used to execute the management method of the pipeline process in the serverless architecture application as described in any one of claims 1 to 3.

5. A management device for pipeline processes in serverless architecture applications, characterized in that: The device comprises: an execution module configured to, upon receiving a user's pause request for a first pipeline in the serverless architecture, execute a first command, wherein the first command is configured to capture a process state of the first pipeline, generate a snapshot file based on the process state, and terminate the process of the first pipeline in the serverless architecture; The storage module is used to store the snapshot file in a preset storage platform.

6. The device according to claim 5, characterized in that The device further comprises: A first control module is configured to control the serverless architecture to create a second serverless architecture function when receiving a user's request to resume the first pipeline; A download module, configured to download the snapshot file from the preset storage platform; A recovery module is used to recover the process of the first pipeline based on the snapshot file and the second serverless architecture function to obtain a second pipeline.

7. The device according to claim 5 or 6, characterized in that The device further comprises: The second control module is configured to control the serverless architecture to construct a first serverless architecture function upon receiving a construction instruction of a serverless architecture application from a user; The third control module is used to control the operation of the first serverless architecture function to trigger the execution of the pipeline to obtain the first pipeline.

8. A computer device, characterized in that: include: A memory and a processor, wherein the memory and the processor are communicatively connected to each other, the memory stores computer instructions, and the processor executes the method for managing pipeline processes in a serverless architecture application according to any one of claims 1 to 3 by executing the computer instructions.

9. A computer-readable storage medium, characterized in that The computer-readable storage medium stores computer instructions, which are used to enable a computer to execute the method for managing pipeline processes in a serverless architecture application according to any one of claims 1 to 3.

10. A computer program product, characterized in that The method comprises computer instructions for causing a computer to execute the method for managing pipeline processes in a serverless architecture application according to any one of claims 1 to 3.

Images