CN110569044B

CN110569044B - Method, device and system for deploying application to running environment

Info

Publication number: CN110569044B
Application number: CN201910847016.9A
Authority: CN
Inventors: 纪鹏
Original assignee: Inspur General Software Co Ltd
Current assignee: Inspur General Software Co Ltd
Priority date: 2019-09-09
Filing date: 2019-09-09
Publication date: 2022-07-12
Anticipated expiration: 2039-09-09
Also published as: CN110569044A

Abstract

The invention provides a method, a device and a system for deploying an application to a running environment, wherein the method comprises the following steps: determining application configuration information of an application, each branch of the application and environment configuration information of each branch; when a client terminal deploys a first branch request, determining an application structure of an application according to application configuration information and environment configuration information of the branch, wherein the application structure comprises a source code file, an element declaration depending on the source code file, a task depending on the element declaration and an element declaration depending on the task; determining each task to be executed according to the application structure; generating a task script of each task to be executed according to the application structure, the environment configuration information and a preset rule base; generating a task execution queue according to the application structure and each task script; and sequentially processing each task script according to the environment address, the first branch and the task execution queue in the environment configuration information so as to deploy the application to the corresponding running environment. According to the scheme, the task script can be automatically generated, so that the application deployment efficiency is improved.

Description

Method, device and system for deploying application to running environment

Technical Field

The present invention relates to the field of computer technologies, and in particular, to a method, an apparatus, and a system for deploying an application to a runtime environment.

Background

During application service development, a development team needs to deploy applications to different operating environments, such as a development environment, a test environment, and a production environment. The version control tool (VCS) and the continuous integrated deployment tool (CI/CD) in combination can enable continuous delivery of applications. The most version control tools support the branch function, namely a new code set (characteristic branch) is derived on the basis of an existing code set (main branch), a development team modifies the characteristic branch to keep the main branch unchanged, and after development and verification are completed, the change of the characteristic branch is merged into the main branch. Thus, an application has a code library, each of which may have multiple branches, each branch including all source code files needed to generate an application artifact. In different branches, the file content, i.e. file version, of some source code files may be different, so that each branch corresponds to one version of the application. In addition, the persistent integrated deployment tool provides task scheduling functionality, with the development team providing the task scripts and trigger conditions needed to execute the task.

At present, in order to implement deployment of applications to different operating environments based on different branches, a development team writes a task script for each branch in consideration of differences of environment configuration information corresponding to different branches. When the system receives a deployment request based on one branch, the system executes a task script corresponding to the branch so as to deploy the application to the running environment.

This approach requires the development team to write task scripts for each branch, and in practice the differences in task scripts between different branches are limited, with most of the content being duplicated. When the deployment behavior of the whole application changes, the development team needs to modify the task script of each branch. Because the task script needs to be written artificially, the application deployment efficiency is low.

Disclosure of Invention

The invention provides a method, a device and a system for deploying an application to a running environment, which can automatically generate a task script so as to improve the deployment efficiency of the application.

In order to achieve the purpose, the invention is realized by the following technical scheme:

in a first aspect, the present invention provides a method for deploying an application to a runtime environment, comprising:

determining application configuration information of an application to be deployed and each branch of the application, wherein the branch identifications corresponding to different branches are different;

receiving environment configuration information of each branch provided by an external client, wherein the environment configuration information comprises an address of an operation environment;

when a deployment request which is sent by the client and comprises a first branch identifier is received, determining first environment configuration information of a first branch corresponding to the first branch identifier;

determining an application structure of the application according to the application configuration information and the first environment configuration information, wherein the application structure comprises: a source code file, an element declaration dependent on at least one source code file, a task dependent on at least one element declaration, an element declaration dependent on a task;

determining each task to be executed in the application structure according to the application structure;

generating a task script of each task to be executed according to the application structure, the first environment configuration information and a preset rule base;

generating a task execution queue according to the application structure and the generated task scripts;

and sequentially processing each generated task script according to the address of the running environment, the first branch and the task execution queue included in the first environment configuration information so as to deploy the application to the corresponding running environment.

Further, the application structure includes element declarations that: an application declaration dependent on a service orchestration task, an image declaration dependent on an image build task, an artifact declaration dependent on an artifact build task, a source code engineering declaration dependent on at least one source code file;

the application structure comprises the following tasks: services orchestration tasks that depend on at least one image declaration, image build tasks that depend on at least one artifact declaration, and artifact build tasks that depend on at least one source code engineering declaration.

Further, the determining the application structure of the application according to the application configuration information and the first environment configuration information includes:

determining an application structure of the application according to the application configuration information;

judging whether the first environment configuration information comprises hot deployment path information, if so, modifying the application structure according to the hot deployment path information, and if not, continuing the current process;

wherein the content of the first and second substances,

if so, determining each task to be executed in the application structure according to the application structure, including: determining each task remaining in the application structure as a task to be executed except for a mirror construction task on which a first mirror declaration depends and each artifact construction task on which the first mirror declaration indirectly depends, wherein the first mirror declaration has a mirror identification included in the hot deployment path information;

