CN115964062A

CN115964062A - Application cloud deployment method, device, equipment, storage medium and program product

Info

Publication number: CN115964062A
Application number: CN202211398820.1A
Authority: CN
Inventors: 蔡中原; 孙政清; 袁丰; 白佳乐
Original assignee: Industrial and Commercial Bank of China Ltd ICBC
Current assignee: Industrial and Commercial Bank of China Ltd ICBC
Priority date: 2022-11-09
Filing date: 2022-11-09
Publication date: 2023-04-14

Abstract

The application relates to a deployment method, a deployment device, an application deployment apparatus, a storage medium and a program product on an application cloud, and relates to the technical field of cloud computing. The method comprises the following steps: firstly, responding to a cloud deployment request of a target application, determining a plurality of container sets according to containers in each node in the target application, wherein each container set comprises a container group formed by partial containers in each node; then, in the process of sequentially upgrading the versions of the container sets, verifying the version of the container set after the current container set is upgraded; if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions after the container set upgrading pass the verification, and determining that the deployment on the cloud of the target application is completed. By adopting the method, the high availability and the service continuity of the target application in the cloud deployment process can be ensured.

Description

Application cloud deployment method, device, equipment, storage medium and program product

Technical Field

The present application relates to the field of cloud computing technologies, and in particular, to a method, an apparatus, a device, a storage medium, and a program product for deploying an application on a cloud.

Background

With the advent of the cloud's native flood, whether small-scale applications or complex large-scale applications, it has become overwhelming to apply them into the cloud.

In the related art, when an application is launched into the cloud, the application is usually deployed on the cloud at one time. However, for complex large-scale applications, deployment on the cloud is completed at one time, and a series of problems such as unavailable service, degraded service and the like can be caused by application interruption caused by version quality or system problems.

Therefore, how to guarantee high availability and service continuity of complex large-scale application in the cloud deployment process becomes a technical problem to be solved urgently.

Disclosure of Invention

In view of the foregoing, there is a need to provide an application cloud deployment method, apparatus, device, storage medium, and program product capable of ensuring high availability and service continuity of complex large-scale applications in the cloud deployment process.

In a first aspect, the present application provides a deployment method on an application cloud, the method comprising:

responding to a cloud deployment request of a target application, and determining a plurality of container sets according to containers in each node in the target application, wherein each container set comprises a container group formed by part of containers in each node;

in the process of sequentially upgrading the versions of the container sets, verifying the version of the container set after the current container set is upgraded;

if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified to pass, and determining that the cloud deployment of the target application is completed.

In one embodiment, determining a plurality of container sets from containers in nodes within a target application includes:

acquiring the function type of each node;

and dividing containers in each node according to the function type of each node to determine a plurality of container sets.

In one embodiment, dividing the containers in each node according to the function type of each node, and determining a plurality of container sets includes:

determining the upgrading configuration proportion of each node according to the function type of each node;

and determining a plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportions.

In one embodiment, the upgrade configuration proportion of each node comprises a plurality of different configuration proportions; determining a plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportions, wherein the container sets comprise:

according to a plurality of configuration proportion combinations among preset nodes, executing container set creation operation on containers in each node to obtain a plurality of container sets; the configuration proportion combination comprises any one configuration proportion in each node; wherein the container set creation operation comprises:

for any configuration proportion combination, acquiring a target container group corresponding to each node according to the configuration proportion of each node in the configuration proportion combination;

and combining the target container groups to form a container set.

In one embodiment, acquiring a target container group corresponding to each node according to the configuration proportion of each node in the configuration proportion combination includes:

and for any node, determining a target container group corresponding to the node according to the configuration proportion of the node and the total number of containers in the node.

In one embodiment, each node comprises a front-end node, a back-end node, a database node and a cache node; the target container group corresponding to each node correspondingly comprises a front-end target container group, a rear-end target container group, a database target container group and a cache target container group; combining the target container groups to form a plurality of container sets, comprising:

and combining the front-end target container group, the rear-end target container group, the database target container group and the cache target container group into a container set.

In one embodiment, verifying the version of the container set updated by the current container set comprises:

acquiring a container group version of each node in the current container set after the container group is upgraded;

and respectively verifying the container group versions to determine the version verification result of the container set version which is upgraded and completed by the current container set.

In one embodiment, the verifying the container group versions respectively to determine the version verification result of the container set version with the updated current container set includes:

if the versions of all the container groups pass the verification, determining that the version of the container set of the current container set passes the verification;

and if any container group version verification fails, determining that the container set version verification of the current container set fails.

In a second aspect, the application also provides an application on-cloud deployment apparatus. The device includes:

the system comprises a container set determining module, a container set determining module and a container set determining module, wherein the container set determining module is used for responding to a cloud deployment request of a target application and determining a plurality of container sets according to containers in nodes in the target application, and each container set comprises a container group formed by partial containers in the nodes;

the version verification module is used for verifying the version of the container set after the current container set is upgraded in the process of sequentially upgrading the version of each container set;

the application deployment module is used for carrying out version upgrading on the current container set again if the version verification of the container set fails; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified to pass, and determining that the cloud deployment of the target application is completed.

In a third aspect, the present application also provides a computer device. The computer device comprises a memory storing a computer program and a processor implementing the steps of the method in any of the embodiments of the first aspect described above when the processor executes the computer program.

In a fourth aspect, the present application further provides a computer-readable storage medium. The computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of the method in any of the embodiments of the first aspect described above.

In a fifth aspect, the present application further provides a computer program product. The computer program product comprising a computer program which, when executed by a processor, performs the steps of the method in any of the embodiments of the first aspect described above.

The application cloud deployment method, the application cloud deployment device, the application cloud deployment equipment, the application cloud deployment storage medium and the application cloud deployment program firstly respond to a cloud deployment request of a target application, and determine a plurality of container sets according to containers in nodes in the target application, wherein each container set comprises a container group formed by partial containers in the nodes; then, in the process of sequentially upgrading the versions of the container sets, verifying the version of the container set after the current container set is upgraded; if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified to pass, and determining that the cloud deployment of the target application is completed. The method for deploying the application on the cloud is characterized in that the target application is divided into a plurality of container sets, each container set is equivalent to an upgrading version of the target application, and version verification is performed on versions of the container sets in sequence, namely the versions with different upgrading degrees are verified progressively until the target application is deployed on the cloud. The verification process only aims at partial nodes of the target application each time, and version upgrading or version restoration can be flexibly carried out, so that high availability and service continuity of the target application in the deployment process on the cloud are guaranteed.

Drawings

FIG. 1 is a diagram of an application environment in which the method of deployment on the application cloud is implemented, in one embodiment;

FIG. 2 is a schematic flow chart diagram illustrating a method for deploying an application cloud in one embodiment;

FIG. 3 is a schematic flow chart diagram illustrating the container set retrieving step in one embodiment;

FIG. 4 is a flowchart of a container set retrieving step in another embodiment;

FIG. 5 is a flowchart illustrating the container set creation step in one embodiment;

FIG. 6 is a flow diagram that illustrates version deployment, according to one embodiment;

FIG. 7 is a flowchart illustrating the container set version verification step in one embodiment;

FIG. 8 is a flowchart of a container set version verification result obtaining step in one embodiment;

FIG. 9 is a flowchart illustrating a deployment method on an application cloud according to another embodiment;

FIG. 10 is a block diagram of an apparatus for deployment on an application cloud in one embodiment;

FIG. 11 is a diagram illustrating an internal structure of a computer device in one embodiment.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more clearly understood, the present application is further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.

The deployment method on the application cloud provided by the embodiment of the application can be applied to the application environment shown in fig. 1. The cloud 102 communicates with the server 104 through a network, and progressive deployment and verification of a target application on the cloud 102 are achieved. The data storage system may store data that the server 104 needs to process, such as a verification version of the application on the cloud 102, and data related to a verification program. The data storage system may be integrated on the server 104 or may be placed on the cloud or other network server. The server 104 may be implemented as a stand-alone server or a server cluster comprised of multiple servers.

In the related technology, a gray release (also called gold sparrow release) method is adopted as an application cloud deployment method, and specifically, under the condition that an original version is available, a new version application is deployed as a gold sparrow at the same time, and the performance of the new version are tested, so that the problems are discovered and adjusted as soon as possible under the condition that the whole system is stable. However, the gray scale release is suitable for small-scale application upgrade, the gray scale upgrade proportion needs to be manually set for the nodes respectively, and the gray scale upgrade effect needs to be manually deployed and verified.

Based on the method, the upgrading proportion and the upgrading plan of various nodes are fully automated, and automatic feedback is realized aiming at the upgrading effect, so that the nodes can be quickly followed or backed up.

The following describes an application cloud deployment method provided in the embodiments of the present application.

In one embodiment, as shown in fig. 2, a deployment method on an application cloud is provided, which is described by taking the method as an example applied to the cloud end 102 in fig. 1, and includes the following steps:

s202, responding to a cloud deployment request of the target application, determining a plurality of container sets according to containers in each node in the target application, wherein each container set comprises a container group formed by partial containers in each node.

The target application is a complex large-scale application which consists of a front-end node, a back-end node, a database node and a cache database node, and each type of node comprises a large number of containers. The front-end node is responsible for providing visual pages and simplifying operation; the back-end node is responsible for receiving the front-end request and accessing parameter data to the database; the database node is responsible for storing parameter data; the cache database node is responsible for storing the session information and temporary data of the application; the container encapsulates all relevant details necessary to run the application, such as application dependencies and operating systems.

