CN109032760A - Method and apparatus for application deployment - Google Patents

Abstract

The embodiment of the present application discloses the method and apparatus for application deployment.One specific embodiment of this method includes: to receive application deployment requests that user's institute's using terminal is sent, for application deployment, wherein application deployment request packet includes configuration parameter and mirror image, wherein configuration parameter includes access type；Determined whether to provide load balancing service for application according to access type；Load balancing service is provided for application in response to determining, creates load balancing example, and creates elastic public network IP address, wherein load balancing example is added with the back-end services created using mirror image；The elastic public network IP address of the load balancing example of creation and creation is associated；It is disposed to terminal sending application and completes prompt information, and the elastic public network IP address after association is sent to terminal.The embodiment is realized using deployment beyond the clouds, and is extended the application of deployment beyond the clouds by creation load balancing example and externally provided the ability serviced.

Description

Method and apparatus for deploying applications

technical field

The embodiments of the present application relate to the field of computer technologies, and in particular to methods and devices for deploying applications.

Background technique

With the continuous development of Internet technology, the cloud platform has been more and more widely used due to its high efficiency and convenience. The main function of the container cloud is application-centric, helping application developers run applications in distributed systems in the form of containers, and finally present applications to users in the form of services.

At present, many container cloud platforms provide application running platforms through technologies such as Docker (application container engine) and Kubernetes, so as to realize operation and maintenance automation, rapid application deployment, elastic scaling and dynamic adjustment of application environment resources, etc., and improve R&D and operation efficiency. Kubernetes (usually written as "k8s") was originally an open source container cluster management system designed and developed by Google. Kubernetes can provide functions such as application deployment, maintenance, and expansion mechanisms.

Contents of the invention

Embodiments of the present application provide methods and devices for deploying applications.

In the first aspect, an embodiment of the present application provides a method for deploying an application, the method including: receiving an application deployment request for deploying an application sent by a terminal used by a user, wherein the application deployment request includes configuration parameters and Mirroring, wherein the above configuration parameters include access type; determine whether to provide load balancing service for the above application according to the above access type; in response to determining to provide load balancing service for the above application, create a load balancing instance, and create an elastic public network IP address, wherein , the above load balancing instance is added with the backend service created using the above image; associate the created load balancing instance with the created elastic public IP address; The network IP address is sent to the above-mentioned terminal.

In some embodiments, a preset route creation interface is provided to the container cluster management system, wherein the above container cluster management system is used to manage the container cluster running the above application; in response to determining that the above container cluster management system invokes the above route creation The interface generates an instance routing table according to the private network corresponding to the above user, and generates a routing table according to the above instance routing, wherein the above routing table is used to realize network communication between workload units among different nodes in the above container cluster.

In some embodiments, the above-mentioned creation of a load balancing instance includes: creating a load balancing instance for the above application in response to determining that there is no load balancing instance for the above application; creating at least one listener for the load balancing instance of the above application, wherein , the listener is used to define load balancing policies and forwarding rules; add backend services to the load balancing instances of the above applications.

In some embodiments, before creating the load balancing instance, the above method further includes: receiving virtual machine setting information sent by the terminal used by the user, wherein the above virtual machine setting information is used to set at least one virtual machine; according to the above virtual Set at least one virtual machine according to the machine setting information, and create a container cluster based on the at least one virtual machine.

In some embodiments, the above method further includes: setting an interface for the container cluster management system to implement container cluster management by calling the interface, wherein the above interface includes at least one of the following: load balancing creation interface, node information acquisition interface, available Zone information acquisition interface, route creation interface, and persistent storage labeling interface.

In the second aspect, the embodiment of the present application provides a device for deploying an application, the device includes: a receiving unit configured to receive an application deployment request for deploying an application sent by a terminal used by a user, wherein the above-mentioned application deployment The request includes configuration parameters and mirror images, wherein the configuration parameters include access types; the determination unit is configured to determine whether to provide load balancing services for the above applications according to the access types; the creation unit is configured to respond to determining to provide load balancing services for the above applications Balanced service, create a load balancing instance, and create an elastic public IP address, wherein the above load balancing instance is added with the backend service created using the above image; the association unit is configured to create the load balancing instance and the created elastic public IP address The network IP address is associated; the sending unit is configured to send application deployment completion prompt information to the above terminal, and send the associated elastic public network IP address to the above terminal.

