WO2021238301A1

WO2021238301A1 - Application update method, apparatus and device and medium

Info

Publication number: WO2021238301A1
Application number: PCT/CN2021/075692
Authority: WO
Inventors: 吴浩
Original assignee: 华为技术有限公司
Priority date: 2020-05-27
Filing date: 2021-02-06
Publication date: 2021-12-02
Also published as: CN113741923A

Abstract

An application update method, apparatus and device and a medium. The method comprises: when a cluster comprises at least one first Pod, and a first container for running an old target application is deployed on each first Pod, after an application update request for requesting to update the target application is received, creating a second container for running the updated target application on each first Pod, so as to replace the old target application with the updated target application, thereby achieving the purpose of updating the target application on the cluster. It can be seen that when any application on the cluster is updated, only a new container for running the updated application needs to be created on an original Pod corresponding to the application, thereby effectively simplifying the application updating operation and improving the application updating efficiency.

Description

Application update method, device, equipment and medium

Technical field

This application relates to the field of computer technology, in particular to an application update method, device, equipment and medium.

Background technique

Currently, applications deployed on clusters are usually containerized, so that the applications deployed on the cluster can be decoupled from the cluster's own configuration (such as the configuration of the underlying facilities or file system), so that the application can be deployed in different clusters or Migrate on different operating systems.

In a cluster including multiple nodes, a container deployment unit Pod may be deployed on each node, and a container corresponding to each application may be deployed on each Pod. For example, the cluster includes the first node and the second node, the first pod is deployed on the first node, the second and third pods are deployed on the second node, and the first pod is deployed on the The first container and the second container, the third container and the fourth container are deployed on the second Pod, the fifth container is deployed on the third Pod, and the first to fourth containers are used To run the first application, and the fifth container is used to run the second application.

In some cases, it is necessary to update the applications on the cluster so that the applications on the cluster can better provide business services to users. However, because the application update operation on the cluster is relatively cumbersome, the application update efficiency is low.

Summary of the invention

Based on this, the embodiments of the present application provide an application update method, device, device, and medium, which can simplify application update operations and improve application update efficiency.

In the first aspect, the embodiments of the present application provide an application update method, which is suitable for updating any application on the cluster, and the method specifically includes: when the cluster includes at least one first Pod, and each When the first container for running the old target application is deployed on the first Pod, after receiving the application update request for requesting to update the target application, a first container for running the updated target application is created on each first Pod. The second container, so that the updated target application replaces the old target application, so as to achieve the purpose of updating the target application on the cluster. It can be seen that when updating any application on the cluster, you only need to create a new container for running the updated application on the original Pod corresponding to the application. This can effectively simplify the application update operation and improve Improved application update efficiency.

In some possible implementation manners, after receiving the application update request, the Pod template for specifying the second container is first obtained, and then the second container is created on each first Pod according to the second container specified by the Pod template. Among them, because the Pod template can specify the second container, when creating the second container on each first Pod, it can be created directly according to the second container specified by the Pod template, and there is no need to separately follow the above application parameters on each first Pod. Creating a second container can reduce the time consumption of creating a second container on each first Pod, thereby improving the update efficiency of applications in the cluster.

In some possible implementations, after receiving the application update request, first select the Pod that matches the Pod template from all Pods in the cluster, and determine the selected Pod as the first Pod; and then in each first Pod Create a second container on it. Among them, because each first Pod is pre-screened from all Pods in the cluster based on the Pod template, it is possible to perform other steps of the application update process only on the first selected Pods, without considering the cluster except for the first Pod. Pods other than those will help improve the efficiency of creating target applications.

In some possible implementations, in order to save Pod space, after the second container is created on the first Pod, the first container used to run the old target application on the first Pod is deleted, so that only the first Pod is deployed The latest container with the target application is no longer deployed with the historical container of the target application, which can effectively save Pod space.

In some possible implementation manners, the application update request carries updated application parameters of the target application, and the application parameters include application version information and/or application configuration information.

In some possible implementations, when there are multiple types of application update processes to update applications in the cluster, first receive the application update type of the target application specified by the user through the graphical user interface (GUI), and determine the application update type corresponding to the application In the application update process of the update type, the target application in the cluster is updated according to the determined application update process. In this way, the target application can be updated according to the user's needs, which is beneficial to improve the user experience.

In a second aspect, the present application provides an application update device, which includes: an operation module, a communication module, and an update module. Among them, the running module is used to run the first container of the old target application on the first container deployment unit (Pod); the communication module is used to receive application update requests; the update module is used to create and run the updated post on the first Pod The second container of the target application to replace the old target application.

In some possible implementations, the update module is also used to: obtain a Pod template, and the Pod template specifies the second container.

In some possible implementation manners, the device further includes:

The selection module is used to select a Pod matching the Pod template from multiple Pods, and the selected Pod is the first Pod.

In some possible implementation manners, the update module is also used to: delete the first container on the first Pod.

In some possible implementation manners, the communication module is further used to receive the application update type specified by the user through a graphical user interface (GUI), and the application with the application update type is the target application to be updated.

In a third aspect, the present application provides a computer including a processor and a memory. The processor and the memory are linked. The processor is configured to execute the instructions stored in the memory, so that the computer executes the application update method in the first aspect or any one of the implementation manners of the first aspect.

In a fourth aspect, the present application provides a computer-readable storage medium that includes instructions that instruct a computer to execute the application update described in the first aspect or any one of the implementation manners of the first aspect method.