The container group is composed of partial containers of each node, and corresponds to the node type. The container set is a set formed by container groups corresponding to the four types of nodes, and the container set corresponds to the application version.

It should be noted that the cloud deployment request is generated based on a requirement of deployment of the target application on the cloud, and when responding to the cloud deployment request, first, according to a container in each node of the target application, a plurality of container groups corresponding to each node are determined, and then, a container set is constructed based on the plurality of container groups of each node, that is, the container set is formed by combining partial containers of the target application.

Optionally, a container group corresponding to each node is determined according to a container in each node in the target application, where the container group includes all containers of each node; the container groups are then placed in the same set as the container set. At this time, the target application only corresponds to one container set, namely the container set after all nodes of the application are upgraded.

Optionally, a container group corresponding to each node is determined according to a container in each node in the target application, where the container group includes all containers of each node; and then, the container groups of different nodes are arranged in different sets to obtain a plurality of container sets. At the moment, the target application corresponds to a plurality of container sets, and each container set comprises upgrading containers of different application nodes.

And S204, verifying the container set version after the current container set is upgraded in the process of sequentially upgrading the versions of the container sets.

And updating the corresponding container in the application version according to the container upgraded in the container set in all the containers of the application version, and taking the updated application version as the container set version.

It should be noted that the cloud deployment in the application in the embodiment of the present application is a progressive deployment, that is, different container sets include different containers of each node in the target application, and different container set versions correspond to application versions with different deployment degrees. Wherein, more nodes containing the target application indicate that the deployment degree of the application version is higher.

In the actual verification process of the target application, the version of the container set upgraded at the current container set is verified, and different container sets are sequentially verified according to the sequence of the deployment degree from low to high. Specifically, each container set of the container set version is obtained first, then each container set is verified respectively, and then the container set version is verified on the basis that each container set is verified successfully.

S206, if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified to pass, and determining that the cloud deployment of the target application is completed.

After the container set versions are obtained, the container set versions need to be traversed to verify the container set versions. If the version verification of the container set fails, it is indicated that the container group in the container set corresponding to the version of the container set cannot be normally deployed on the cloud, and at this time, version upgrading needs to be performed on the current container set again; if the container version passes the verification, the container group in the container set corresponding to the container version can be normally deployed on the cloud, then the version of the next container set needs to be upgraded, and when the container set version passes the verification, the deployment on the cloud of the target application is completed.

In the embodiment of the application, firstly, responding to a cloud deployment request of a target application, and determining a plurality of container sets according to containers in each node in the target application, wherein each container set comprises a container group formed by part of containers in each node; then, in the process of sequentially upgrading the versions of the container sets, verifying the version of the container set after the current container set is upgraded; if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions after the container set upgrading pass the verification, and determining that the deployment on the cloud of the target application is completed. In the deployment method on the application cloud, the target application is divided into a plurality of container sets, each container set is equivalent to the upgrade version of the target application, and the version verification is performed on the container sets in sequence, namely the verification is performed on the versions with different upgrade degrees progressively until the target application is deployed on the cloud. The verification process only aims at partial nodes of the target application each time, and version upgrading or version restoration can be flexibly performed, so that high availability and service continuity of the target application in the deployment process on the cloud are guaranteed.

When verification is performed on deployment on the application cloud, verification can be performed respectively according to the plurality of container sets so as to ensure that verification is performed on deployment versions in batches. Based on this, the specific acquisition steps of the container set are explained below by an embodiment.

In one embodiment, as shown in fig. 3, determining a plurality of container sets according to containers in nodes in a target application includes:

s302, acquiring the function type of each node.

Each node in the target application can be divided into a front-end node, a back-end node, a database node and a cache node according to the function type. The front-end node realizes the display function of the target application, the back-end node realizes the functions of receiving requests and accessing data, the database node realizes the representation function of various node relationships, and the cache node realizes the data storage function. It should be noted that, various nodes supplement each other and jointly form an application, that is, only when each node of the target application is respectively in the cloud and can normally operate, the target application can provide a normal service.

S304, dividing the containers in each node according to the function type of each node, and determining a plurality of container sets.

In order to ensure that applications including various nodes have high availability, the containers in the nodes need to be divided, and the containers in the nodes can be divided into new containers and old containers in a preset proportion or manual designation mode; and then determining the new container in each node as a container set corresponding to each node.

It should be noted that, in the process of dividing the containers in each node, each time a part of the containers in each node are determined as a container set, a plurality of container sets can be determined for a plurality of divisions of the containers in each node.