In some embodiments, the above-mentioned apparatus further includes: a providing unit configured to provide a preset route creation interface to the container cluster management system, wherein the above-mentioned container cluster management system is used to manage the container cluster running the above-mentioned application; generate A unit configured to generate an instance routing table according to the private network corresponding to the user in response to determining that the above-mentioned container cluster management system calls the above-mentioned route creation interface, and generate a routing table according to the above-mentioned instance route, wherein the above-mentioned routing table is used to implement the above-mentioned container Network communication between workload units among different nodes in the cluster.

In some embodiments, the creating unit is further configured to: create a load balancing instance for the above application in response to determining that there is no load balancing instance for the above application; create at least one listener for the load balancing instance of the above application, wherein , the listener is used to define load balancing policies and forwarding rules; add backend services to the load balancing instances of the above applications.

In some embodiments, the above-mentioned apparatus further includes a first setting unit, the above-mentioned first setting unit is configured to: receive the virtual machine setting information sent by the terminal used by the above-mentioned user, wherein the above-mentioned virtual machine setting information is used to set at least one A virtual machine: setting at least one virtual machine according to the above virtual machine setting information, and creating a container cluster based on the above at least one virtual machine.

In some embodiments, the above-mentioned apparatus further includes: a second setting unit configured to set an interface for the container cluster management system to implement management of the container cluster by calling the interface, wherein the above-mentioned interface includes at least one of the following: load balancing creation Interface, node information acquisition interface, availability zone information acquisition interface, route creation interface, persistent storage labeling interface.

In the third aspect, the embodiment of the present application provides a server, the server includes: one or more processors; When executed by one or more processors, the above one or more processors implement the method described in any implementation manner of the first aspect.

In a fourth aspect, an embodiment of the present application provides a computer-readable medium, on which a computer program is stored, wherein, when the computer program is executed by a processor, the method described in any implementation manner in the first aspect is implemented.

The method and device for deploying applications provided by the embodiments of the present application firstly receive the application deployment request sent by the terminal used by the user for deploying applications, and then determine whether to provide load balancing services for the above-mentioned applications according to the access type. Provide load balancing services for the above applications, create a load balancing instance, and create an elastic public IP address, then associate the created load balancing instance with the created elastic public IP address, and finally send a notification message that the application deployment is complete to the terminal, and Send the associated elastic public network IP address to the terminal, thereby realizing the deployment of the application in the cloud, and expanding the ability of the application deployed in the cloud to provide external services by creating a load balancing instance.

Description of drawings

Other characteristics, objects and advantages of the present application will become more apparent by reading the detailed description of non-limiting embodiments made with reference to the following drawings:

FIG. 1 is an exemplary system architecture diagram to which an embodiment of the present application can be applied;

FIG. 2 is a flowchart of an embodiment of a method for deploying an application according to the present application;

Fig. 3 is according to the example figure that Kubernetes realizes interacting with the public cloud by calling the interface in this application;

FIG. 4 is a schematic diagram of an application scenario of a method for deploying an application according to the present application;

Fig. 5 is a flow chart of another embodiment of the method for deploying an application according to the present application;

FIG. 6 is an example diagram of network communication in a container cluster according to the present application;

Fig. 7 is a schematic structural diagram of an embodiment of a device for deploying applications according to the present application;

FIG. 8 is a schematic structural diagram of a computer system suitable for implementing the server of the embodiment of the present application.

Detailed ways

The application will be further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described here are only used to explain related inventions, rather than to limit the invention. It should also be noted that, for the convenience of description, only the parts related to the related invention are shown in the drawings.

It should be noted that, in the case of no conflict, the embodiments in the present application and the features in the embodiments can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and embodiments.

Fig. 1 shows an exemplary system architecture 100 to which the method for deploying an application or the device for deploying an application according to the embodiment of the present application can be applied.

As shown in FIG. 1 , a system architecture 100 may include terminal devices 101 , 102 , 103 , a network 104 and a server 105 . The network 104 is used as a medium for providing communication links between the terminal devices 101 , 102 , 103 and the server 105 . Network 104 may include various connection types, such as wires, wireless communication links, or fiber optic cables, among others.