In a fifth aspect, this application provides a computer program product containing instructions, which when run on a computer, causes the computer to execute the application update method described in the first aspect or any one of the implementations of the first aspect.

On the basis of the implementation manners provided in the above aspects, this application can be further combined to provide more implementation manners.

Description of the drawings

In order to more clearly describe the technical solutions in the embodiments of the present application, the following will briefly introduce the drawings needed in the description of the embodiments. Obviously, the drawings in the following description are only some of the implementations recorded in the present application. For example, for those of ordinary skill in the art, other drawings can be obtained based on these drawings.

Figure 1 is a schematic structural diagram of a k8s cluster provided by an embodiment of the application;

Figure 2 is a schematic diagram of the structure of k8s provided by an embodiment of the application;

FIG. 3 is a system architecture diagram of an application update method provided by an embodiment of the application;

FIG. 4 is a flowchart of an application update method provided by an embodiment of the application;

FIG. 5 is a flowchart of an application update method applied to k8s according to an embodiment of the application;

FIG. 6 is a schematic structural diagram of a computer provided in an embodiment of this application.

Detailed ways

The solutions in the embodiments provided in this application will be described below in conjunction with the drawings in this application.

The terms "first", "second", etc. in the description and claims of the application and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific sequence or sequence. It should be understood that the terms used in this way can be interchanged under appropriate circumstances, and this is only used to describe the method of distinguishing objects with the same attribute in the description of the embodiments of the present application.

In order to facilitate the understanding of the technical solutions of this application, some technical terms involved in this application are introduced below.

Kubernetes (k8s for short) is Google's open source container orchestration and scheduling engine, which is used to manage containerized applications on each node in the cluster. k8s includes a management (master) component and a node (node) component. Among them, the master component can run on any node in the cluster, and the master component is used to control and manage the cluster. The node component can run on any node in the cluster, and the node component is used to provide a k8s operating environment for the node and to maintain the container deployment unit (that is, Pod) on the node. For example, as shown in Figure 1, when the cluster includes a management node and N application nodes, the master component can run on the management node, so that the management node deployed with the master component can manage and control the cluster; and each application node The node component can be run on any application node, so that the node component running on each application node is used to maintain the Pod on that node.

The master component includes an interface server (that is, kube-apiserver), a management controller (that is, kube-controller-manager), and a storage system (such as etcd). Among them, etcd is used to save all cluster data. kube-apiserver is the only entry point for resource operations, so that the user and any component in k8s can operate on related resources through kube-apiserver communication (as shown in Figure 2). The kube-controller-manager is used to maintain the application state of each application in the cluster, and the kube-controller-manager is a collection of many controllers in the master component, which includes a stateless application controller (that is, Deployment Controller) and a copy Collective controller (that is, Replicaset Controller). The Deployment Controller is used to maintain the deployment resource status; the Replicaset Controller is used to maintain the Replicaset resource status, and the Replicaset Controller can create a Pod replica corresponding to the Pod template on at least one node according to the Pod template.

It should be noted that in k8s, Deployment is used to provide declarative updates for Pod and ReplicaSet, that is, users only need to describe the target state of Pod and/or Replicaset in Deployment, and Deployment Controller will control the actual status of Pod and Replicaset. The state changes to the above-mentioned target state. Replcaset refers to a collection of Pod copies.

The node component includes a proxy component (that is, kubelet) and a running component (that is, docker). Among them, kubelet is used to maintain the Pod in the node and the container on the Pod. Docker is used to run containers on Pod.

Pod is the smallest unit used for creation, scheduling and management in k8s. In addition, at least one container can be deployed on each Pod; moreover, containers deployed on the same Pod usually correspond to the same application, that is, all containers deployed on a Pod are used to run the same application. For example, if both container 1 and container 2 are deployed on Pod 1, then container 1 and container 2 are usually used to run the same application.

In addition, in order to facilitate the understanding of the technical solution of the present application, the following introduces related technologies for updating applications in the cluster.

In related technologies, the method of deleting and rebuilding Pod (for example, the Recreate Update method or the Rolling Update method in k8s) can be used to update the applications in the cluster, which is specifically: when the target application needs to be updated, it can be created in the cluster node first A new Pod, and a container for running the updated target application is deployed on the new Pod, and then the old Pod deployed in the cluster node is deleted, and a container for running the old target application is deployed on the old Pod. For example, suppose that the container used to run the old target application is deployed on Pod1, Pod2, and Pod3, and the container used to run the updated target application is deployed on Pod4, Pod5, and Pod6. Based on this assumption, when the target application needs to be updated, Pod4, Pod5, and Pod6 can be created in the cluster, and Pod1, Pod2, and Pod3 can be deleted from the cluster to enable the updated target application to run in the cluster.

It should be noted that the embodiment of this application does not limit the execution order of multiple Pod creation and multiple Pod deletion. You can create all new Pods and then delete all old Pods, such as the Recreate Update method in k8s; you can also create the first Pod first. Batch new Pods and delete the first batch of old Pods, then create the second batch of new Pods and delete the second batch of old Pods,... (until the creation of all new Pods and the deletion of all old Pods are completed), such as Rolling in k8s Update method.