if not, determining each task to be executed in the application structure according to the application structure, including: and determining each task in the application structure as a task to be executed.

Further, the sequentially processing each generated task script to deploy the application to the corresponding runtime environment includes:

sequentially executing each generated other task script except the generated task script of the service orchestration task, storing the generated product into an external product warehouse, and storing the generated mirror image product into the external mirror image warehouse;

and sending the task script of the generated service orchestration task to an external service orchestration system to trigger the service orchestration system to deploy the application to a corresponding operating environment by executing the received service orchestration task according to the address of the operating environment, the generated mirror image script, the base mirror image specified in the hot deployment path information, and the source code engineering product of each source code engineering statement on which the first mirror image statement indirectly depends, which are included in the first environment configuration information.

Further, the generating a task script of each task to be executed according to the application structure, the first environment configuration information, and a preset rule base includes:

and judging whether the first environment configuration information comprises code compiling mode information and/or product deployment mode information, if so, generating a task script of each task to be executed according to the code compiling mode information and/or the product deployment mode information and a preset rule base, otherwise, generating the task script of each task to be executed according to the rule base.

Further, the code compiling mode information includes: a compilation mode, an article identification, and/or an article type;

generating a task script of each task to be executed according to the code compiling mode information and/or the product deployment mode information and a preset rule base, wherein the task script comprises:

when the first environment configuration information includes code compiling mode information, the following operations are executed for each product building task to be executed:

a1: judging whether the code compiling mode information comprises a product type which is dependent on a target product statement of a current product building task, if so, executing A3, otherwise, executing A2;

a2: judging whether the code compiling mode information comprises a product identifier of the target product statement, if so, executing A3, otherwise, executing A4;

a3: generating a task script of the current product construction task according to a preset rule base and a compiling mode included in the code compiling mode information, and ending the current flow;

a4: and generating a task script of the current product construction task according to the rule base.

Further, the product deployment mode information includes: a running mode, a mirror identification and/or a mirror type;

when the first environment configuration information includes the product deployment mode information, the following operations are executed for each mirror image construction task to be executed:

b1: judging whether the product deployment mode information comprises a mirror type which a target mirror declaration of a current mirror construction task belongs to, if so, executing B3, otherwise, executing B2;

b2: judging whether the product deployment mode information comprises a mirror image identifier of the target mirror image statement, if so, executing B3, otherwise, executing B4;

b3: generating a task script of the current mirror image construction task according to the rule base and an operation mode included in the product deployment mode information, and ending a current flow;

b4: and generating a task script of the current mirror image construction task according to the rule base.

Further, before sequentially processing each generated task script to deploy the application to the corresponding runtime environment, the method further includes:

judging whether the first environment configuration information comprises environment variable information, if so, determining a variable name and a variable value in the environment variable information, determining a target environment variable with the variable name in a corresponding operation environment according to an address of the operation environment included in the first environment configuration information, changing the value of the target environment variable into the variable value, and continuing the current flow, otherwise, continuing the current flow.

In a second aspect, the present invention provides an application configuration, integration and deployment system for performing any of the above methods for deploying an application to a runtime environment, the system comprising:

the device comprises a determining unit, a judging unit and a judging unit, wherein the determining unit is used for determining application configuration information of an application to be deployed and each branch of the application, and the branch identifications corresponding to different branches are different;

an environment configuration information receiving unit, configured to receive environment configuration information of each of the branches provided by an external client, where the environment configuration information includes an address of an operating environment;

a deployment request receiving unit, configured to determine, when receiving a deployment request that includes a first branch identifier and is sent by the client, first environment configuration information of a first branch corresponding to the first branch identifier;

an application structure determining unit, configured to determine an application structure of the application according to the application configuration information and the first environment configuration information, where the application structure includes: a source code file, an element declaration dependent on at least one source code file, a task dependent on at least one element declaration, an element declaration dependent on a task;

the task determining unit is used for determining each task to be executed in the application structure according to the application structure;

the task script generating unit is used for generating a task script of each task to be executed according to the application structure, the first environment configuration information and a preset rule base;

the task execution queue generating unit is used for generating a task execution queue according to the application structure and each generated task script;

and the application deployment processing unit is used for sequentially processing each generated task script according to the address of the running environment, the first branch and the task execution queue which are included in the first environment configuration information so as to deploy the application to the corresponding running environment.

In a third aspect, the present invention provides a system for deploying an application to a runtime environment, comprising: a client, a product warehouse, a mirror warehouse, a service orchestration system, and the application configuration, integration, and deployment system;

the client is used for sending externally input environment configuration information of each branch to the application configuration, integration and deployment system aiming at each branch of the application to be deployed, wherein the branch identifications corresponding to different branches are different, and the environment configuration information comprises addresses of running environments; when a first branch is triggered to request deployment, a deployment request comprising a branch identifier of the first branch is sent to the application configuration, integration and deployment system;