Users (for example, application developers) can use terminal devices 101 , 102 , 103 to interact with server 105 through network 104 to receive or send messages and the like. Various communication client applications can be installed on the terminal devices 101, 102, 103, such as web browser applications, shopping applications, search applications, instant messaging tools, email clients, social platform software, and the like.

The terminal devices 101, 102, and 103 may be hardware or software. When the terminal devices 101, 102, and 103 are hardware, they can be various electronic devices that have display screens and support the sending and receiving of information, including but not limited to smart phones, tablet computers, laptop computers and desktop computers, etc. . When the terminal devices 101, 102, 103 are software, they can be installed in the electronic devices listed above. It can be implemented as a plurality of software or software modules (for example, to provide distributed services), or as a single software or software module. No specific limitation is made here.

The server 105 may be a server that provides various services, such as a cloud server that processes the application deployment requests sent by the terminal devices 101, 102, and 103. The cloud server may deploy the applications according to the received application deployment requests. After the deployment is completed, Interfaces (for example, URLs) for accessing applications deployed on the cloud may be provided.

It should be noted that the server may be hardware or software. When the server is hardware, it can be implemented as a distributed server cluster composed of multiple servers, or as a single server. When the server is software, it can be implemented as multiple software or software modules (for example, for providing distributed services), or as a single software or software module. No specific limitation is made here.

It should be understood that the numbers of terminal devices, networks and servers in Fig. 1 are only illustrative. According to the implementation needs, there can be any number of terminal devices, networks and servers.

It should be noted that the method for deploying applications provided in the embodiment of the present application is generally executed by the server 105 , and correspondingly, the device for deploying applications is generally set in the server 105 .

Continuing to refer to FIG. 2 , a flow 200 of an embodiment of the method for deploying applications according to the present application is shown. The method for deploying an application includes the following steps:

Step 201, receiving an application deployment request sent by a terminal used by a user for deploying an application.

In this embodiment, the execution subject of the method for deploying applications (such as the server 105 shown in FIG. , 102, 103) receiving an application deployment request for deploying an application. Here, the above-mentioned application deployment request may include configuration parameters and images, wherein the configuration parameters may include access type, number of operating instances, and the like. The access type may refer to the manner in which the customer accesses the above application, and the access type may include load balancing and non-load balancing, that is, the customer's access request is distributed to each running instance of the application through load balancing. The aforementioned image may refer to an image file obtained by processing the application program file of the aforementioned application. Here, the client may refer to a network user who accesses the above-mentioned application deployed on the cloud.

In practice, the execution subject mentioned above can store the received image in a mirror warehouse, and the mirror warehouse is a place for centralized storage of mirror files. Multiple image files can be stored in each image repository, and each image file has a different label. In this way, the above execution subject can use the image file in the image warehouse to create a container, and use the created container to run the application to provide the backend service of the application. A container is an application running instance created from an image. It can be started, started, stopped, and deleted. Multiple containers are isolated from each other.

Step 202, determine whether to provide load balancing service for the application according to the access type.

In this embodiment, the execution subject may determine whether to provide a load balancing service for the application according to the access type. As an example, when the above-mentioned access type is load balancing, the above-mentioned execution subject may determine to provide a load-balancing service for the above-mentioned application.

Step 203, in response to determining that the load balancing service is provided for the application, a load balancing instance is created, and an elastic public network IP address is created.

In this embodiment, in response to determining that the load balancing service is provided for the above application, the execution subject may create a load balancing instance and create an elastic public network IP address. Among them, the created load balancing instance can be added with the backend service created using the above image. A load balancing instance is a running load balancing service entity, and multiple listeners and backend servers can be added to a load balancing instance. Here, the listener is used to define load balancing policies and forwarding rules, and the backend server can be used to process requests from customers to access the above applications. Multiple virtual machines can run on one backend server, and each virtual machine can have multiple virtual machines. Each container can run the backend service of the above application.

In practice, the above execution subject can create a load balancing instance through preset rules. After the load balancing instance is created, the above execution subject can also create an elastic public IP address for the above application. Elastic IP Address (EIP for short) is a public IP address that can be purchased and held independently. The above-mentioned executive body can apply for an elastic public IP address, and poll and wait for the application of the elastic public IP address to be completed. In response to the completion of the application, it is determined that the creation of the elastic public network IP address is completed. It should be noted that the technology of creating a load balancing instance and applying for an elastic public IP address is a well-known technology widely used in cloud platforms at present, and will not be repeated here.