Based on the application update process provided by the above-mentioned related technologies, it can be seen that the application update process described above is implemented by the delete and re-rebuild process of the Pod, so that the Pod corresponding to the application before the update is different from the Pod corresponding to the application after the update, so that the application before the update corresponds to the Pod Basic information (such as Pod name, Pod name identification, Pod IP address, node information of the node where Pod is located, etc.) is different from the basic information of the Pod corresponding to the updated application, resulting in applications in the cluster (especially those that have a strong dependence on Pod basic information Sexual applications) are prone to abnormalities (such as abnormal applications such as failure to operate normally) due to changes in the basic information of the Pod.

In order to solve the shortcomings of the above-mentioned related technologies, an embodiment of the present application provides an application update method, which specifically includes: when the cluster includes at least one first Pod, and each first Pod is deployed for running old When the first container of the target application is received, after receiving the application update request for requesting to update the target application, a second container for running the updated target application is created on each first Pod, so that the updated target The application replaces the old target application, thus achieving the purpose of updating the target application on the cluster. Among them, because the application update process is realized by rebuilding the container corresponding to the updated application on the original Pod, the container corresponding to the old target application and the container corresponding to the updated target application are both located on the same Pod, thus The basic information of the Pod corresponding to the target application remains unchanged during the application update process, which can prevent applications on the cluster (especially those applications that have a strong dependence on the basic information of the Pod) from being prone to changes in the basic information of the Pod. abnormal.

In order to facilitate the understanding of the technical solution of the present application, the application scenario of the application update method provided in the embodiment of the present application will be exemplarily introduced below in conjunction with FIG. 3. Among them, FIG. 3 is a system architecture diagram of an application update method provided by an embodiment of the application.

The application scenario shown in FIG. 3 includes an application update device 301, a graphical user interface (GUI) 302, and a user 303. Wherein, the application update device 301 is deployed in the cluster, and the application update device 301 updates the applications in the cluster by executing the application update method provided in the embodiments of the present application. The GUI 302 is used to receive the data information input by the user 303 and the triggered instruction request.

In the application scenario shown in Figure 3, when the user 303 wants to update the target application, the user 303 can trigger an application update request on the GUI302 for requesting to update the target application, so that the GUI302 sends the application update request to the application update The device 301 enables the application update device 301 to create a second container for running the updated target application on the first Pod, so that the purpose of replacing the old target application with the updated target application in the cluster can be achieved. Among them, the first Pod refers to the Pod deployed with the first container for running the old target application.

In addition, the application update device 301 includes an operation module 3011, an update module 3012, and a communication module 3013. The running module 3011 is used to run the container on the cluster nodes. For example, the running module 3011 is used to run the first container of the old target application on the first Pod. The communication module 3013 is used to receive information (such as data information, instruction requests, etc.) sent by the user 303 through the GUI 302. For example, the communication module 3013 is used to receive application update requests. The update module 3012 is used to update applications in the cluster. For example, the update module 3012 can be used to create a second container for running the updated target application on the first Pod to replace the old target application.

In addition, the embodiment of the present application does not limit the GUI 302. In a possible implementation manner, the GUI 302 is a terminal device. For example, the GUI 302 may be a terminal device such as a smart phone, a computer, a personal digital assistant (Personal Digital Assistant, PDA), or a tablet computer.

In order to make the technical solutions of the embodiments of the present application clearer and easier to understand, the application update method provided by the embodiments of the present application will be specifically introduced below in conjunction with the interaction process in the application scenario shown in FIG. 3. Among them, FIG. 4 is a flowchart of an application update method provided by an embodiment of the application. As shown in FIG. 4, the application update method provided by an embodiment of the application includes S401-S403:

S401: The application updating apparatus 301 runs the first container of the old target application on the first Pod.

The first container refers to the container used to run the old target application (that is, the target application before the update) in the cluster.

The first Pod refers to the Pod in which the first container is deployed in the cluster, and this embodiment of the present application does not limit the number of first Pods, nor does it limit the number of first containers deployed on each first Pod.

Based on the above content, in this embodiment of the application, when the user 303 triggers an application running request through the GUI302, and the application running request is used to request to run an old target application, the GUI302 sends the application running request to the application update device 301 to The application update apparatus 301 is made to run the first container of the old target application on the first Pod in the cluster. As an example, suppose the cluster includes node 1, node 2, and node 3. Pod1, Pod2, and Pod3 are deployed on node 1, Pod3 and Pod4 are deployed on node 2, Pod5 is deployed on node 3, and Pod1, Pod2, and Pod5 are all deployed There is the first container. Based on this assumption, it can be known that since the first container is deployed on Pod1, Pod2, and Pod5, Pod1, Pod2, and Pod5 are all the first Pod. Therefore, after the application update device 301 receives the above application running request, the application update device 301 You can run the first container on Pod1, Pod2, or Pod5 to run the old target application in the cluster.

S402: The application update device 301 receives an application update request.

The application update request is used to request to update the target application, and the application update request is triggered by the user 303 through the GUI302.

In addition, the embodiment of this application does not limit the information carried in the application update request. The following describes with two examples.

Example 1: The application update request carries updated application parameters of the target application, and the application parameters include application version information and/or application configuration information.

Specifically, when the application update request is used to request to update the current version of the target application to the target version, the application update request carries the application version information of the target version (that is, the updated version information of the target application); When the application update request is used to request to update the current application configuration information of the target application to the target application configuration information, the application update request carries the target application configuration information (that is, the updated application configuration information of the target application); When the application update request is used to request that the current version of the target application be updated to the target version, and the current application configuration information of the target application is updated to the target application configuration information, the application update request carries the target application configuration information and the target version App version information for.