the application configuration, integration and deployment system is used for storing the product generated by executing the task script of the product construction task to the product warehouse; storing a mirror image product generated by executing a task script of a mirror image construction task to the mirror image warehouse; sending the generated task script of the service arrangement task to the service arrangement system;

the service orchestration system is configured to deploy the application to a corresponding operating environment by executing the received service orchestration task based on the mirror product stored in the mirror repository according to the address of the operating environment included in the environment configuration information of the first branch.

The invention provides a method, a device and a system for deploying an application to a running environment, wherein the method comprises the following steps: determining application configuration information of an application, each branch of the application and environment configuration information of each branch; when a client terminal deploys a first branch request, determining an application structure of an application according to application configuration information and environment configuration information of the branch, wherein the application structure comprises a source code file, an element declaration depending on the source code file, a task depending on the element declaration and an element declaration depending on the task; determining each task to be executed according to the application structure; generating a task script of each task to be executed according to the application structure, the environment configuration information and a preset rule base; generating a task execution queue according to the application structure and each task script; and sequentially processing each task script according to the environment address, the first branch and the task execution queue in the environment configuration information so as to deploy the application to the corresponding running environment. The invention can automatically generate the task script, thereby improving the application deployment efficiency.

Drawings

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below, and it is obvious that the drawings in the following description are some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to these drawings without creative efforts.

FIG. 1 is a flow diagram of a method for deploying an application to a runtime environment according to an embodiment of the present invention;

FIG. 2 is a diagram illustrating an application architecture according to an embodiment of the present invention;

FIG. 3 is a schematic diagram of another application architecture provided by an embodiment of the present invention;

FIG. 4 is a schematic diagram of an application configuration, integration, and deployment system provided by an embodiment of the invention;

fig. 5 is a schematic diagram of a system for deploying an application to a runtime environment according to an embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer and more complete, the technical solutions in the embodiments of the present invention will be described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention, and based on the embodiments of the present invention, all other embodiments obtained by a person of ordinary skill in the art without creative efforts belong to the scope of the present invention.

As shown in fig. 1, an embodiment of the present invention provides a method for deploying an application to a runtime environment, which may include the following steps:

step 101: determining application configuration information of an application to be deployed and each branch of the application, wherein the branch identifications corresponding to different branches are different.

Step 102: and receiving environment configuration information of each branch provided by an external client, wherein the environment configuration information comprises an address of an operation environment.

Step 103: when a deployment request which is sent by the client and comprises a first branch identification is received, first environment configuration information of a first branch corresponding to the first branch identification is determined.

Step 104: determining an application structure of the application according to the application configuration information and the first environment configuration information, wherein the application structure comprises: a source code file, an element declaration dependent on at least one source code file, a task dependent on at least one element declaration, an element declaration dependent on a task.

Step 105: and determining each task to be executed in the application structure according to the application structure.

Step 106: and generating a task script of each task to be executed according to the application structure, the first environment configuration information and a preset rule base.

Step 107: and generating a task execution queue according to the application structure and the generated task scripts.

Step 108: and sequentially processing each generated task script according to the address of the running environment, the first branch and the task execution queue included in the first environment configuration information so as to deploy the application to the corresponding running environment.

The method for deploying the application to the running environment provided by the embodiment of the invention comprises the following steps: determining application configuration information of an application, each branch of the application and environment configuration information of each branch; when a client terminal deploys a first branch request, determining an application structure of an application according to application configuration information and environment configuration information of the branch, wherein the application structure comprises a source code file, an element declaration depending on the source code file, a task depending on the element declaration and an element declaration depending on the task; determining each task to be executed according to the application structure; generating a task script of each task to be executed according to the application structure, the environment configuration information and a preset rule base; generating a task execution queue according to the application structure and each task script; and sequentially processing each task script according to the environment address, the first branch and the task execution queue in the environment configuration information so as to deploy the application to the corresponding running environment. The embodiment of the invention can automatically generate the task script, thereby improving the application deployment efficiency.

In this embodiment of the present invention, the execution subject of the above step 101 to step 108 may be an application configuration, integration, and deployment system, which may be referred to as a deployment system hereinafter.

In order to realize the automatic generation of the task script, the application structure of the application to be deployed needs to be determined in advance. Thus, in step 101, application configuration information of the application to be deployed needs to be determined in advance, so that the application structure can be determined according to the application configuration information. In one embodiment of the invention, the developer may write this application configuration information as needed and send it to the deployment system via the client.

Referring to fig. 2, fig. 2 shows an application structure of an application. Typically, the top layer of the application structure is the application declaration, and the bottom layer is the respective source code files. And based on all the source code files and combined with the concrete framework of the application structure, sequentially executing each task in the application structure, namely finally generating an application product of the application declaration.

The same source code file can have different versions, and the content of the source code file between different versions is different. In this way, when the application artifacts are generated based on different versions of the source code file, the application artifacts of different versions can be generated correspondingly.