In some optional implementations of this embodiment, the above process of creating a load balancing instance may specifically include the following content: first, the above execution subject may determine whether there is a load balancing instance for the above application, and in response to determining that there is no load balancing instance for the above The load balancing instance of the application, the above execution subject can create a load balancing instance for the above application. Afterwards, the above execution subject may create at least one listener for the load balancing instance of the above application. Among them, the listener is used to define load balancing policies and forwarding rules. Then, the execution subject may also add a backend service to the load balancing instance of the application, wherein the backend service is created based on the image of the application. As an example, the above execution subject may use the image file of the above application to create a container, and use the created container to run the application to provide the backend service of the application.

In some scenarios, in response to determining that there is a load balancing instance for the above application, the execution subject may update the listener and backend service of the existing load balancing instance according to actual needs.

In some optional implementations of this embodiment, before creating a load balancing instance, the above method for deploying an application may further include the following:

First, the execution subject may receive virtual machine setting information sent by the terminal used by the user, wherein the virtual machine setting information is used to set at least one virtual machine. For example, the virtual machine setting information may refer to the purchase information of the virtual machine purchased by the user, for example, may include the number of purchased virtual machines and the like.

Then, the execution subject may set at least one virtual machine according to the virtual machine setting information, and create a container cluster based on the at least one virtual machine. In practice, each of the above at least one virtual machine can be used as a node, and multiple workload units can be set in each node, and at least one container can be set in each workload unit, and each container A backend service that can run the above application. The containers in the above at least one virtual machine may form a container cluster.

In some optional implementation manners, the above-mentioned method for deploying an application may further include the following content: setting an interface for the container cluster management system to manage the container cluster by calling the interface. Here, the above-mentioned interfaces may include at least one of the following: an interface for creating load balancing, an interface for obtaining node information, an interface for obtaining information about availability zones, an interface for creating routes, and an interface for labeling persistent storage. Here, a series of interfaces may be preset to realize the management of the above-mentioned container cluster by the above-mentioned container cluster management system. The series of interfaces set can use Cloud SDK (Cloud Software Development Kit) to realize the interaction with the public cloud. Among them, the Cloud SDK can encapsulate the Open API of the public cloud (that is, the open API), and can also add authentication to the request authentication etc.

As an example, the above container cluster management system may be Kubernetes. At this point, the above-mentioned virtual machine can be used as a Kubernetes node (Node), and each node can have at least one workload unit (Pod). The Pod includes at least one container, and the Pod is the basic operating unit of Kubernetes. Kubernetes can realize the management of the above-mentioned container cluster by calling the above-mentioned series of interfaces.

For example, as shown in Figure 3, the Node Controller in Kubernetes can obtain node information by calling the above-mentioned node information acquisition interface, such as virtual machine identifier, availability zone, etc., and can also obtain available information by calling the availability zone information acquisition interface district information.

The Router Controller in Kubernetes can create a route table in a private network (Virtual Private Cloud, VPC) by calling the route creation interface.

The Service Controller in Kubernetes can control the creation of the load balancing instance and the creation of the elastic public network IP address by calling the load balancing creation interface.

The Persistent Volume label Controller in Kubernetes can control the labeling of persistent volumes by calling the persistent storage labeling interface.

Node Status in Kubernetes can obtain node information by calling the node information acquisition interface, and can obtain availability zone information by calling the availability zone information acquisition interface.

The apiserver in Kubernetes can pass the SSH Key by calling the node information acquisition interface.

Step 204, associating the created load balancing instance with the created elastic public network IP address.

In this embodiment, the above execution subject may associate the load balancing instance created in step 203 with the created elastic public network IP address. As an example, the above execution subject can realize the binding of the load balancing instance and the elastic public network IP address by calling the interface.

Step 205, sending a prompt message of application deployment completion to the terminal, and sending the associated elastic public network IP address to the terminal.

In this embodiment, after step 204 is completed, the execution subject may send application deployment completion notification information to the terminal to remind the user that application deployment is complete. The above execution subject may also send the associated elastic public network IP address to the terminal. Through the elastic public IP address, customers can access the services of the above-mentioned applications deployed in the cloud.