In the embodiment of the application, the function type of each node is obtained first, and then the containers in each node are divided according to the function type of each node to generate a plurality of container sets. The container set comprises part of nodes of the application, and the container set is verified in sequence in the actual verification process, so that the flexible setting of the container set in the embodiment of the application can support flexible upgrading of the target application.

When the container set is constructed, the containers of all the nodes can be divided according to a preset mode so as to comprehensively cover all the nodes of the target application. Based on this, the following describes a specific acquisition step of the container set from the dimension of the preset manner by an embodiment.

In one embodiment, as shown in fig. 4, dividing the containers in each node according to the function type of each node, and determining a plurality of container sets includes:

s402, determining the upgrading configuration proportion of each node according to the function type of each node.

After all nodes of the target application are obtained, the containers of all the nodes are classified according to the node function types. Specifically, the application contents of a plurality of containers in each node may be evaluated according to the function type of the node, and then the upgrade configuration proportion of each node may be determined based on the evaluation result of the application contents of the plurality of containers in each node. It should be noted that the containers of the nodes may be set in batches, and the upgrade configuration ratio of each batch may be freely set.

For example, if the node type is a front-end node, since the front-end node is only used for paged display, the upgrade configuration proportion of each batch may be set to 30%, that is, in the upgrade process of the first batch, 30% of the front-end nodes are upgraded to a new version, and 70% of the nodes still maintain the old version; and then, on the basis of 70% of nodes of the old version, upgrading the second batch according to the upgrading configuration proportion of 30%, and so on until all the nodes of the front-end node are completely upgraded. Because the contents of the containers in the backend node, the database node and the cache node are important, the upgrade configuration proportion of each batch can be set to be 20% for the sake of stability, and if all the upgrade of the backend node, the database node and the cache node is completed, each type of node needs to perform configuration upgrade of five batches.

S404, determining a plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportions.

And according to the upgrade configuration proportion of each node, acquiring a new container group of each node, combining the new container groups of different nodes and determining a container set. Because the upgrade configuration proportion of each node is set in batches, each node corresponds to a plurality of new container groups, and correspondingly, the new container groups of different nodes are combined to obtain a plurality of container sets.

In the embodiment of the application, a plurality of container sets are determined according to the upgrading configuration proportion. Because the upgrade configuration proportion is divided according to the batch, the corresponding container set is also divided according to the batch, and thus the container set can be verified in batches. Namely, the target application node is verified while the target application can be normally used.

When the container set is constructed, the container of each node can be combined to ensure that the function type of the container set covers each node, namely, a complete application version is obtained. Based on this, the following describes a specific acquisition step of a container set from the combined dimensions of the container group by an embodiment.

In one embodiment, the upgrade configuration proportion of each node comprises a plurality of different configuration proportions; determining a plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportions, wherein the container sets comprise: according to a plurality of configuration proportion combinations among preset nodes, executing container set creation operation on containers in each node to obtain a plurality of container sets; the configuration ratio combination includes any one of the configuration ratios in each node.

Because the configuration proportion of each node is preset independently, the number of containers in the container group of each node can be determined according to different configuration proportions of each node; then, acquiring each container group of each node according to the number of the containers; finally, a plurality of container sets are created by grouping the containers of the nodes.

As shown in fig. 5, the container set creating operation includes:

s502, for any configuration proportion combination, according to the configuration proportion of each node in the configuration proportion combination, a target container group corresponding to each node is obtained.

Each configuration proportion combination comprises a configuration proportion of a front-end node, a configuration proportion of a rear-end node, a configuration proportion of a database node and a configuration proportion of a cache node. After any configuration proportion combination is obtained, the number of containers required to be configured in each node is determined according to the configuration proportion of each node, and the number of containers required to be configured in each node is used as a target container group corresponding to the node.

S504, the target container groups are combined to form a container set.

After the target container group of each node is obtained, a container set formed by each target container group needs to be verified, specifically, each target container group is combined to obtain a container set including part of containers of each node, and the container set is used for verifying the application version of the configuration proportion combination.

Illustratively, taking a orchestration management tool (K8S) as an example, the schematic diagram of version deployment of an application is shown in fig. 6, where a target application has four types of nodes, namely a front-end node, a back-end node, a database node, and a cache database node, where the front-end node includes 100 containers, the back-end node includes 200 containers, the database node includes 300 containers, and the cache database node includes 150 containers. The management node of K8S combines 30 containers of the front-end node as a target container group of the front-end node according to the configuration proportion of 30% of the front-end node, 20% of the back-end node, 20% of the database node and 20% of the cache database node; the 40 containers of the back-end node are used as a target container group of the back-end node; taking 60 containers of the database nodes as a target container group of the database nodes; and taking 30 containers of the cache database node as a target container group of the cache database node, and combining the old containers of all the nodes to place in different working nodes to generate an application version corresponding to the configuration proportion combination. And combining the target container groups of the four types of nodes to form a container set corresponding to the configuration proportion combination, and placing the container set corresponding to the configuration proportion combination in the storage node through the management node of the K8S.