Example 2: When the application update apparatus 301 can use multiple types of application update processes to update applications in the cluster, the application update request can carry the application update type and the updated application parameters of the target application. The application update type is specified by the user 303 through the GUI 302, and the application update device 301 can determine the application update process used when updating the target application according to the application update type. In this way, the application update device 301 can not only extract the updated application parameters of the target application from the application update request, but also extract the selection information of the application update process used to update the target application from the application update request.

Based on the foregoing content, in this embodiment of the application, when the user 303 triggers an application update request through the GUI302, and the application update request is used to request to update the target application, the GUI302 sends the application update request to the application update device 301, so that the The application update device 301 can update the target application in the cluster based on the information carried in the application update request.

S403: The application updating device 301 creates a second container for running the updated target application on the first Pod to replace the old target application.

The second container refers to the container used to run the updated target application in the cluster.

In the embodiment of the present application, after the application update device 301 obtains the application update request, the application update device 301 uses the application parameters carried in the application update request to create a second container on each first Pod, so that Use the updated target application to replace the old target application. As an example, when the cluster includes Pod1, Pod2, and Pod5, and the first container is deployed on Pod1, Pod2, and Pod5, Pod1, Pod2, and Pod5 are all the first Pod, and S403 is specifically: the application update device 301 is on Create a second container on Pod1, create a second container on Pod2, and create a second container on Pod5, so that the subsequent application update device 301 can run the second container on Pod1, the second container on Pod2, or the second container on Pod5. The second container approach realizes the purpose of running the updated target application in the cluster.

Based on the above related content of S401 to S403, it can be known that in the application update method provided in the embodiment of the present application, when the cluster includes at least one first Pod, and each first Pod is deployed with a first Pod for running the old target application In the case of a container, after receiving an application update request for requesting to update the target application, create a second container for running the updated target application on each first Pod, so that the updated target application replaces the old target Application, so as to achieve the purpose of updating the target application on the cluster. It can be seen that when updating any application on the cluster, you only need to create a new container for running the updated application on the original Pod corresponding to the application. This can effectively simplify the application update operation and improve Improved application update efficiency. In addition, because the application update process is implemented by rebuilding the container corresponding to the updated application on the original Pod, the old target application and the updated target application are both located on the same Pod, so that the Pod corresponding to the target application The basic information always remains the same during the application update process, which can prevent the applications on the cluster (especially those applications that have a strong dependence on the basic information of the Pod) from being abnormal due to the changes of the basic information of the Pod.

In some cases (for example, the application update device 301 is k8s), the second container on the first Pod can be created with reference to the second container on the Pod template. Based on this, the embodiment of the present application also provides a possible implementation manner of the application update method. In this implementation manner, the application update method includes S401-S403 as well as S404:

S404: The application updating device 301 obtains a Pod template, the Pod template designating the aforementioned second container.

Pod templates refer to objects that need to be referenced when creating a Pod on a node and creating a container on the Pod. For example, in k8s, a copy of the Pod template can be deployed on the node as a Pod on the node; you can also create a corresponding container on the Pod based on the container deployed on the Pod template, so that the container deployed on the Pod is the same as the Pod. The containers deployed on the template are consistent.

In addition, the Pod template can be created according to the updated application parameters of the target application, so that the second container is deployed on the Pod template, so that the Pod template can specify the second container.

Based on the above content, in this embodiment of the application, after the application update device 301 receives the application update request, the application update device 301 first creates a Pod template according to the updated application parameters of the target application carried in the application update request, so that the Pod A second container is deployed on the template; then follow the second container deployed on the Pod template to create a second container on each first Pod, so that the second container on each first Pod is the same as the second container on the Pod template , So the creation of the second container is realized. Among them, because the Pod template can specify the second container, when creating the second container on each first Pod, it can be created directly according to the second container specified by the Pod template, and there is no need to separately follow the above application parameters on each first Pod. Creating a second container can reduce the time consumption of creating a second container on each first Pod, thereby improving the update efficiency of applications in the cluster.

In addition, in order to improve the update efficiency of the target application, each first Pod can be filtered from all the Pods in the cluster based on the result of matching each Pod in the cluster with the aforementioned Pod template. Based on this, the embodiment of the present application also provides a possible implementation manner of the application update method. In this implementation manner, the application update method includes S401-S404 as well as S405:

S405: The application update device 301 selects a Pod matching the above-mentioned Pod template from a plurality of Pods, and the selected Pod is the first Pod.

The Pod that matches the above Pod template satisfies the condition that: the difference between the application corresponding to the container deployed on the Pod and the application corresponding to the container deployed on the Pod template is only in the application parameters. For example, when the application update device 301 is k8s, the Pod that matches the above Pod template satisfies the conditions: the Pod is deployed with a container corresponding to the target application, and the container corresponding to the target application deployed on the Pod is different from that deployed on the Pod template The target application corresponds to the container.

It should be noted that step S405 may be executed after S404 is executed and before S403 is executed.

Based on the above content, in this embodiment of the application, after obtaining the Pod template for specifying the second container, the application update device 301 first matches each Pod in the cluster with the Pod template, and matches each pod template that has been successfully matched with the Pod template. The Pods are all determined to be the first Pod, and then a second container is created on each of the determined first Pods. Among them, because each first Pod is pre-screened from all Pods in the cluster based on the Pod template, it is possible to perform other steps of the application update process only on the first selected Pods, without considering the cluster except for the first Pod. Pods other than those will help improve the efficiency of creating target applications.