Continue to refer to FIG. 4, which is a schematic diagram of the application scenario of the method for deploying applications according to this embodiment picture. In the application scenario shown in Figure 4, the cloud server first receives the application for deploying the application sent by the terminal used by the user. Deployment request, wherein the above-mentioned application deployment request includes configuration parameters and images, wherein the configuration parameters include access type: negative load balancing. Secondly, the cloud server can determine whether to provide load balancing services for the above applications according to the access type. Again Second, in response to determining to provide load balancing services for the above applications, the cloud server can create a load balancing instance, and create Create an elastic public IP address, where the load balancing instance is added with the backend service created using the above image. Then, the cloud server The server can associate the created load balancing instance with the created elastic public IP address. Finally, cloud servers can Send an application deployment completion notification message to the above-mentioned terminal, and send the associated elastic public IP address to the above-mentioned terminal end. Customers can access the above-mentioned applications deployed on the cloud server through the elastic public IP address. As shown in Figure 4 It shows that when the container accesses the external network, it can use the address of the virtual machine running on the backend server through SNAT (source address translation). URL to access the external network, where each virtual machine can be used as a node. When the external network accesses the container, the request can be The public network IP address, load balancing instance, etc. are forwarded to the virtual machine port, and then passed through iptables (IP packet filtering system) forwarded to the corresponding container. As shown in Figure 4, the backend server can run multiple nodes in Availability Zone-A and Availability Zone-B. Each node runs at least one workload unit (Pod), and each workload unit (Pod) is set to There is one less container, and each container can run the back-end services of the above applications. Containers in the above multiple nodes can be composed of container cluster. This cluster can choose to be deployed in a certain region, and use the private network (VPC) function in different availability zones Deployment to improve application availability.

The method provided by the above embodiments of the present application realizes the deployment of the application on the cloud, and expands the ability of the application deployed on the cloud to provide external services by creating a load balancing instance.

Further referring to FIG. 5 , it shows a flow 500 of still another embodiment of the method for deploying an application. The process 500 of the method for deploying an application includes the following steps:

Step 501, receiving an application deployment request sent by a terminal used by a user for deploying an application.

In this embodiment, the execution subject of the method for deploying applications (such as the server 105 shown in FIG. , 102, 103) receiving an application deployment request for deploying an application. Here, the above-mentioned application deployment request may include configuration parameters and images, wherein the configuration parameters may include access type, number of operating instances, and the like.

Step 502, determine whether to provide load balancing service for the application according to the access type.

In this embodiment, the execution subject may determine whether to provide a load balancing service for the application according to the access type.

Step 503, in response to determining that the load balancing service is provided for the application, create a load balancing instance, and create an elastic public network IP address.

In this embodiment, in response to determining that the load balancing service is provided for the above application, the execution subject may create a load balancing instance and create an elastic public network IP address. Among them, the created load balancing instance can be added with the backend service created using the above image. A load balancing instance is a running load balancing service entity, and multiple listeners and backend servers can be added to a load balancing instance. Here, the back-end server can be used to process requests from customers to access the above applications. Multiple virtual machines can run on one back-end server, and each virtual machine can have multiple containers, and the above-mentioned applications can run in each container. backend services.

Step 504, associating the created load balancing instance with the created elastic public network IP address.

In this embodiment, the above execution subject may associate the load balancing instance created in step 503 with the created elastic public network IP address.

Step 505, sending a prompt message of application deployment completion to the terminal, and sending the associated elastic public network IP address to the terminal.

In this embodiment, the execution subject may send application deployment completion prompt information to the terminal to prompt the user that the application deployment is complete. The above execution subject may also send the associated elastic public network IP address to the terminal.

Step 506, providing a preset route creation interface to the container cluster management system.

In this embodiment, the execution subject may provide a preset route creation interface to the container cluster management system. Wherein, the above-mentioned container cluster management system may be used to manage the container cluster running the above-mentioned application. Here, the above-mentioned route creation interface can call the open interface in the private network (VPC).

Step 507, in response to determining that the container cluster management system invokes the route creation interface, generates an instance routing table according to the private network corresponding to the user, and generates a routing table according to the instance route.