Correspondingly, in order to deploy different application artifacts to the operating environment, developers can write different versions of the same source code file as needed. In this way, the branches of the application to be deployed can be determined, and each branch includes all the source code files required for generating the application artifacts. For example, when the application structure of the application to be deployed is shown in fig. 2, any branch of the application includes each source code file at the bottom layer in the application structure shown in fig. 2. Of course, in different branches, there is at least one source code file with different file versions.

Of course, in order to identify different branches for the deployment system, different branches have different branch identifications. Based on this, in step 101, each branch of the application to be deployed may also be determined in advance, that is, each source code file used for generating an application product is determined.

Based on the above, the application structure and branches may determine the applications to be deployed. Thus, when the application is deployed in the runtime environment, environment configuration information needs to be determined in advance to determine the runtime environment for the application deployment.

In detail, after each branch of the application is determined, since the application is deployed to the running environment according to any branch, the running environment generally corresponds to the branch, so that before the developer requests the application deployment, the developer can set the environment configuration information of each branch according to the preset branch, and send the environment configuration information to the deployment system. Of course, this environment configuration information needs to be assigned at least the address of the operating environment. Correspondingly, in step 102, the deployment system receives the environment configuration information provided by the client.

In the embodiment of the invention, as a plurality of branches of an application are available and the environment configuration information corresponding to each branch and branch is determined, a developer can send a deployment request aiming at different branch identifications, so that different application products of the same application can be respectively deployed to corresponding different operating environments based on the branch and environment configuration information corresponding to each branch identification, and the differential construction and deployment of the application in a plurality of environments are realized. It can be seen that, in order to implement multi-environment differentiation construction and deployment, a developer only needs to set branches and environment configuration information thereof as required, and the differentiation between different branches is usually not large, so that the operation of the developer is simpler.

In addition to the address of the operating environment, in an embodiment of the present invention, the environment configuration information may further include any one or more of hot deployment path information, code compiling mode information, and/or product deployment mode information and environment variable information.

Wherein, by setting the hot deployment path information, it can indicate that a certain element declaration in the application structure is deployed in a hot deployment manner; by setting the code compiling mode information, the compiling mode corresponding to the task script of a certain product building task in the application structure can be indicated; by setting the product deployment mode information, the deployment mode corresponding to the task script of a certain mirror image construction task in the application structure can be indicated; by setting the environment variable information, the value of a certain environment variable in the operating environment can be changed.

When a developer needs to deploy an application to a running environment, a deployment request can be made for a specific branch through a client. Thus, the branch identification of the specific branch can be carried in the deployment request sent by the client. Correspondingly, in step 103, the deployment system may determine the environment configuration information of the corresponding branch, that is, determine the first environment configuration information, according to the branch identifier when receiving the deployment request.

Since the environment configuration information may include hot deployment path information, and the presence of this information may cause a change in the application structure, the application structure of the application may be determined in step 104 by combining the application configuration information and the first environment configuration information. This application structure may be as shown in fig. 2, for example. Referring to fig. 2, the application structure includes a source code file, an element declaration dependent on at least one source code file, a task dependent on at least one element declaration, and an element declaration dependent on a task.

Specifically, the source code file dependent element declaration can be a source code engineering declaration, the source code engineering declaration dependent task can be an artifact building task, the artifact building task dependent element declaration can be an artifact declaration, the artifact declaration dependent task can be a mirror building task, the mirror building task dependent element declaration can be a mirror declaration, the mirror declaration dependent task can be a service orchestration task, and the service orchestration task dependent element declaration can be an application declaration.

The product of the corresponding product statement can be generated by executing the product building task, the image product of the corresponding image statement can be generated by executing the image building task, the application product of the corresponding application statement can be generated by executing the service orchestration task, and the generated application product can be deployed in the running environment to complete the deployment operation of deploying the application to the running environment.

Thus, in one embodiment of the invention, the application structure includes element declarations that are: an application declaration dependent on a service orchestration task, an image declaration dependent on an image build task, an artifact declaration dependent on an artifact build task, a source code engineering declaration dependent on at least one source code file;

Since the generation of the application product depends on each task in the application structure, in step 105, each task to be executed can be determined according to the determined application structure. Of course, these tasks to be performed are part or all of all tasks in the application structure.

In detail, by executing tasks in the application structure, the element artifacts of the current level element declaration can be generated according to the element artifacts of the corresponding lower level element declaration, and the process is circulated until the application artifacts are generated. Thus, a corresponding task script for each task to be executed needs to be generated.

In addition, since the environment configuration information may include code compiling mode information and/or product deployment mode information, and the generation of the task script may be affected by the existence of this information, in step 106, the application structure, the first environment configuration information, and the preset rule base may be combined to generate a corresponding task script for each task to be executed.

In detail, in the preset rule base, rules of how to generate instructions according to the structure of elements are stored.

For example, the article generation rules

Inputting: the source code engineering type is dotnetcore, and the dotnet built $ project dir' is output,

inputting: the source code engineering type dotnetcore, output 'javac $ project dir',