In the embodiment of the application, the container set is formed by combining the arrangement management tool according to a plurality of preset configuration proportions among the nodes, and the method is high in logicality and simple to operate. In addition, the storage node of the arrangement management tool records the container set corresponding to each configuration proportion combination, and the application version corresponding to each batch of configuration proportion combination can be updated and recorded, so that the operation and maintenance pressure of operation and maintenance personnel is relieved.

When constructing a container set, a container group is generally obtained according to the container in each node, and then the container set is obtained by sorting the container groups. Based on this, a specific acquisition procedure of the container group is explained below by an embodiment.

For any node, the configuration proportion of the node can be directly multiplied by the total number of containers in the node, the target container number of the node is determined, and then the target container group of the node is determined according to the target container number. Illustratively, there are 500 containers in a node, and the configuration proportion of the node is 20%, then 100 containers of the node are taken as the target container group corresponding to the node.

In the embodiment of the application, the target container group is determined according to the configuration proportion of the nodes and the total number of the containers in the nodes, and the configuration proportion of the nodes can be flexibly set on the basis of the total number of the containers in the nodes to obtain the target container groups with different numbers, so that container sets with different scales are generated, and upgrading verification is performed on different application versions in the follow-up process.

When constructing a container set, the container set may be obtained from each container group to fully cover all the containers of each node. Based on this, the following describes a specific acquisition step of the container set from the dimension of the composition manner by an embodiment.

In one embodiment, each node comprises a front-end node, a back-end node, a database node and a cache node; the target container group corresponding to each node correspondingly comprises a front-end target container group, a rear-end target container group, a database target container group and a cache target container group; combining the target container groups to form a plurality of container sets, including:

It should be noted that the complex application generally includes four types of nodes, i.e., a front-end node, a back-end node, a database node, and a cache node, and the large-scale application generally includes hundreds of nodes, and only when various types of nodes supplement each other and work normally at the same time, it can be determined that the deployment of the target application is successful, that is, the version verification passes.

For complex and large-scale target applications, the target container groups of the nodes are obtained according to the configuration proportion of the nodes, and then the target container groups of the nodes are combined to obtain a container set corresponding to the target applications.

In the embodiment of the application, the container sets are obtained by combining the target container sets based on various nodes, each container set is complex to apply because each container set comprises four types of nodes, the number of containers of each target container set is specified and preset, and when the target container set comprises a plurality of containers, the container sets are applied in a large scale. In summary, each container set can set different verification versions of the target application according to requirements, which means that the container set constructed in the embodiment of the present application can satisfy the verification of application versions with different complexity and different scales.

When the cloud deployment version of the application is verified, the application can be deployed into the cloud for verification at one time, and the application can also be deployed into the cloud in batches for verification. Based on this, the specific verification steps of the application version are explained below by an embodiment.

In one embodiment, as shown in fig. 7, verifying the upgraded version of the container set of the current container set includes:

s702, acquiring a container group version of each node in the current container set after the container group is upgraded.

In this embodiment of the present application, the container group version corresponds to a node type, a class of nodes corresponds to a series of container group versions, and containers corresponding to the series of container group versions are equal to containers corresponding to the class of nodes.

It should be noted that the scale of the version of the container group is positively correlated with the number of times of upgrading the container group, that is, the version of the container group after each upgrading is completed contains more upgrading containers and has a larger corresponding application scale than the version of the container group before upgrading.

S704, verifying the container group versions respectively to determine the version verification result of the container set version after the current container set is upgraded.

Wherein, the container set version is obtained by composing container group versions of various nodes. When verifying the container set version, it is necessary to verify each container set version corresponding to the container set version, and then determine the version verification result of the container set version according to each verification result of each container set version.

It should be noted that, when the container group versions are verified respectively, since the contents of the corresponding containers in each container group are the same, only a single container in each container group needs to be verified. In addition, the verification mode of each container group version can be selected according to the type of the actual application node, and the verification mode is not limited in the application.

In the embodiment of the application, although the scale of the container group version is larger and larger, the container set version containing the container group version is also larger and larger, but the number of the containers verified each time is set according to the preset configuration proportion, so that the verification of the whole target application version is gradually completed by updating the basic application version verified each time according to the container group version successfully upgraded while the workload of each verification is equivalent.

When obtaining the version verification results of the container set versions, the verification results of the container set versions are generally integrated to obtain more accurate verification results. Based on this, the following describes a specific determination procedure of the version verification result of the container set version by an embodiment.

In one embodiment, as shown in fig. 8, verifying the container group versions respectively to determine a version verification result of the container set version of which the upgrade of the current container set is completed includes:

s802, if the versions of the container groups pass the verification, determining that the version of the container set of the current container set passes the verification.

S804, if any container group version verification fails, determining that the container set version verification of the current container set fails.

When the target application is a complex large-scale application, the container set version is also a complex large-scale application version corresponding to the target application, and at the moment, the container group versions forming the container set version are only simple large-scale application versions due to the fact that the contained node types are single. Therefore, when determining the version verification result of the container set version, the verification result of each container group version needs to be combined.

If the verification of each container group version is passed, which indicates that the container corresponding to the current container group version in each node is successfully deployed, the container set version constructed by the multiple container group versions is verified to be passed; if any container group version verification fails, the fact that the container corresponding to the current container group version in a certain type of nodes is deployed on the cloud and cannot work normally is indicated, it is determined that the container set version verification of the current container set fails, and the container group version which cannot work normally is returned to the node before the container group verification.

In the embodiment of the application, the version verification result of the container set version is comprehensively determined to be more reasonable according to the verification result of each container set version. In addition, when the version verification of the container set fails, only the containers of the container group which fails in the verification are returned to the original nodes, and the container group which passes the verification can still update part of the nodes of the target application, so that all the nodes of the target application are prevented from being developed in the subsequent application upgrading process, and the workload of subsequent developers is reduced.

In one embodiment, a deployment method on an application cloud is provided, as shown in fig. 9, the embodiment comprising:

and S901, deploying the new version, updating programs of target application nodes, and upgrading containers of various nodes.

And S902, receiving the deployment request from the S901, setting the configuration upgrading proportion, and deploying the container groups of various types of nodes in batches for the new version.

And S903, upgrading each type of node, namely upgrading the program and the process in the container to obtain a target container group of each node, wherein the application is upgraded from an old version to an old version.

And S904, version verification, namely verifying the container group versions of various nodes respectively to ensure that the progressive deployment corresponding to the container group of each node is successful. For the front-end node and the back-end node, initiating an interface query in an http mode, and if the interface information of the new node can be queried, proving that the container group corresponding to the front-end node and the back-end node is successfully deployed; for the database node and the cache database node, a new node is stored with a data and then inquired, if a return value is inquired, it indicates that the container group corresponding to the database node and the cache database node is successfully deployed.

And S905, verifying the version of the container set after the upgrading of the current container set is completed, judging according to the flow flowing in the S904, if the flow flows in correctly and has no problem, continuing to flow in the next node for judgment, and so on until the flow flows through all the nodes and has no error, passing the verification of the version of the container set, and when all the versions of the container set pass the verification, namely the task upgrading succeeds.

S906, if the container group version verification of any node fails, indicating that the container set version verification of the batch fails, and performing rollback operation on the container group version which fails in verification.

And S907, designating the rollback configuration, namely the proportion of the rolled nodes, wherein the number of the container groups in the nodes of the current type is consistent with the number of the container groups configured in the batch of S902.

In the embodiment of the application, in response to a request for deploying on the cloud of a target application, a plurality of container sets are determined according to containers in each node in the target application, and each container set comprises a container group formed by partial containers in each node; then, in the process of sequentially upgrading the versions of the container sets, verifying the version of the container set after the current container set is upgraded; if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified to pass, and determining that the cloud deployment of the target application is completed. The deployment method on the application cloud in the embodiment of the application is to divide the target application into a plurality of container sets, each container set is equivalent to the upgrading version of the target application, and the version verification is performed on the container sets in sequence, namely the version verification is performed on the versions with different upgrading degrees progressively until the target application is deployed on the cloud. The verification process only aims at partial nodes of the target application each time, and version upgrading or version restoration can be flexibly carried out, so that high availability and service continuity of the target application in the deployment process on the cloud are guaranteed.

It should be understood that, although the steps in the flowcharts related to the above embodiments are shown in sequence as indicated by the arrows, the steps are not necessarily performed in sequence as indicated by the arrows. The steps are not performed in the exact order shown and described, and may be performed in other orders, unless explicitly stated otherwise. Moreover, at least a part of the steps in the flowcharts related to the above embodiments may include multiple steps or multiple stages, which are not necessarily performed at the same time, but may be performed at different times, and the order of performing the steps or stages is not necessarily sequential, but may be performed alternately or alternately with other steps or at least a part of the steps or stages in other steps.

Based on the same inventive concept, the embodiment of the present application further provides an application cloud deployment apparatus for implementing the application cloud deployment method mentioned above. The implementation scheme for solving the problem provided by the apparatus is similar to the implementation scheme described in the above method, so specific limitations in one or more embodiments of the apparatus for deploying on an application cloud provided below may refer to the limitations on the method for deploying on an application cloud in the foregoing, and are not described herein again.