In this embodiment, in response to determining that the container cluster management system invokes the route creation interface, the execution subject can generate an instance routing table by calling the open interface of the private network (VPC) corresponding to the above-mentioned user, and then the private network (VPC) can be based on The above example routing table generates a routing table. The routing table can be used to implement network communication between workload units among different nodes in the container cluster. For example, as shown in FIG. 6, node 1 and node 2 are included in FIG. 6, wherein, node 1 and node 2 include workload unit 1 and workload unit 2 respectively, and each workload unit includes container 1 and container 2. Among them, eth0 represents the physical network card. In this example, each workload unit needs to have an independent IP address, and all workload units are in a flat network space that can be directly connected. At this point, the communication between containers can be based on the following principles:

1) The containers in the same workload unit share the same network namespace, and the access between them can use the localhost (local host) address + container port.

2) The default route of the workload unit in the same node is the address of the Ethernet bridge cbr0. Since the workload unit in the same node is associated with the same cbr0 bridge and the address network segment is the same, all the workload units in the same node Containers can communicate directly with each other.

3) For the communication of workload units between different nodes, use the routing function of the private network (VPC) to route the network packets whose target IP is the container network segment, and forward them to the corresponding nodes. In this case, a routing table is required.

It can be seen from FIG. 5 that, compared with the embodiment corresponding to FIG. 2 , the process 500 of the method for deploying applications in this embodiment highlights the process of generating the routing table, thereby realizing the connection between the containers in the container cluster. Communication.

Further referring to FIG. 7 , as an implementation of the methods shown in the above figures, the present application provides an embodiment of a device for deploying applications. This device embodiment corresponds to the method embodiment shown in FIG. 2 . The device can be specifically applied to various electronic devices.

As shown in FIG. 7 , the apparatus 700 for deploying applications in this embodiment includes: a receiving unit 701 , a determining unit 702 , a creating unit 703 , an associating unit 704 and a sending unit 705 . Wherein, the receiving unit 701 is configured to receive an application deployment request for deploying an application sent by a terminal used by a user, wherein the above-mentioned application deployment request includes configuration parameters and images, wherein the above-mentioned configuration parameters include access types; the determining unit 702 is It is configured to determine whether to provide load balancing service for the above application according to the above access type; the creating unit 703 is configured to create a load balancing instance and create an elastic public network IP address in response to determining to provide load balancing service for the above application, wherein the above load The balance instance is added with the back-end service created using the above image; the association unit 704 is configured to associate the created load balance instance with the created elastic public IP address; the sending unit 705 is configured to send an application deployment completion notification to the above terminal information, and send the associated elastic public IP address to the above terminal.

In this embodiment, the specific processing of the receiving unit 701, the determining unit 702, the creating unit 703, the associating unit 704, and the sending unit 705 of the apparatus 700 for deploying applications and the technical effects brought about by them can refer to FIG. 2 respectively. The relevant descriptions of step 201, step 202, step 203, step 204 and step 205 in the embodiment will not be repeated here.

In some optional implementations of this embodiment, the above-mentioned device 700 further includes: a providing unit (not shown in the figure), configured to provide a preset route creation interface to the container cluster management system, wherein the above-mentioned container cluster The management system is used to manage the container cluster running the above-mentioned application; the generation unit (not shown in the figure) is configured to respond to determining that the container cluster management system calls the above-mentioned route creation interface, and generate an instance according to the private network corresponding to the above-mentioned user A routing table, and generating a routing table according to the above-mentioned instance routing, wherein the above-mentioned routing table is used to implement network communication between workload units among different nodes in the above-mentioned container cluster.

In some optional implementations of this embodiment, the creating unit 703 is further configured to: create a load balancing instance for the above application in response to determining that there is no load balancing instance for the above application; The instance creates at least one listener, where the listener is used to define load balancing policies and forwarding rules; add backend services to the load balancing instance of the above application.

In some optional implementations of this embodiment, the above-mentioned apparatus 700 further includes a first setting unit (not shown in the figure), and the above-mentioned first setting unit is configured to: receive the virtual machine setting sent by the terminal used by the above-mentioned user Information, wherein the above virtual machine setting information is used to set at least one virtual machine; set at least one virtual machine according to the above virtual machine setting information, and create a container cluster based on the above at least one virtual machine.