$ project dir is a placeholder and will eventually be replaced with the root folder of the source code project.

For example, mirror generation rules

Inputting: service type frontend, base mirror nginx

And (3) outputting: copy $ artifact/root/www

nginx run

$ artifact is the placeholder, which will eventually be replaced with the location of the artifact on which the mirror depends.

In step 107, after the corresponding task script of each task to be executed is generated, the task execution queue can be generated by combining the corresponding task script according to the logical relationship between the tasks to be executed defined in the application structure.

In step 108, the task scripts are processed according to the sequence of the task execution queue, and then the application product can be generated. Of course, the execution of the task script needs to use the source code file, so the task script is executed according to the branch, i.e. the first branch, to which the developer issues the deployment request. Certainly, in order to deploy the application product to the specific operating environment, the environment address of the application product needs to be acquired, that is, the address of the operating environment included in the first environment configuration information. In conclusion, the deployment operation of deploying the application to the running environment is completed.

For the processing operation of the deployment system on each task script, in an embodiment of the present invention, considering an external existing service orchestration system, a mirror product stored in a mirror repository may be read, and a service orchestration task is executed based on the read mirror product to generate an application product, so that the deployment system may execute only a task script of a product building task and a task script of a mirror building task, but not a task script of a service orchestration task, and deliver the task script of the service orchestration task to the service orchestration system for execution.

In detail, after the deployment system executes the corresponding task script to generate the product, the product may be stored in the product warehouse, and the product stored in the product warehouse is read, the corresponding task script is executed to generate a mirror image product, the generated mirror image product is stored in the mirror image warehouse, and finally, the task script of the service orchestration task and the operating environment address in the first environment configuration information are sent to the service orchestration system to trigger the service orchestration system to execute the received task script to generate the application product, and the application product is deployed to the corresponding operating environment.

As mentioned above, when the hot deployment path information is included in the first environment configuration information, the generation of the application structure and the determination of the task to be executed may be affected. Therefore, in an embodiment of the present invention, to illustrate a possible implementation manner of application deployment when there is hot deployment path information, in step 104, the determining an application structure of the application according to the application configuration information and the first environment configuration information includes:

judging whether the first environment configuration information comprises hot deployment path information, if so, modifying the application structure according to the hot deployment path information, and otherwise, continuing the current process;

wherein the content of the first and second substances,

if yes, the step 105 includes: determining each task remaining in the application structure as a task to be executed except for a mirror construction task on which a first mirror declaration depends and each artifact construction task on which the first mirror declaration indirectly depends, wherein the first mirror declaration has a mirror identification included in the hot deployment path information;

if the determination result is negative, the step 105 includes: and determining each task in the application structure as a task to be executed.

In the embodiment of the invention, firstly, the corresponding application structure is preliminarily generated according to the application configuration information, then whether the hot deployment path information exists is judged, if so, the application structure needs to be correspondingly changed, otherwise, the application structure does not need to be changed. Of course, after the application structure is changed, the task to be executed is determined based on the changed application structure.

If the application structure is changed, all tasks in the changed application structure are tasks to be executed except for each task on which the mirror declaration specified by the hot deployment path depends. Correspondingly, if the application structure is not changed, all tasks in the application structure are to-be-executed tasks.

For example, if the changed application structure is as shown in fig. 3, and the hot deployment path information includes the mirror identifier of the mirror declaration 1, the tasks to be executed include: service orchestration task 1, mirror build task 2, artifact build task 3, and artifact build task 4.

Based on the above, in an embodiment of the present invention, in order to illustrate a possible implementation manner of hot deploying an application to a runtime environment, in step 108, the sequentially processing each generated task script to deploy the application to a corresponding runtime environment includes:

Typically, the mirror artifacts of a mirror declaration are built on top of the base mirror, plus the artifact artifacts of each artifact declaration on which the mirror declaration indirectly depends. Thus, when the mirror product of the mirror declaration needs to be hot deployed, the base mirror can be used to replace the mirror product of the mirror declaration, and participate in arrangement with other generated mirror products, so as to be deployed as an application. And then directly copying the source code engineering products of all the source code engineering statements indirectly depended by the mirror image statement to a running environment, thereby achieving the purpose of hot deployment.

As such, the hot deployment path information may include three items of information, branch identification, mirror identification, and alternate mirror.

For example, assume that the application structure determined in step 104 is as shown in fig. 3, and the mirror image product of mirror image statement 1 is constructed by adding the product of product statement 1 and the product of product statement 2 on the base mirror image microsoft/dotnet. Because the mirror product of the mirror statement 1 needs to be hot deployed, the base mirror image microsoft/dotnet is used for replacing the mirror product of the mirror statement 1, and the base mirror image microsoft/dotnet and the mirror product of the mirror statement 2 participate in arrangement, so that the base mirror image microsoft/dotnet is deployed as an application. Then copying the source code engineering product of the source code engineering statement 1 and the source code engineering product of the source code engineering statement 2 to the running environment directly, thereby achieving the purpose of hot deployment.