In some cases, a corresponding relationship may be established between the application identifier of the containerized application deployed on the Pod and the Pod in advance, so that the Pod on which the containerized application is deployed can be found subsequently based on the application identifier. Based on this, the embodiment of the present application can also filter out each first Pod from all Pods in the cluster based on the application identifier of the target application. Therefore, the embodiment of the present application also provides a possible implementation of the application update method. In this implementation manner, the application update method includes not only some or all of the above steps, but also includes S406:

S406: The application updating device 301 determines the Pod corresponding to the target application identifier among the multiple Pods as the first Pod.

The target application identifier is used to uniquely identify the target application. In addition, the embodiment of the present application does not limit the method of obtaining the target application identifier. For example, when the application update request carries related information about the target application identifier, the application update device 301 may obtain the target application identifier according to the application update request.

Based on the above content, in this embodiment of the application, after the application update device 301 obtains the application update request, the application update device 301 first determines the target application identifier according to the application update request, and then filters out all Pods in the cluster that correspond to the target application Each identified Pod is used as the first Pod, so that the subsequent application update device 301 can directly create a second container on each of the determined first Pods, which is beneficial to improve the efficiency of creating the second container.

In addition, in order to save Pod space, the first container used to run the old target application on the first Pod may be deleted, so that the container corresponding to the old target application is no longer deployed on the first Pod. Based on this, the embodiment of the present application also provides a possible implementation manner of the application update method. In this implementation manner, the application update method includes not only some or all of the above steps, but also includes S407:

S407: The application updating apparatus 301 deletes the first container on the first Pod.

In this embodiment of the application, after the application update apparatus 301 receives the application update request, the application update apparatus 301 may create a second container on each first Pod and delete the first container, so that only the target is deployed on each first Pod The latest container of the application is no longer deployed with the historical container of the target application, which can effectively save Pod space.

It should be noted that the implementation of this application does not limit the execution order of deleting the first container and creating the second container on the first Pod. For example, on any first Pod, you can delete the first container and then create the second container. You can create the second container first and then delete the first container.

In addition, the embodiment of the present application does not limit the execution time for the application update apparatus 301 to delete the first container on each first Pod, and the following describes with two examples.

Example 1: The application update apparatus 301 may delete the first container on all the first Pods, and then create the second container on each first Pod. For example, when the first container is deployed on Pod1, Pod2, Pod5, and Pod6, the application update device 301 can delete the first container on Pod1, delete the first container on Pod2, delete the first container on Pod5, and delete the first container on Pod5. After deleting the first container on Pod6, create a second container on Pod1, create a second container on Pod2, create a second container on Pod5, and create a second container on Pod6.

Example 2: The application update device 301 can create the second container on the first Pod and delete the first container in a mode in which the number of Pods in the container update state remains unchanged. For example, when the first container is deployed on Pod1, Pod2, Pod5, and Pod6, and the number of Pods in the container update state in the application update device 301 is 2, the application update device 301 performs container update on Pod1 and Pod2 ( That is, delete the first container and create a second container); when Pod1 and Pod2 complete the container update at the same time, the application update device 301 starts to update the container on Pod5 and Pod6 respectively; when Pod1 and Pod2 do not complete the container update at the same time (for example , Pod1 completes the container update but Pod2 does not complete the container update, or Pod2 completes the container update but Pod1 does not complete the container update), the application update device 301 starts to update the container on Pod5, so that the application update device 301 always maintains the second position A Pod is in a container update state. In this way, it can be ensured that the two first Pods are always kept in the container update state in the application update device 301.

In addition, in the second example, the number of Pods in the container update state can be designated by the user 303 through the GUI 302, and can be preset in the application update device 301.

In some cases, the application update device 301 can use multiple types of application update processes to update applications in the cluster, so the application update device 301 can determine the application update process according to the application update type specified by the user 303 through the GUI302. Based on this, the embodiment of the present application also provides a possible implementation manner of the application update method. In this implementation manner, the application update method includes not only some or all of the above steps, but also includes S408:

S408: The application update apparatus 301 receives the application update type specified by the user 303 through the GUI 302, and the application with the application update type is the target application to be updated.

In the embodiment of the present application, when the application update apparatus 301 receives the application update type of the target application specified by the user 303 through the GUI 302, the application update apparatus 301 first determines the application update process corresponding to the application update type according to the application update type. This allows the subsequent application update device 301 to update the target application in the cluster according to the determined application update process. For example, when the application update process determined by the application update apparatus 301 according to the application update type includes the steps in any implementation manner of the application update method provided in the embodiment of the present application, the application update apparatus 301 follows the application update provided in the embodiment of the present application. Any implementation of the method updates the target application.

In some cases, the user 303 does not directly specify the application update type through the GUI302, but enters the description information of the application update process through the GUI302 (for example, the basic information of the Pod cannot be changed during the application update process). At this time, the application update device 301 can be based on The description information determines the type of application update. Based on this, the embodiment of the present application also provides a possible implementation manner of the application update method. In this implementation manner, the application update method includes S409-S412 in addition to some or all of the above steps:

S409: The application update apparatus 301 receives the target process information input by the user 303 through the GUI302.

The target process information is the description information of the application update process of the target application. In addition, the embodiment of the present application does not limit the target process information. As an example, the target process information includes constraint conditions of the application update process, and/or description information of part or all of the steps in the application update process. Among them, the constraint condition of the application update process is used to describe the constraint condition that the application update process should meet. For example, the constraint condition of the application update process may be that the basic information of the Pod cannot be changed during the application update process.