In some optional implementations of this embodiment, the above-mentioned device 700 further includes: a second setting unit (not shown in the figure), configured to set an interface, so that the container cluster management system implements the container cluster by calling the interface Management, wherein the above-mentioned interface includes at least one of the following: an interface for creating a load balancer, an interface for obtaining node information, an interface for obtaining information about an availability zone, an interface for creating a route, and an interface for labeling persistent storage.

Referring now to FIG. 8 , it shows a schematic structural diagram of a computer system 800 suitable for implementing the server of the embodiment of the present application. The server shown in FIG. 8 is only an example, and should not limit the functions and scope of use of this embodiment of the present application.

As shown in FIG. 8 , a computer system 800 includes a central processing unit (CPU, Central Processing Unit) 801, which can be randomly accessed according to a program stored in a read-only memory (ROM, Read Only Memory) 802 or loaded from a storage section 806 Various appropriate actions and processes are executed by programs stored in random access memory (RAM, Random Access Memory) 803 . In the RAM 803, various programs and data necessary for the operation of the system 800 are also stored. The CPU 801 , ROM 802 , and RAM 803 are connected to each other via a bus 804 . An input/output (I/O, Input/Output) interface 805 is also connected to the bus 804 .

The following components are connected to the I/O interface 805: a storage section 806 including a hard disk and the like; and a communication section 807 including a network interface card such as a LAN (Local Area Network) card, a modem, and the like. The communication section 807 performs communication processing via a network such as the Internet. A drive 808 is also connected to the I/O interface 805 as needed. A removable medium 809, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is mounted on the drive 808 as necessary so that a computer program read therefrom is installed into the storage section 806 as necessary.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product, which includes a computer program carried on a computer-readable medium, where the computer program includes program codes for executing the methods shown in the flowcharts. In such an embodiment, the computer program may be downloaded and installed from a network via communication portion 807 and/or installed from removable media 809 . When the computer program is executed by the central processing unit (CPU) 801, the above-mentioned functions defined in the method of the present application are performed.

It should be noted that the computer-readable medium described in this application may be a computer-readable signal medium or a computer-readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable Programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In the present application, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In this application, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, in which computer-readable program codes are carried. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device. . Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out the operations of this application may be written in one or more programming languages, or combinations thereof, including object-oriented programming languages—such as Java, Smalltalk, C++, and conventional A procedural programming language—such as "C" or a similar programming language. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In cases involving a remote computer, the remote computer can be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (such as through an Internet service provider). Internet connection).

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or portion of code that contains one or more logical functions for implementing specified executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified functions or operations , or may be implemented by a combination of dedicated hardware and computer instructions.

The units involved in the embodiments described in the present application may be implemented by means of software, or may be implemented by means of hardware. The described units may also be set in a processor, for example, it may be described as: a processor includes a receiving unit, a determining unit, a creating unit, an associating unit and a sending unit. Wherein, the names of these units do not constitute a limitation on the unit itself under certain circumstances, for example, the receiving unit can also be described as "a unit that receives an application deployment request sent by a terminal used by a user for deploying an application" .

As another aspect, the present application also provides a computer-readable medium. The computer-readable medium may be included in the device described in the above embodiments, or it may exist independently without being assembled into the device. The above-mentioned computer-readable medium carries one or more programs, and when the one or more programs are executed by the device, the device: receives an application deployment request for deploying an application sent by a terminal used by a user, wherein the above-mentioned The application deployment request includes configuration parameters and images, wherein the above configuration parameters include access types; determine whether to provide load balancing services for the above applications according to the above access types; Elastic public network IP address, wherein the above load balancing instance is added with the backend service created using the above image; associate the created load balancing instance with the created elastic public network IP address; send a prompt message of application deployment completion to the above terminal, And send the associated elastic public network IP address to the above-mentioned terminal.

The above description is only a preferred embodiment of the present application and an illustration of the applied technical principles. Those skilled in the art should understand that the scope of the invention involved in this application is not limited to the technical solution formed by the specific combination of the above-mentioned technical features, and should also cover the technical solutions formed by the above-mentioned technical features or without departing from the above-mentioned inventive concept. Other technical solutions formed by any combination of equivalent features. For example, a technical solution formed by replacing the above-mentioned features with technical features with similar functions disclosed in (but not limited to) this application.