In one embodiment, as shown in fig. 10, there is provided an apparatus 100 for deploying on an application cloud, including a container set determining module 1002, a version verifying module 1004, and an application deploying module 1006, wherein:

the container set determining module 1002 is configured to determine, in response to a request for deployment on the cloud of a target application, a plurality of container sets according to containers in nodes in the target application, where each container set includes a container group formed by some containers in each node.

And the version verification module 1004 is configured to verify the version of the container set after the current container set is upgraded in the process of sequentially upgrading the version of each container set.

The application deployment module 1006 is configured to, if the version verification of the container set fails, perform version upgrade on the current container set again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified to pass, and determining that the cloud deployment of the target application is completed.

In one embodiment, the container set determination module 1002 includes:

a first obtaining unit, configured to obtain a function type of each node;

and the first determining unit is used for dividing the containers in each node according to the function type of each node and determining a plurality of container sets.

In one embodiment, the first determining unit includes:

the first determining subunit is used for determining the upgrading configuration proportion of each node according to the function type of each node;

and the second determining subunit is used for determining a plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportions.

In an embodiment, the second determining subunit is further configured to, according to a combination of multiple preset configuration proportions between nodes, perform a container set creation operation on containers in each node, to obtain multiple container sets; the configuration proportion combination comprises any one configuration proportion in each node; wherein the container set creation operation comprises: for any configuration proportion combination, acquiring a target container group corresponding to each node according to the configuration proportion of each node in the configuration proportion combination; and combining the target container groups to form a container set.

In one embodiment, the second determining subunit is further configured to determine, for any one node, a target container group corresponding to the node according to the configuration proportion of the node and the total number of containers in the node.

In one embodiment, the second determining subunit is further configured to combine the front-end target container group, the back-end target container group, the database target container group, and the cache target container group into a container set.

In one embodiment, the version verification module 1004 includes:

the second acquisition unit is used for acquiring the container group version of each node in the current container set after the container group is upgraded;

and the second determining unit is used for respectively verifying the container group versions so as to determine the version verification result of the container set version which is upgraded and completed by the current container set.

In an embodiment, the second determining unit is further configured to determine that the version of the container set of the current container set passes verification if the versions of the container groups pass verification; and if any container group version verification fails, determining that the container set version verification of the current container set fails.

The modules in the application cloud device can be wholly or partially implemented by software, hardware and a combination thereof. The modules can be embedded in a hardware form or independent of a processor in the computer device, and can also be stored in a memory in the computer device in a software form, so that the processor can call and execute operations corresponding to the modules.

In one embodiment, a computer device is provided, which may be a terminal, and its internal structure diagram may be as shown in fig. 11. The computer apparatus includes a processor, a memory, an input/output interface, a communication interface, a display unit, and an input device. The processor, the memory and the input/output interface are connected through a system bus, and the communication interface, the display unit and the input device are connected to the system bus through the input/output interface. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operating system and the computer program to run on the non-volatile storage medium. The input/output interface of the computer device is used for exchanging information between the processor and an external device. The communication interface of the computer device is used for carrying out wired or wireless communication with an external terminal, and the wireless communication can be realized through WIFI, a mobile cellular network, NFC (near field communication) or other technologies. The computer program is executed by a processor to implement a method of deployment on an application cloud. The display unit of the computer device is used for forming a visual picture and can be a display screen, a projection device or a virtual reality imaging device. The display screen can be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment can be a touch layer covered on the display screen, a key, a track ball or a touch pad arranged on the shell of the computer equipment, an external keyboard, a touch pad or a mouse and the like.

Those skilled in the art will appreciate that the architecture shown in fig. 11 is merely a block diagram of some of the structures associated with the disclosed aspects and is not intended to limit the computing devices to which the disclosed aspects apply, as particular computing devices may include more or less components than those shown, or may combine certain components, or have a different arrangement of components.

In one embodiment, a computer device is provided, comprising a memory and a processor, the memory having a computer program stored therein, the processor implementing the following steps when executing the computer program:

responding to a cloud deployment request of a target application, and determining a plurality of container sets according to containers in each node in the target application, wherein each container set comprises a container group formed by partial containers in each node;

in the process of sequentially upgrading the version of each container set, verifying the version of the container set upgraded at present;

if the version verification of the container set fails, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions after the container set upgrading pass the verification, and determining that the deployment on the cloud of the target application is completed.

In one embodiment, the processor, when executing the computer program, further performs the steps of:

acquiring the function type of each node;

In one embodiment, the processor when executing the computer program further performs the steps of:

and combining the target container groups to form a container set.

and combining the front end target container group, the back end target container group, the database target container group and the cache target container group into a container set.

and respectively verifying the container group versions to determine the version verification result of the container set version which is upgraded at the current container set.