As mentioned above, when the application structure is as shown in fig. 3, the tasks to be executed include the service orchestration task 1, the mirror image construction task 2, the artifact construction task 3, and the artifact construction task 4.

In detail, the deployment system may correspondingly and respectively obtain a source code engineering product 1 of the source code engineering statement 1, a source code engineering product 2 of the source code engineering statement 2, a source code engineering product 3 of the source code engineering statement 3, and a source code engineering product 4 of the source code engineering statement 4 according to corresponding contents of the source code file sets 1 to 4 in the first branch.

For the execution of the task script, specifically, the deployment system executes the task script of the product construction task 3 according to the source code engineering product 3 to generate the product 3, executes the task script of the product construction task 4 according to the source code engineering product 4 to generate the product 4, finally executes the task script of the mirror image construction task 2 according to the product 3 and the product 4 to generate the mirror image product 2, sends the task script of the service orchestration task 1 to the service orchestration system, and triggers the service orchestration system to deploy the application to the corresponding operating environment by executing the service orchestration task 1 according to the address of the operating environment, the mirror image product 2, the basic mirror image microsoft/dotnet, the source code engineering product 1 and the source code engineering product 2 included in the first environment configuration information.

In the embodiment of the invention, the hot deployment path is used for realizing the rapid generation of the application, so that developers can verify the result in time. For a specific branch, the existing basic mirror image is deployed in the operating environment, and for each request, the deployment system directly deploys the product of the source code engineering to the operating environment without passing through a product node and a mirror image node.

As mentioned above, when the first environment configuration information includes the code compiling mode information and/or the product deployment mode information, the generation of the task script is affected. Therefore, in an embodiment of the present invention, in order to illustrate a possible implementation manner of the script generation rule influencing the task script generation, the step 106 includes: and judging whether the first environment configuration information comprises code compiling mode information and/or product deployment mode information, if so, generating a task script of each task to be executed according to the code compiling mode information and/or the product deployment mode information and a preset rule base, otherwise, generating the task script of each task to be executed according to the rule base.

In the embodiment of the invention, when the script generation rule exists, the script generation rule and the preset rule base are combined to generate the task script, and when the script generation rule does not exist, the task script is directly generated according to the preset rule base.

In detail, the script generation rules may include code compilation mode information and/or artifact deployment mode information, both of which may exist separately or both of which may exist separately.

In detail, for the case that the script generation rule only includes the code compiling mode information, in an embodiment of the present invention, the code compiling mode information includes: a compilation mode, an article identification, and/or an article type;

In detail, the code compiling mode information may include three items of information of a branch identification, a product identification/type, and a compiling mode.

In the embodiment of the present invention, as long as a product declaration conforms to a specified product identifier/type and a task script of a product building task on which the product declaration depends is generated, a specified compiling mode needs to be satisfied.

In detail, for the case that the script generation rule only includes the product deployment manner information, in an embodiment of the present invention, the product deployment manner information includes: a running mode, a mirror identification and/or a mirror type;

b1: judging whether the product deployment mode information comprises a mirror type which a target mirror statement of a current mirror construction task belongs to, if so, executing B3, otherwise, executing B2;

b3: generating a task script of the current mirror image construction task according to the rule base and the operation mode included in the product deployment mode information, and ending the current flow;

In detail, the product deployment mode information may include three items of information, namely branch identification, mirror identification/type and operation mode.

In the embodiment of the present invention, as long as a mirror declaration conforms to a specified mirror identifier/type and a task script of a mirror construction task on which the mirror declaration depends is generated, a specified operation mode needs to be satisfied.

In detail, when the script generation rule includes both the code compiling mode information and the product deploying mode information, the task script generation process is a combination of the above two implementation modes, that is, the above a1 to a4 and B1 to B4 need to be executed.

In the embodiment of the invention, the script generation rule is used for realizing the construction and deployment of the application in a specific mode, so that a developer can check or debug the running state of the application in a running environment. For a particular branch, the system compiles the source code in debug mode, initiating services in debug mode.

As mentioned above, when the first environment configuration information includes the environment variable information, the running environment to which the application deployment is oriented may be affected. Therefore, in an embodiment of the present invention, in order to illustrate a possible implementation manner of the environment variable information affecting the execution environment to which the application deployment is oriented, before step 108, the method further includes:

In detail, the environment variable information may include three items of information, i.e., a branch identification, a variable name, and a variable value.

In the embodiment of the present invention, when the environment variable information exists, the existing operating environment is modified according to the environment variable information, and then step 108 is executed to deploy the application to the modified operating environment. When the environment variable information is not present, step 108 is performed directly.

In the embodiment of the invention, the environment variables are used for realizing that the applications generated by different branches are deployed to different running environments. For a particular branch, the deployment system deploys the application to the specified runtime environment using the configured target address.