S410: The application update device 301 determines the application update type according to the target process information.

The embodiment of the application does not limit the specific implementation manner for the application update apparatus 301 to determine the application update type. For example, S410 may specifically be: the application update apparatus 301 first obtains the preset description information corresponding to each application update type, and then compares the target process information with the target process information. The preset description information corresponding to each application update type is matched, and the application update type corresponding to the preset description information with the highest matching degree is determined.

The preset description information is preset and stored in a preset storage location, and the application update device 301 can obtain the preset description information from the preset storage location.

In this embodiment of the application, after the application update device 301 receives the target process information, it first obtains the preset description information corresponding to each application update type from the preset storage location, and compares the preset description information corresponding to each application update type with the target The process information is matched separately to obtain the matching degree corresponding to each application update type; then the matching degree corresponding to each application update type is compared, and the application update type corresponding to the highest matching degree is determined as the final application update type.

S411: The application update device 301 displays the application update type through the GUI 302, so that the user 303 determines whether to select the application update type.

S412: The application update apparatus 301 receives the selection result input by the user 303 through the GUI302.

Based on the above content, in this embodiment of the application, when the user 303 enters the target process information on the GUI302, the GUI302 sends the target process information to the application update device 301, so that the application update device 301 first determines the application update according to the target process information Type, and then feedback the application update type to GUI302, so that GUI302 displays the application update type to user 303, and user 303 confirms whether to select the displayed application update type through GUI302, so that GUI302 will feed back user 303’s selection result to The application update device 301, so that the application update device 301 determines whether the determined application update type is the application update type specified by the user for the target application based on the selection result, and if so, directly uses the application update corresponding to the determined application update type The process updates the target application; if not, ends the current application update process or recommends another application update type to the user 303 again. It can be seen that because the application update device 301 can automatically determine the application update type according to the target process information provided by the user 303, there is no need for the user 303 to directly specify the application update type, which reduces the technical threshold for the user to use the application update device 301 and is beneficial to improve user experience.

In order to facilitate the understanding of the foregoing technical solution, the application update method provided by the embodiment of the present application will be described below in conjunction with FIG. 2 and FIG. 5 and taking the application update device as k8s as an example. Wherein, FIG. 5 is a flowchart of an application update method applied to k8s according to an embodiment of the application. As shown in Figure 5, the application update method applied to k8s provided by the embodiment of the present application includes S501-S505:

S501: The kube-apiserver receives an application update request triggered by the user through the GUI, the application update request is used to request to update the target application, and the application update request carries the updated application parameters of the target application and the application update of the target application specified by the user type.

There is a one-to-one correspondence between application update types and application update processes, and the corresponding relationship is specifically: k8s application update types include Recreate Update type, Rolling Update type, and Inplace Rolling Update type, and the Recreate Update type corresponds to the above Recreate Update method, Rolling The Update type corresponds to the above Rolling Update method, and the Inplace Rolling Update type corresponds to the application update method provided in the embodiment of the present application.

In the embodiment of this application, after the kube-apiserver in k8s receives the application update request through the GUI, the kube-apiserver can directly carry the application update request with the updated application parameters of the target application and the application of the target application specified by the user The update type is stored in etcd so that other components in subsequent k8s (such as Deployment Controller) can use the above information stored in etcd.

S502: The Deployment Controller judges whether the application parameters of the target application stored in etcd are updated, if yes, execute S503; if not, end.

The Deployment Controller is used to monitor whether the data information stored in etcd (such as the application parameters of the target application) changes in real time through the kube-apiserver.

In the embodiment of this application, after the kube-apiserver in k8s stores the updated application parameters of the target application carried in the application update request in etcd, the Deployment Controller can monitor that the application parameters corresponding to the target application are updated through the kube-apiserver. Therefore, the Deployment Controller needs to perform S503 and subsequent steps in order to complete the update process of the target application.

S503: When the Deployment Controller determines that the application update type of the target application stored in etcd is the InplaceRolling Update type, the Deployment Controller updates the Pod template of the target application according to the updated application parameters of the target application.

In the embodiment of this application, after the Deployment Controller determines that the application parameters of the target application stored in etcd are updated, the Deployment Controller first determines the application update process of the target application according to the application update type of the target application stored in etcd, which is specifically: When the Deployment Controller determines that the application update type of the target application is the Recreate Update type, it uses the Recreate Update method described above to update the target application; when the Deployment Controller determines that the application update type of the target application is the Rolling Update type, it uses the above The introduced Rolling Update method updates the target application; when the Deployment Controller determines that the application update type of the target application is the InplaceRolling Update type, S503 to S505 are used to update the target application.

In addition, the embodiment of the present application does not limit the update process of the Pod template of the target application. For example, the update process of the Pod template of the target application may specifically be: Deployment Controller creates a new Pod template of the target application according to the updated application parameters of the target application The Deployment Controller stores the new Pod template of the target application in etcd, and sets the new template as the Pod template of the target application, so that the kubelet on the node where the first Pod is deployed can update the first Pod based on the Pod template.

S504: The Deployment Controller determines each first Pod according to the application identifier of the target application.

In k8s, the application identifier of the target application may be the first label; moreover, the first container is deployed on all Pods with the first label. In addition, the embodiment of the present application does not limit the method for determining the application identifier of the target application. For example, it may be determined based on the relevant information of the target application carried in the application update request.