In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored which, when executed by a processor, performs the steps of:

In one embodiment, the computer program when executed by the processor further performs the steps of:

acquiring the function type of each node;

and combining the target container groups to form a container set.

In one embodiment, a computer program product is provided, comprising a computer program which, when executed by a processor, performs the steps of:

acquiring the function type of each node;

and determining a plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportion.

and combining the target container groups to form a container set.

It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by hardware related to instructions of a computer program, which can be stored in a non-volatile computer-readable storage medium, and when executed, the computer program can include the processes of the embodiments of the methods described above. Any reference to memory, database, or other medium used in the embodiments provided herein may include at least one of non-volatile and volatile memory. The nonvolatile Memory may include Read-Only Memory (ROM), magnetic tape, floppy disk, flash Memory, optical Memory, high-density embedded nonvolatile Memory, resistive Random Access Memory (ReRAM), magnetic Random Access Memory (MRAM), ferroelectric Random Access Memory (FRAM), phase Change Memory (PCM), graphene Memory, and the like. Volatile Memory can include Random Access Memory (RAM), external cache Memory, and the like. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM), for example. The databases referred to in various embodiments provided herein may include at least one of relational and non-relational databases. The non-relational database may include, but is not limited to, a block chain based distributed database, and the like. The processors referred to in the various embodiments provided herein may be, without limitation, general purpose processors, central processing units, graphics processors, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, or the like.

The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.

The above examples only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the present application. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present application shall be subject to the appended claims.

Claims

1. A method for deployment on an application cloud, the method comprising:

if the version verification of the container set is not passed, the version of the current container set is upgraded again; and if the container set version passes the verification, performing version upgrading on the next container set until the container set version after the container set upgrading passes the verification, and determining that the cloud deployment of the target application is completed.

2. The method of claim 1, wherein determining a plurality of container sets from containers in nodes within the target application comprises:

acquiring the function type of each node;

and dividing containers in each node according to the function type of each node, and determining the plurality of container sets.

3. The method of claim 2, wherein the partitioning containers within each of the nodes according to the function type of each of the nodes to determine the plurality of container sets comprises:

and determining the plurality of container sets from the containers in the corresponding nodes according to the upgrading configuration proportions.

4. The method of claim 3, wherein the upgraded configuration proportion for each node comprises a plurality of different configuration proportions;

determining the plurality of container sets from the containers in the corresponding nodes according to each upgrade configuration proportion, including:

according to a plurality of configuration proportion combinations among preset nodes, performing container set creation operation on containers in each node to obtain a plurality of container sets; the configuration proportion combination comprises any one configuration proportion in each node; wherein the container set creation operation comprises:

and combining the target container groups to form a container set.

5. The method according to claim 4, wherein the obtaining a target container group corresponding to each node according to the configuration proportion of each node in the configuration proportion combination comprises:

for any node, determining a target container group corresponding to the node according to the configuration proportion of the node and the total number of containers in the node.

6. The method according to claim 4 or 5, wherein each of said nodes comprises a front-end node, a back-end node, a database node and a cache node; the target container group corresponding to each node correspondingly comprises a front-end target container group, a rear-end target container group, a database target container group and a cache target container group;

said combining each of said target container groups to form said plurality of container sets comprises:

and combining the front end target container group, the rear end target container group, the database target container group and the cache target container group into the container set.

7. The method according to any one of claims 1-5, wherein verifying the version of the container set that the upgrade of the current container set is completed comprises:

and respectively verifying the container group versions to determine the version verification result of the container set version upgraded at the current container set.

8. The method of claim 7, wherein the verifying each container group version separately to determine a version verification result of the container set version with the upgraded current container set comprises:

if the versions of the container groups pass the verification, determining that the version of the container set of the current container set passes the verification;

9. An apparatus for deploying on an application cloud, the apparatus comprising:

the system comprises a container set determining module, a container set determining module and a container set selecting module, wherein the container set determining module is used for responding to a cloud deployment request of a target application and determining a plurality of container sets according to containers in nodes in the target application, and each container set comprises a container group formed by part of containers in the nodes;

the version verification module is used for verifying the version of the container set after the upgrading of the current container set in the process of sequentially upgrading the version of each container set;

the application deployment module is used for carrying out version upgrading on the current container set again if the version verification of the container set fails; and if the container set version passes the verification, performing version upgrading on the next container set until the container set versions which are upgraded are verified, and determining that the deployment on the cloud of the target application is completed.

10. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that the processor, when executing the computer program, implements the steps of the method of any of claims 1 to 8.

11. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the steps of the method of any one of claims 1 to 8.

12. A computer program product comprising a computer program, characterized in that the computer program realizes the steps of the method of any one of claims 1 to 8 when executed by a processor.