As can be seen from the above, the environment configuration sub-information, such as the hot deployment path information, the code compiling mode information, the product deployment mode information, and the environment variable information, may include a branch identifier for distinguishing a branch targeted by the sub-information. Based on this, in an embodiment of the present invention, corresponding to step 102, the developer may send the environment configuration sub information with the branch identifier to the deployment system through the client, and after receiving one environment configuration sub information, the deployment system associates the environment configuration sub information with a corresponding branch according to the branch identifier therein, so as to determine the environment configuration information of each branch.

In summary, embodiments of the present invention provide a method for deploying an application to a runtime environment, where a deployment system determines an application structure based on application configuration information and environment configuration information, and then automatically generates a task script for each task to be executed in combination with the application structure and the environment configuration information, and deploys the application to the runtime environment through automatic execution of the task script. Therefore, developers and operation and maintenance personnel do not need to write scripts, and only need to provide the system with environment configuration information corresponding to each branch in advance, wherein the environment configuration information comprises a target address, a code compiling mode, a product deployment mode, a hot deployment path and the like of a running environment.

As shown in fig. 4, an embodiment of the present invention provides an application configuring, integrating, and deploying system, configured to perform any one of the above methods for deploying an application to a runtime environment, where the system includes:

a determining unit 401, configured to determine application configuration information of an application to be deployed, and each branch of the application, where branch identifiers corresponding to different branches are different;

an environment configuration information receiving unit 402, configured to receive environment configuration information of each of the branches provided by an external client, where the environment configuration information includes an address of an operating environment;

a deployment request receiving unit 403, configured to determine, when receiving a deployment request that includes a first branch identifier and is sent by the client, first environment configuration information of a first branch corresponding to the first branch identifier;

an application structure determining unit 404, configured to determine an application structure of the application according to the application configuration information and the first environment configuration information, where the application structure includes: a source code file, an element declaration dependent on at least one source code file, a task dependent on at least one element declaration, an element declaration dependent on a task;

a task determining unit 405, configured to determine, according to the application structure, each to-be-executed task in the application structure;

a task script generating unit 406, configured to generate a task script of each to-be-executed task according to the application structure, the first environment configuration information, and a preset rule base;

a task execution queue generating unit 407, configured to generate a task execution queue according to the application structure and each generated task script;

the application deployment processing unit 408 is configured to sequentially process each generated task script according to the address of the runtime environment, the first branch, and the task execution queue included in the first environment configuration information, so as to deploy the application to the corresponding runtime environment.

The information interaction, execution process and other contents between the units in the system are based on the same concept as the method embodiment of the present invention, and specific contents can be referred to the description in the method embodiment of the present invention, and are not described herein again.

Based on the foregoing, as shown in fig. 5, an embodiment of the present invention provides a system for deploying an application to a runtime environment, which may include:

a client 501, an article repository 502, an image repository 503, a service orchestration system 504, and the above-mentioned application configuration, integration, and deployment system 505;

the client 501 is configured to send, for each branch of an application to be deployed, externally input environment configuration information of each branch to the application configuration, integration, and deployment system 505, where the branch identifiers corresponding to different branches are different, and the environment configuration information includes an address of an operating environment; when a first branch is triggered to request deployment externally, sending a deployment request including a branch identifier of the first branch to the application configuration, integration and deployment system 505;

the application configuration, integration, and deployment system 505 to store an article product generated by executing a task script of an article building task to the article repository 502; storing a mirror image product generated by executing a task script of a mirror image construction task to the mirror image warehouse 503; sending the generated task script of the service orchestration task to the service orchestration system 504;

the service orchestration system 504 is configured to deploy the application to the corresponding operating environment by executing the received service orchestration task based on the image product stored in the image repository 503 according to the address of the operating environment included in the environment configuration information of the first branch.

In the embodiment of the invention, the task script is processed by the deployment system in such a way that only the task scripts of the product construction task and the mirror image construction task are executed, the task script of the service orchestration task is sent, the existing service orchestration task is specially executed to generate an application product, and the application product is deployed to the service orchestration system of the operating environment. Correspondingly, the service orchestration system deploys the application to the corresponding runtime environment by executing the received service orchestration task.

In summary, the embodiments of the present invention have at least the following advantages:

1. the method for deploying the application to the running environment provided by the embodiment of the invention comprises the following steps: determining application configuration information of an application, each branch of the application and environment configuration information of each branch; when a client terminal deploys a first branch request, determining an application structure of an application according to application configuration information and environment configuration information of the branch, wherein the application structure comprises a source code file, an element declaration depending on the source code file, a task depending on the element declaration and an element declaration depending on the task; determining each task to be executed according to the application structure; generating a task script of each task to be executed according to the application structure, the environment configuration information and a preset rule base; generating a task execution queue according to the application structure and each task script; and sequentially processing each task script according to the environment address, the first branch and the task execution queue in the environment configuration information so as to deploy the application to the corresponding running environment. The embodiment of the invention can automatically generate the task script, thereby improving the application deployment efficiency.