In addition, in k8s, the embodiment of the present application does not limit the determination method of each first Pod. For example, each Pod replica in the Replicaset whose selector field is the application identifier of the target application can be determined as the first Pod.

It should be noted that in order to ensure that during the container update process, the Replicaset corresponding to the target application can always include all Pods corresponding to the target application, the selector field of the Replicaset corresponding to the target application can be modified to the application ID of the old target application and after the update After confirming that all Pods corresponding to the target application are deployed with the second container, modify the selector field of the Replicaset corresponding to the target application to the updated application identifier of the target application, so that the Deployment Controller can Always use the selector field of the Replicaset corresponding to the target application to query all Pods corresponding to the target application.

S505: When the kubelet corresponding to each first Pod determines that the first Pod needs to be updated, it creates a second container on the first Pod and deletes the first container.

The embodiment of this application does not limit the specific implementation manner in which the kubelet determines that the first Pod needs to be updated. For example, for each kubelet corresponding to the first Pod, the kubelet performs the Pod template of the first Pod and the target application stored in etcd. By comparison, when it is determined that the container corresponding to the target application deployed on the first Pod is different from the container corresponding to the target application deployed on the above Pod template, it is determined that the first Pod needs to be updated, and the first Pod is created on the first Pod. Second container and delete the first container, so that the first Pod can run the updated target application in the second container. In order to facilitate the understanding of S505, the following description is combined with an example.

As an example, suppose the cluster includes node 1, node 2, and node 3; Pod1, Pod2, and Pod3 are deployed on node 1, Pod3 and Pod4 are deployed on node 2, Pod5 is deployed on node 3, and Pod1, Pod2, and Pod5 are all deployed There is a first container; kubelet1 is deployed on node 1, kubelet2 is deployed on node 2, and kubelet3 is deployed on node 3.

Based on the above assumptions, when the Pod template of the target application stored in etcd is updated, kubelet1 compares the Pod1 deployed on node 1 with the Pod template of the target application stored in etcd, and determines the first container on Pod1 When it is different from the second container on the Pod template, it is determined that Pod1 needs to be updated. At this time, the kubelet1 creates a second container on Pod1 according to the Pod template and deletes the first container, so that the target application deployed on Pod1 corresponds to the container and Pod The target application deployed on the template corresponds to the same container. Similarly, kubelet1 compares the Pod2 deployed on node 1 with the Pod template of the target application stored in etcd, and when it determines that the first container on Pod2 is different from the second container on the Pod template, it determines that Pod2 needs to be updated. At this time, the kubelet1 creates a second container on Pod2 according to the Pod template and deletes the first container, so that the container corresponding to the target application deployed on Pod2 is the same as the container corresponding to the target application deployed on the Pod template. Similarly, kubelet3 compares the Pod5 deployed on node 3 with the Pod template of the target application stored in etcd, and when it determines that the first container on Pod5 is different from the second container on the Pod template, it determines that Pod5 needs to be updated. At this time, the kubelet3 creates a second container on Pod5 according to the Pod template and deletes the first container, so that the container corresponding to the target application deployed on Pod5 is the same as the container corresponding to the target application deployed on the Pod template. In this way, the target application in the cluster is updated.

In addition, in order to avoid insufficient Pod space resources in k8s, you can delete the first container on the first Pod and then create the second container, so that the Pod space released by deleting the first container can be used during the creation of the second container. Resources, so effectively avoid the occurrence of insufficient Pod space resources.

In addition, in k8s, all containers on the first Pod can be updated according to the mode that the number of Pods in the container update state remains unchanged, and the number of Pods in the container update state can be determined according to the MaxUnavailable field, for example, set MaxUnavailable The value of the field is determined as the number of Pods in the container update state. Among them, the value of the MaxUnavailable field can be preset or specified by the user through the GUI.

In addition, the docker on each node is used to run the containers deployed on the Pod. For example, when Pod1 and docker1 are deployed on node 1, and the first container is deployed on Pod1, docker1 runs the first container on Pod1 so that the old target application can run in the cluster.

Based on the above related content of S501 to S505, it can be seen that in k8s, the container corresponding to the old target application can be directly deleted on the original Pod and the container corresponding to the updated target application can be created, so that the Pod corresponding to the target application is in the target application’s The update process is always the same, so that the basic Pod information corresponding to the target application always remains the same, which can effectively avoid abnormalities caused by changes in the basic information of the Pod due to changes in the basic information of the applications on the cluster.

The application update method provided by the embodiment of the present application is described in detail above with reference to FIGS. 1 to 5, and the application update apparatus provided by the embodiment of the present application and the corresponding equipment are introduced below with reference to the accompanying drawings.

As shown in FIG. 3, the application update apparatus 301 provided by the embodiment of the present application includes:

The running module 3011 is used to run the first container of the old target application on the first container deployment unit (Pod);

The communication module 3013 is used to receive application update requests;

The update module 3012 is used to create a second container for running the updated target application on the first Pod to replace the old target application.

For the specific implementation of the running module 3011, refer to the description of related content in S401 in the embodiment shown in FIG. 4. For the specific implementation of the communication module 3013, refer to the description of related content in S402 in the embodiment shown in FIG. 4. For the specific implementation of the update module 3012, refer to the description of S403 in the embodiment shown in FIG. 4.

In some possible implementations, the update module 3012 is also used to:

Obtain the Pod template, and the Pod template specifies the second container.

In some possible implementation manners, the application update apparatus 301 further includes:

In some possible implementations, the update module 3012 is also used to:

Delete the first container on the first Pod.

In some possible implementations, the communication module 3013 is also used to:

The application update type specified by the user is received through a graphical user interface (GUI), and the application with the application update type is the target application to be updated.

The application update apparatus 301 of the embodiment of the present application may correspond to the implementation of the application update method described in the embodiment of the present application, and the above and other operations and/or functions of the modules/units of the application update apparatus 301 are respectively intended to implement FIG. 4 and FIG. For the sake of brevity, the corresponding procedures of the methods in the embodiment shown in 5 will not be repeated here.

The embodiment of the present application also provides a computer. The computer may be a server or a cloud server, and is specifically used to implement the functions of the application update apparatus 301 in the embodiment shown in FIG. 3.

FIG. 6 provides a schematic structural diagram of a computer. As shown in FIG. 6, the computer 600 includes a bus 601, a processor 602, a communication interface 603 and a memory 604. The processor 602, the memory 604, and the communication interface 603 communicate through a bus 601. The bus 601 may be a peripheral component interconnect standard (PCI) bus or an extended industry standard architecture (EISA) bus, etc. The bus can be divided into address bus, data bus, control bus and so on. For ease of representation, only one thick line is used in FIG. 6, but it does not mean that there is only one bus or one type of bus. The communication interface 603 is used to communicate with the outside. For example, receiving a first query request based on the graph traversal language, receiving a second query request based on the graph traversal language, and so on.

The processor 602 may be a central processing unit (CPU). The memory 604 may include a volatile memory (volatile memory), such as a random access memory (random access memory, RAM). The memory 604 may also include a non-volatile memory (non-volatile memory), such as a read-only memory (ROM), flash memory, HDD or SSD.

The memory 604 stores executable code, and the processor 602 executes the executable code to execute the aforementioned application update method.

Specifically, in the case where the embodiment shown in FIG. 3 is implemented, and the modules of the application update apparatus 301 described in the embodiment in FIG. 3 are implemented by software, the running module 3011 and the update module in FIG. 3 are executed. The software or program code required for the function of 3012 is stored in the memory 604. The function of the communication module 3013 is implemented through the communication interface 603. The communication interface 603 receives the application update request and transmits it to the processor 602 via the bus 601. The processor 602 executes the program code corresponding to each module stored in the memory 604, such as the program code corresponding to the running module 3011 and the update module 3012, so as to realize The first container of the old target application is run on the first container deployment unit (Pod), and the second container for running the updated target application is created on the first Pod to replace the old target application. Of course, the processor 602 can also execute the program code corresponding to the selection module, select a Pod matching the Pod template from a plurality of Pods, and the selected Pod is the first Pod. In this way, the application update device 301 can perform an update on the first Pod. The container corresponding to the target application is updated.

An embodiment of the present application also provides a computer-readable storage medium, which includes instructions that instruct a computer to execute the above-mentioned application update method applied to the application update apparatus 301.

The embodiment of the present application also provides a computer program product. When the computer program product is executed by a computer, the computer executes any one of the aforementioned application update methods. The computer program product may be a software installation package. In the case where any method of the aforementioned application update method needs to be used, the computer program product can be downloaded and executed on the computer.

Claims

An application update method, characterized in that the method includes:

Run the first container of the old target application on the first container deployment unit (Pod);

Receive application update request;

A second container for running the updated target application is created on the first Pod to replace the old target application.
The method according to claim 1, wherein the method further comprises:

Obtain a Pod template, where the Pod template specifies the second container.
The method according to claim 2, wherein the method further comprises:

A Pod matching the Pod template is selected from a plurality of Pods, and the selected Pod is the first Pod.
The method according to any one of claims 1-3, wherein the method further comprises:

Delete the first container on the first Pod.
The method according to any one of claims 1 to 4, wherein the application update request carries updated application parameters of the target application, and the application parameters include application version information and/or application configuration information.
The method according to any one of claims 1-5, wherein the method further comprises:

The application update type specified by the user is received through a graphical user interface (GUI), and the application with the application update type is the target application to be updated.
An application update device, characterized in that the device includes:

The running module is used to run the first container of the old target application on the first container deployment unit (Pod);

The communication module is used to receive application update requests;

The update module is used to create a second container for running the updated target application on the first Pod to replace the old target application.
The device according to claim 7, wherein the update module is further used for:

Obtain a Pod template, where the Pod template specifies the second container.
The device according to claim 8, wherein the device further comprises:

The selection module is configured to select a Pod matching the Pod template from a plurality of Pods, and the selected Pod is the first Pod.
The device according to any one of claims 7-9, wherein the update module is further configured to:

Delete the first container on the first Pod.
The device according to any one of claims 7-10, wherein the application update request carries updated application parameters of the target application, and the application parameters include application version information and/or application configuration information.
The device according to any one of claims 7-11, wherein the communication module is further configured to:

The application update type specified by the user is received through a graphical user interface (GUI), and the application with the application update type is the target application to be updated.
A computer, characterized in that the computer includes a processor and a memory;

The processor is configured to execute instructions stored in the memory, so that the computer executes the application update method according to any one of claims 1 to 6.
A computer-readable storage medium, wherein the computer-readable storage medium includes instructions that instruct a computer to execute the application update method according to any one of claims 1 to 6.