Claims (12)

1. A method for deploying an application, comprising: receiving an application deployment request for deploying an application sent by a terminal used by a user, where the application deployment request includes configuration parameters and images, where the configuration parameters include an access type; Determine whether to provide load balancing services for the application according to the access type; In response to determining that a load balancing service is provided for the application, creating a load balancing instance, and creating an elastic public network IP address, wherein the load balancing instance is added with the backend service created using the image; Associate the created load balancing instance with the created elastic public IP address; Sending application deployment completion prompt information to the terminal, and sending the associated elastic public network IP address to the terminal. 2. The method of claim 1, wherein the method further comprises: providing a preset route creation interface to a container cluster management system, wherein the container cluster management system is used to manage the container cluster running the application; In response to determining that the container cluster management system invokes the route creation interface, generate an instance routing table according to the private network corresponding to the user, and generate a routing table according to the instance route, wherein the routing table is used to implement the Network communication between workload units between different nodes in a container cluster. 3. The method according to claim 1, wherein said creating a load balancing instance comprises: creating a load balancing instance for the application in response to determining that no load balancing instance exists for the application; Create at least one listener for the load balancing instance of the application, where the listener is used to define load balancing policies and forwarding rules; Add a backend service for the load balancing instance of the application in question. 4. The method according to claim 1, wherein, before creating the load balancing instance, the method further comprises: receiving virtual machine setting information sent by the terminal used by the user, wherein the virtual machine setting information is used to set at least one virtual machine; Setting at least one virtual machine according to the virtual machine setting information, and creating a container cluster based on the at least one virtual machine. 5. The method of claim 4, wherein the method further comprises: Set an interface for the container cluster management system to implement container cluster management by calling the interface, wherein the interface includes at least one of the following: load balancing creation interface, node information acquisition interface, availability zone information acquisition interface, route creation interface, persistent storage labeling interface. 6. An apparatus for deploying an application, comprising: The receiving unit is configured to receive an application deployment request for deploying an application sent by a terminal used by a user, where the application deployment request includes configuration parameters and images, where the configuration parameters include an access type; a determining unit configured to determine whether to provide a load balancing service for the application according to the access type; The creating unit is configured to create a load balancing instance and create an elastic public network IP address in response to determining that a load balancing service is provided for the application, wherein the load balancing instance is added with a backend service created using the image; The association unit is configured to associate the created load balancing instance with the created elastic public network IP address; The sending unit is configured to send application deployment completion prompt information to the terminal, and send the associated elastic public network IP address to the terminal. 7. The apparatus of claim 6, wherein the apparatus further comprises: A providing unit configured to provide a preset route creation interface to a container cluster management system, wherein the container cluster management system is used to manage the container cluster running the application; A generation unit configured to generate an instance routing table according to the private network corresponding to the user in response to determining that the container cluster management system invokes the route creation interface, and generate a routing table according to the instance route, wherein the route The table is used to implement network communication between workload units among different nodes in the container cluster. 8. The apparatus according to claim 6, wherein the creating unit is further configured to: creating a load balancing instance for the application in response to determining that no load balancing instance exists for the application; Create at least one listener for the load balancing instance of the application, where the listener is used to define load balancing policies and forwarding rules; Add a backend service for the load balancing instance of the application in question. 9. The device according to claim 6, wherein the device further comprises a first setting unit configured to: receiving virtual machine setting information sent by the terminal used by the user, wherein the virtual machine setting information is used to set at least one virtual machine; Setting at least one virtual machine according to the virtual machine setting information, and creating a container cluster based on the at least one virtual machine. 10. The apparatus of claim 9, wherein the apparatus further comprises: The second setting unit is configured to set an interface for the container cluster management system to implement container cluster management by calling the interface, wherein the interface includes at least one of the following: load balancing creation interface, node information acquisition interface, availability zone information Interface for acquisition, interface for route creation, interface for persistent storage and labeling. 11. A server, comprising: one or more processors; a storage device on which one or more programs are stored, When the one or more programs are executed by the one or more processors, the one or more processors are made to implement the method according to any one of claims 1-5. 12. A computer-readable medium, on which a computer program is stored, wherein, when the program is executed by a processor, the method according to any one of claims 1-5 is realized.