2. In the embodiment of the invention, as a plurality of branches of one application are available and the environmental configuration information corresponding to each branch and branch is determined, a developer can send a deployment request aiming at different branch identifications, so that different application products of the same application can be respectively deployed to corresponding different operating environments based on the branch and environmental configuration information corresponding to each branch identification, and the application can be differentially constructed and deployed in a plurality of environments. It can be seen that, in order to implement multi-environment differentiation construction and deployment, a developer only needs to set branches and environment configuration information thereof as required, and the differentiation between different branches is usually not large, so that the operation of the developer is simpler.

3. In the embodiment of the invention, the hot deployment path is used for realizing the rapid generation of the application, so that developers can verify the result in time. For a specific branch, the existing basic mirror image is deployed in the operating environment, and for each request, the deployment system directly deploys the product of the source code engineering to the operating environment without passing through a product node and a mirror image node.

4. In the embodiment of the invention, the script generation rule is used for realizing the construction and deployment of the application in a specific mode, so that a developer can check or debug the running state of the application in a running environment. For a particular branch, the system compiles the source code in debug mode, initiating services in debug mode.

5. In the embodiment of the invention, the environment variables are used for realizing that the applications generated by different branches are deployed to different running environments. For a particular branch, the deployment system deploys the application to the specified runtime environment using the configured target address.

6. The embodiment of the invention provides a method for deploying an application to a running environment. Therefore, developers and operation and maintenance personnel do not need to write scripts, and only need to provide the system with environment configuration information corresponding to each branch in advance, wherein the environment configuration information comprises a target address, a code compiling mode, a product deployment mode, a hot deployment path and the like of a running environment.

It is noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising a" does not exclude the presence of other similar elements in a process, method, article, or apparatus that comprises the element.

Those of ordinary skill in the art will understand that: all or part of the steps for realizing the method embodiments can be completed by hardware related to program instructions, the program can be stored in a computer readable storage medium, and the program executes the steps comprising the method embodiments when executed; and the aforementioned storage medium includes: various media that can store program codes, such as ROM, RAM, magnetic or optical disks.

Finally, it is to be noted that: the above description is only a preferred embodiment of the present invention, and is only used to illustrate the technical solutions of the present invention, and not to limit the protection scope of the present invention. Any modification, equivalent replacement, or improvement made within the spirit and principle of the present invention shall fall within the protection scope of the present invention.

Claims

1. A method of deploying an application to a runtime environment, comprising:

sequentially processing each generated task script according to the address of the running environment, the first branch and the task execution queue included in the first environment configuration information so as to deploy the application to the corresponding running environment;

the application structure comprises element declarations that: an application declaration dependent on a service orchestration task, an image declaration dependent on an image build task, an artifact declaration dependent on an artifact build task, a source code engineering declaration dependent on at least one source code file;

the application structure comprises the following tasks: a service orchestration task dependent on the at least one image declaration, an image build task dependent on the at least one artifact declaration, an artifact build task dependent on the at least one source code engineering declaration;

determining an application structure of the application according to the application configuration information and the first environment configuration information, including:

wherein the content of the first and second substances,

if so, determining each task to be executed in the application structure according to the application structure, including: determining each task to be executed except an image construction task depended by a first image statement and each product construction task depended indirectly in the application structure, wherein the first image statement has an image identifier included in the hot deployment path information;

if not, determining each task to be executed in the application structure according to the application structure, including: determining each task in the application structure as a task to be executed;

the sequential processing of each generated task script to deploy the application to a corresponding runtime environment comprises:

sending the task script of the generated service orchestration task to an external service orchestration system to trigger the service orchestration system to deploy the application to a corresponding operating environment by executing the received service orchestration task according to an address of the operating environment, the generated mirror script, a base mirror specified in the hot deployment path information, and a source code engineering product of each source code engineering statement on which the first mirror statement indirectly depends, which are included in the first environment configuration information;

generating a task script of each task to be executed according to the application structure, the first environment configuration information and a preset rule base, wherein the task script comprises:

judging whether the first environment configuration information comprises code compiling mode information and/or product deployment mode information, if so, generating a task script of each task to be executed according to the code compiling mode information and/or the product deployment mode information and a preset rule base, otherwise, generating a task script of each task to be executed according to the rule base;

the code compiling mode information includes: a compilation mode, an article identification, and/or an article type;

when the first environment configuration information comprises code compiling mode information, aiming at each product construction task to be executed, the following operations are executed:

a4: generating a task script of the current product construction task according to the rule base;

the product deployment mode information includes: a running mode, a mirror identification and/or a mirror type;

b4: generating a task script of the current mirror image construction task according to the rule base;

before each generated task script is sequentially processed to deploy the application to the corresponding running environment, the method further comprises the following steps:

2. An application configuration, integration and deployment system for performing the method of deploying an application to a runtime environment of claim 1, the system comprising:

3. A system for deploying an application to a runtime environment, comprising:

a client, an article repository, a mirror repository, a service orchestration system, and an application configuration, integration, and deployment system according to claim 2;