WO2019218463A1 - Method and apparatus for automatically building kubernetes master node on basis of ansible tool, terminal device, and readable storage medium - Google Patents

Abstract

The present solution is applicable to the technical field of data processing, and provides a method for automatically building a Kubernetes master node on the basis of an Ansible tool, a terminal device, and a computer-readable storage medium. The method comprises: adding creation parameters input by a user and related to a Kubernetes master node to a preset configuration template to generate a configuration file; determining a node to be deployed corresponding to the configuration file among multiple available nodes, wherein the available nodes are available physical nodes or virtual machine nodes; and invoking an Ansible tool to build the Kubernetes master node in the node to be deployed on the basis of the configuration file. The present solution achieves automatic building of a Kubernetes master node by means of an Ansible tool and improves the building efficiency of the Kubernetes master node.

Description

Method, device, terminal device and readable storage medium for automatically building Kubernetes master node based on Ansible tool

This application claims the priority of the Chinese patent application filed on May 14, 2018, the Chinese Patent Office, the application number is 201810456299.X, and the invention is entitled "Method and terminal device for automatically building the Kubernetes master node based on the Ansible tool". The content is incorporated herein by reference.

Technical field

The present application belongs to the field of data processing technologies, and in particular, to a method, a device, a terminal device and a computer readable storage medium for automatically setting up a Kubernetes master node based on an Ansible tool.

Background technique

Traditional virtualization technologies, such as hypervisor virtualization technology, have shortcomings in terms of performance and resource usage, while container technology improves resource utilization by dividing resources managed by a single operating system into isolated groups. Become a research hotspot. A container can be understood as a sandbox in which one application runs, and different containers are isolated from each other, but a communication mechanism can be established between the containers. The container technology provided by Docker allows for the same, each container being a separate virtual environment or application.

Kubernetes is an open source container orchestration tool that combines the functions of combining several containers into one service and dynamically allocating hosts running on the container, providing great convenience for users to use the container. To use Kubernetes, Kubernetes clusters need to be built. Kubernetes clusters include two types of nodes: master node and slave node. The master node is responsible for the management and scheduling of all resources in the Kubernetes cluster. Therefore, the master node is built first. However, when the Kubernetes master node is built in the prior art, each step in the setup process requires manual configuration by the user, and the construction efficiency is low.

technical problem

In view of this, the embodiment of the present application provides a method, an apparatus, a terminal device, and a computer readable storage medium for automatically setting up a Kubernetes master node based on an Ansible tool, so as to solve the problem of low efficiency of building a Kubernetes master node in the prior art.

Technical solution

The first aspect of the embodiment of the present application provides a method for automatically setting up a Kubernetes master node based on an Ansible tool, and completing a Kubernetes master node by executing a preset deployment script, including:

Adding a user-entered creation parameter related to the Kubernetes master node to a preset configuration template to generate a configuration file;

Determining a node to be deployed corresponding to the configuration file among a plurality of available nodes, wherein the available node is an available physical node or a virtual machine node;

Calling the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file.

A second aspect of the embodiments of the present application provides an apparatus for automatically setting up a Kubernetes master node based on an Ansible tool, and may include a unit for implementing the steps of the foregoing method for automatically setting a Kubernetes master node based on an Ansible tool.

A third aspect of the embodiments of the present application provides a terminal device, including a memory and a processor, where the computer stores computer readable instructions executable on the processor, the processor executing the computer The steps of the above method for automatically setting up the Kubernetes master node based on the Ansible tool are implemented when the instruction is read.

A fourth aspect of the embodiments of the present application provides a computer readable storage medium storing computer readable instructions, which are implemented by a processor to implement the above-described automatic build based on an Ansible tool. The steps of the Kubernetes master node method.

Beneficial effect

The embodiment of the present application completes the establishment of the Kubernetes master node by executing a preset deployment script, including filling the user-entered creation parameters related to the Kubernetes master node into a preset configuration template, thereby generating a configuration file from multiple available nodes. Determine the node to be deployed corresponding to the configuration file. The available node refers to the available physical node or virtual machine node. Finally, the Ansible tool is automatically invoked. Based on the configuration file, the Kubernetes master node is set up in the node to be deployed, and the deployment script is implemented. The automation of the Kubernetes main node has improved the construction efficiency.

DRAWINGS

1 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool in Embodiment 1 of the present application;

2 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool in Embodiment 2 of the present application;

3 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool in Embodiment 3 of the present application;

4 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool in Embodiment 4 of the present application;

5 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool in Embodiment 5 of the present application;

6 is a structural block diagram of an apparatus for automatically setting up a Kubernetes master node based on an Ansible tool in Embodiment 6 of the present application;

7 is a schematic diagram of a Kubernetes cluster in Embodiment 7 of the present application;

8 is a regional structure diagram based on a Kubernetes cluster in Embodiment 8 of the present application;

FIG. 9 is a schematic diagram of a terminal device in Embodiment 9 of the present application.

Embodiments of the invention

In order to more clearly understand the technical features, objects and effects of the present application, the specific embodiments of the present application will be described in detail with reference to the accompanying drawings.

Please refer to FIG. 1. FIG. 1 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool according to an embodiment of the present application. As shown in Figure 1, the method includes the following steps:

S101: Add a creation parameter related to the Kubernetes primary node input by the user to the preset configuration template to generate a configuration file.

In the embodiment of the present application, for convenience of description, the Kubernetes related technology and the Kubernetes master node are first introduced. Kubernetes is a container orchestration tool for automated container operations. It enables the deployment and scheduling of containers, as well as inter-cluster extensions. The physical server or virtual machine with Kubernetes tools is called the Kubernetes node. In general, multiple Kubernetes nodes are required to be formed as Kubernetes clusters (Kubernetes) Cluster) to achieve the deployment and management of the container. Within a Kubernetes cluster, there is one and only one control unit, the Kubernetes master node (Kubernetes) Master), mainly responsible for receiving requests, resource scheduling, and management. The components of the Kubernetes master node are described in detail later. In addition to the Kubernetes master node, the Kubernetes cluster usually includes multiple subordinate objects of the Kubernetes master node, that is, multiple Kubernetes Nodes (Kubernetes Node), which are used to actually run the container allocated by the Kubernetes master node.

In the embodiment of the present application, the automatic establishment of the Kubernetes master node is performed by executing a preset deployment script, which is specifically performed by performing the configuration of the code in the configuration process of the Kubernetes master node. The deployment script automatically completes steps S101 to S103. It is worth mentioning that the deployment script is a script file, and the script file is a combination of a series of actions that control the computer to perform arithmetic operations, in which logical branches can be implemented. Preferably, the deployment script is written in the Shell language. Of course, depending on the application scenario, the deployment script can also be written in other languages suitable for writing script files.

Optionally, the deployment script corresponding to the build body is determined from the pre-stored multiple deployment scripts, and the deployment script is executed. To build the Kubernetes master node, in addition to the nodes to be deployed, there should be a building body that initiates the building action, that is, the terminal device of the user who initiated the building action. The environment of the terminal device may be different, such as the operating system. For example, the terminal device can run under the Windows operating system or the Linux operating system. For different environments of the terminal device, the code for building the Kubernetes master node may also be different. In turn, multiple deployment scripts can be pre-written, each of which corresponds to an environment terminal device. In the embodiment of the present application, a plurality of deployment scripts are pre-stored, for example, may be stored in a cloud server, and after the building entity issues an instruction to set up a Kubernetes master node, the corresponding deployment is determined from the cloud server according to the environment of the building entity. Scripts and automate the deployment script to improve the applicability of the deployment script to the build body.

Optionally, the user is provided with a setup option for setting up a Kubernetes master node, and the setup option may be presented in the form of a graphical interface or a command line. After obtaining the confirmation result of the user about the setup option, the user is configured to build the Kubernetes master node. After the instruction, an operation of determining a deployment script corresponding to the build body from the plurality of pre-stored deployment scripts is performed. By providing the user with the build options, the effectiveness and convenience of obtaining instructions for building the main Kubernetes node is improved.

During the execution of the deployment script, the creation parameters related to the Kubernetes master node input by the user are first added to the preset configuration template, and the configuration file is automatically generated. The creation parameters related to the Kubernetes master node include the attribute parameters of the Kubernetes master node, such as the installation version, the address of the Kubernetes master node, the node identifier (name) of the main Kubernetes node, and the area identifier. The creation parameters also include the composition of the Kubernetes master. Attribute parameters of each node component of the node, etc. In the embodiment of the present application, since the content format of the created parameter can be determined in advance, the configuration template can be preset according to the content format of the created parameter, and the configuration template includes the name of each content format of the created parameter, so that the user can input the corresponding name. Content, which improves the normativeness of creating parameter inputs and reduces the possibility of creating parameter input errors. After the creation parameters entered by the user are added to the configuration template, a configuration file can be generated, and the Kubernetes master node is built according to the configuration file in the subsequent steps.

S102: Determine, to be deployed, a node to be deployed corresponding to the configuration file, where the available node is an available physical node or a virtual machine node.

In the embodiment of the present application, a resource area stored by a plurality of available nodes is referred to as a public service area, and the public service area is used to deploy a program or service that provides a specific service for the user, that is, multiple available nodes in the public service area are available. The condition for deploying the Kubernetes master node, where the available nodes are available physical nodes or virtual machine nodes. Since the configuration file contains the node identifier (name) of the primary node running Kubernetes and the area identifier, the node corresponding to the configuration file can be determined from multiple available nodes, and the node is used as the node to be deployed.

S103: Call the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file.

Although the traditional tools such as the kops tool can build the Kubernetes master node, in the specific construction process, the user still needs to manually write code to perform the configuration of the address of the Kubernetes master node. In the embodiment of the present application, the Ansible tool is invoked, and the Ansible tool automatically builds a Kubernetes master node in the node to be deployed based on the configuration file. It should be noted that the Ansible tool is an automated operation and maintenance management tool based on the Python language. Compared to other tools such as server/client architecture, the Ansible tool does not need to deploy a client agent on the node to be deployed. After installing the Ansible tool on the build body, the Ansible tool can send a secure shell protocol to the node to be deployed (Secure Shell, SSH) commands to implement communication between the node to be deployed and the building entity. During the execution of the deployment script, after the configuration file and the node to be deployed are determined, the Ansible tool is automatically invoked, and the node components related to the Kubernetes master node are configured in the node to be deployed according to the creation parameters in the configuration file. After the configuration is completed, That is, the Kubernetes master node is successfully built in the node to be deployed. It is worth mentioning that, in step S102, the host may automatically send a configuration file-based query instruction to the management program of the public service area to determine the node to be deployed under the execution of the deployment script, or may be executed under the execution of the deployment script. The building entity directly determines the node to be deployed from among the available nodes based on the configuration file directly through the Ansible tool.

Optionally, configure SSH-free login for the node to be deployed. After installing the Ansible tool on the main body, you can view the building entity as an SSH server and treat the node to be deployed as an SSH client (the SSH server and SSH client here do not represent the Ansible tool to use the server/client architecture, just to It is convenient for SSH communication, and the construction process is highly simple. In order to facilitate communication between the main body and the node to be deployed, and further improve the construction efficiency, the key pair generated by the SSH key command in the construction body can be obtained (including private The key and the public key are distributed to the node to be deployed and stored in the storage space of the node to be deployed, so that the node to be deployed can implement the password-free login.

The embodiment shown in FIG. 1 shows that, in the embodiment of the present application, the establishment of the Kubernetes master node is completed by executing a preset deployment script, and specifically, the user-entered creation related to the Kubernetes master node is performed during the execution of the deployment script. Add parameters to the preset configuration template, generate a configuration file, determine the node to be deployed corresponding to the configuration file among the available physical nodes or virtual machine nodes, and finally call the Ansible tool to build Kubernetes in the node to be deployed based on the configuration file. The master node realizes the automatic establishment of the Kubernetes master node, which reduces the possibility of human error in the traditional configuration process and improves the building efficiency of the Kubernetes master node.

Referring to FIG. 2, FIG. 2 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool according to Embodiment 2 of the present application. With respect to the embodiment corresponding to FIG. 1, the embodiment refines the process before S102 to obtain S201~S202, which are as follows:

S201: Detect whether there is a node that is building the Kubernetes master node or has built the Kubernetes master node among the plurality of available nodes.

Before determining the node to be deployed from among the plurality of available nodes in the public service area, first detecting whether there are nodes of the plurality of available nodes that are building the Kubernetes master node or the established Kubernetes master node, and performing different operations according to the detected result, The Kubernetes master node in this step refers to the node that matches the attribute parameters in the configuration file. Specifically, a corresponding detection command is sent to a plurality of available nodes, and feedback of the plurality of available nodes regarding the detection command is received to perform detection by the Kubernetes master node.

S202: If there is no node that is setting up the Kubernetes master node or the Kubernetes master node, the node to be deployed corresponding to the configuration file is determined among the multiple available nodes. The operation of the node.

If there are nodes in the available nodes that are building the Kubernetes master node or the Kubernetes master node, the nodes to be deployed corresponding to the configuration files are determined to be stopped in the multiple available nodes in order to avoid the waste of resources caused by the repeated construction. The subsequent operation stops the execution of the deployment script; if there are no nodes in the available nodes that are building the Kubernetes master node or the Kubernetes master node, the Kubernetes master node is not created and is executed in multiple available nodes. Determine the operation of the node to be deployed corresponding to the configuration file.

It can be seen from the embodiment shown in FIG. 2 that in the embodiment of the present application, by detecting whether a plurality of available nodes are ready to be built or have built a Kubernetes master node, resource waste caused by repeated construction is effectively prevented.

Please refer to FIG. 3. FIG. 3 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool according to Embodiment 3 of the present application. With respect to the embodiment corresponding to FIG. 1, the embodiment obtains S301~S302 after S103 is refined, and the details are as follows:

S301: Obtain a binary configuration file associated with the Kubernetes master node from a binary file server.

In the embodiment of the present application, the Kubernetes master node is built according to the binary configuration file, and the binary configuration file can be understood as the installation file of the Kubernetes master node, so the binary configuration file is first obtained from the binary file server. Among them, the binary file server is a download server independent of the Kubernetes master node and the Kubernetes cluster, which is used to store various types of binary files and various types of scripts. In addition, the deployment script can be pre-stored in the binary file server, and the deployment script can be obtained from the binary file server when the Kubernetes primary node needs to be built.

S302: Start a script component preset in the Ansible tool, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures an operating environment of the Kubernetes master node.

After obtaining the binary configuration file, start the script component preset in the Ansible tool, that is, Playbooks, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures the operating environment of the Kubernetes master node. The script component is a component of the Ansible tool for configuring a remote node, which describes the steps for operating a remote node. The script component can contain a list of multiple elements, each of which is for a host, so the script component allows the Ansible tool to order multiple hosts. Under the element list of the script component, there are task lists (tasks), and each task under the task list is a call to the Ansible tool. In the embodiment of the present application, when only one node to be deployed is described, only one element list is set in the preset script component, and the Kubernetes main node has multiple node components, so a single element in the script component. In the task list of the list, multiple configuration tasks corresponding to multiple node components are set.

The description is performed by one of the node components, and the corresponding configuration task of the node component can be:

(1) Copy the binary file corresponding to the node component in the binary configuration file to a binary directory, which is generally a /usr/bin directory, which can be understood as installing a binary file corresponding to the node component;

(2) creating a startup service file corresponding to the node component, where the startup service file is used to start a service corresponding to the node component;

(3) creating a parameter file in the startup service file, wherein the parameter file is used to describe parameters such as the address of the node component, and the parameter file is configured according to the configuration file;

(4) Configure the startup service file to be booted. You can use the systemctl command to configure it. When the above (1), (2), (3), and (4) are completed, the configuration of the node component is completed.

It can be seen from the above that in the script component preset in the Ansible tool, only the steps and methods of configuring the node component can be preset. In the specific implementation, the configuration of multiple node components of the Kubernetes master node is also required according to the configuration file. After the configuration of multiple node components is completed, the configuration of the operating environment of the Kubernetes master node is completed, that is, the Kubernetes master node is set up.

As shown in the embodiment shown in FIG. 3, in the embodiment of the present application, the binary configuration file associated with the Kubernetes master node is first obtained from the binary file server, and the script component in the Ansible tool is started, so that the Ansible tool is pre-processed according to the script component. The task is to complete the installation of the binary configuration file and the configuration of the multiple node components of the Kubernetes master node. After the configuration of the multiple node components is completed, the configuration of the Kubernetes master node running environment is completed, and the Kubernetes master is improved by obtaining the binary configuration file. The convenience of the node and the automation of building the Kubernetes master node is further improved by running the preset script component.

Referring to FIG. 4, FIG. 4 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool according to Embodiment 4 of the present application. With respect to the embodiment corresponding to FIG. 3, in this embodiment, based on the Kubernetes master node including the database component, the interface service component, the control component, and the scheduling component, the S302 is refined to obtain S401~S402, which are as follows:

S401: Deploy the database component by using the Ansible tool, wherein network configuration data is obtained from the configuration file, and the network configuration data is loaded to the database component.

In the embodiment of the present application, the Kubernetes master node includes a database (Etcd) component, an interface service (Kube ApiServer) component, and a control (Kube). Controller Manager) components and scheduling (Kube Scheduler) components. To facilitate the explanation of the content of the embodiment of the present application, a schematic diagram of a Kubernetes cluster as shown in FIG. 7 is provided. In FIG. 7, the Master represents the Kubernetes master node, and the Controller The Manager represents the control component, the Scheduler represents the scheduling component, the ApiServer represents the interface service component, the Etcd represents the database component, and the lowest node represents the Kubernetes slave node. It is worth mentioning that before setting up the Kubernetes master node, that is, configuring the components under the Kubernetes master node, you need to turn off the firewall. Based on the firewall policy, minimize the network access, and the area where the main body is located and the public node where the node to be deployed is located. The network between the service areas is open.

The database component is a distributed key-value storage service that guarantees data consistency through a distributed Raft algorithm and provides a hypertext transfer protocol (HyperText). Transfer Protocol, HTTP) and JavaScript object markup language (JavaScript Object Notation, JSON) Application Programming Interface (API). In the embodiment of the present application, the database component is used for configuration management, data storage, and as a distributed lock, and the database component is deployed through the Ansible tool. Specifically, the Ansible tool obtains a binary file corresponding to the database component from the binary configuration file according to the task in the script component, copies the binary file to a binary directory, creates a startup service file of the database component, and creates the startup service file. The parameter file in the configuration file adds the network configuration data in the configuration file to the parameter file, and finally configures the startup service file to be booted. The network configuration data refers to the monitoring uniform resource locator associated with the database component in the configuration file ( Uniform Resource Locator, URL) and notification URL, etc., the listener URL is used by the database component to communicate with the Kubernetes slave node, and the URL is used for the database component to communicate with the interface service component.

S402: Deploy the interface service component, the control component, and the scheduling component in sequence, where an address of the Kubernetes master node is configured according to the configuration file.

After the database component deployment is complete, continue to deploy the interface service components. As shown in Figure 7, in the Kubernetes master node, the interface service component is responsible for data interaction with the database component. It is worth mentioning that, in addition to the interface service component, other node components of the Kubernetes master node do not directly manipulate the database component. The interface service component is the data center of the Kubernetes master node, which manages the application programming interface of the Kubernetes cluster. The process of configuring the interface service component is similar to that of the configuration database component. When the parameter file corresponding to the interface service component is configured, the service address of the interface service component and the above notification URL are extracted from the configuration file and added to the parameter file. By configuring the notification URL in the parameter file of the interface service component, the interface service component can access the database component by telling the URL, and the service address is for the convenience of the interface component and other node components except the interface service component and the database component. Data interaction.

The control component is the management and control center of the Kubernetes cluster, ensuring that the status of various resources in the Kubernetes cluster is in a normal state. When monitoring the status of a resource in the Kubernetes cluster is abnormal, the control component triggers the scheduling operation, and the control component includes the node controller. (Node Controller) and copy controller (Replication Controller). The scheduling component is responsible for orchestrating the containers in the Kubernetes cluster, and is responsible for dispatching the containers to specific Kubernetes slave nodes. The scheduling component listens to the container through the application programming interface provided by the interface service component, obtains the container to be scheduled, and sorts each Kubernetes slave node according to a preset sorting mechanism, and dispatches the container to the Kubernetes slave node of the first sort. The configuration process of the control component and the scheduling component is similar to the configuration process of the database component described above, except that when the parameter file corresponding to the control component is configured and the parameter file corresponding to the scheduling component is configured, the address of the Kubernetes master node is obtained from the configuration file. And added to the parameter file. It is worth mentioning that the control component and the scheduling component are generally located at the same node, so the address of the configured control component itself and the address of the scheduling component itself are usually the same. When the database component, interface service component, control component, and scheduling component are deployed, the Kubernetes master node is set up.

Optionally, after configuring all the node components under the Kubernetes master node, create a system domain name system (Domain Name System (DNS) service. After the DNS service is created inside the Kubernetes cluster, the domain name lookup service can be used between the containers to facilitate the construction of services between the containers.

Optionally, a dashboard is created, and the dashboard is a user interface of the Kubernetes cluster, which facilitates the user to view and operate the resources of the Kubernetes cluster through the dashboard, thereby improving the user experience.

As shown in the embodiment shown in FIG. 4, in the embodiment of the present application, the Ansible tool sequentially deploys a database component, an interface service component, a control component, and a scheduling component according to tasks in the script component, wherein the configuration file is deployed when the database component is deployed. Obtain the network configuration data, and load the network configuration data into the parameter file corresponding to the database component. When deploying the control component and the scheduling component, obtain the address of the Kubernetes master node from the configuration file, and load the address to the corresponding component of the control component. In the parameter file corresponding to the parameter file and the scheduling component, the deployment of each node component of the Kubernetes master node is performed in order, which reduces the possibility of error and improves the orderliness of building the Kubernetes master node.

Referring to FIG. 5, FIG. 5 is a flowchart of an implementation of a method for automatically setting a Kubernetes master node based on an Ansible tool according to Embodiment 5 of the present application. With respect to the embodiment corresponding to FIG. 4, the embodiment further includes:

S501: Generate a first security certificate and a second security certificate based on the configuration file, where the first security certificate is used to control access rights of the database component, and the second security certificate is used to control access rights of the interface service component. .

In the embodiment of the present application, since the database component and the interface service component often perform data interaction, in order to improve the security of the two node components, when the database component is deployed, the first security certificate and the second security are automatically generated according to the configuration file. The certificate, the first security certificate and the second security certificate are all Secure Sockets Layer (Secure Socket Layer, SSL) certificate. The first security certificate is used to control access rights of the database component, and the second security certificate is used to control access rights of the interface service component.

S502: Configure the first security certificate to the database component and the interface service component, and configure the second security certificate to the interface service component.

The first security certificate is configured into the database component and the interface service component, the configuration is completed, and the startup service file corresponding to the database component is configured to be booted, and the Kubernetes slave node and the interface service component need to perform data interaction with the database component. After verification of the first security certificate. Similarly, the second security certificate is configured into the interface service component, the configuration is completed, and the startup service file corresponding to the interface service component is configured to be booted, and the Kubernetes slave node needs to go through the data before interacting with the interface service component. Verification of the second security certificate. It is worth mentioning that step S501 and step S502 can be written in advance to the task of the Ansible tool script component to implement automatic configuration.

According to the embodiment shown in FIG. 5, in the embodiment of the present application, the first security certificate and the second security certificate are generated based on the configuration file, and the first security certificate is configured into the database component and the interface service component to control the database component. Access rights, the second security certificate is configured into the interface service component to control the access rights of the interface service component, and the security of the Kubernetes master node and the Kubernetes cluster is improved.

In another embodiment of the present application, the Kubernetes primary node and the Kubernetes cluster may be constructed based on a proprietary network. As shown in FIG. 8, a regional structure diagram based on the Kubernetes cluster is provided. First, the various structures in Figure 8 are described, the user-specific network (Virtual Private Cloud (VPC) is a user-created custom private network. Different private networks are logically isolated. Users can create and manage cloud hosts in their own private networks to implement load balancing and secure access control. VPC1 And VPC2 is a proprietary network created by different users. The available area is the area that provides specific services for the cloud platform service, including the public service area and the specific user VPC area. The ECA and SCA in Figure 8 are two instances of the available area, representing East China A and South China A respectively. The public service area is used to deploy a program or service that provides specific services for the user, and can communicate with the user VPC. The public service area includes a resource pool, the resource pool is a collection of available nodes, and the Package Server represents a binary file server, and the master1 in the resource pool. Master2 and so on represent the available nodes, while nodes in VPC1 and VPC2 are used to build Kubernetes slave nodes, and user VPCs of different users are isolated by default. The management area is a general level with respect to the higher level of the available area. The public service area can be managed by the Ansible tool, which can be understood as the above-mentioned construction main body. The Manager in the management area in Figure 8 represents the Kubernetes Manager, which is a hypervisor that can manage the Kubernetes cluster.

In addition, the DB connected to the Manager in the management area of FIG. 8 represents a database, and the etcd cluster connected to the Manager represents a database component cluster, wherein the database is used for storing data, and in FIG. 8, the database component has been set up in advance and is being managed. As a database component cluster in the zone, the Kubernetes master node is built in the available nodes of the resource pool. When multiple node components of the Kubernetes master node are deployed, if the database component is involved, only the address of the database component needs to point to the database component cluster. As shown in Figure 8, Kubernetes Manager manages multiple available nodes in the public service area by calling the Ansible tool. When you need to deploy the Kubernetes master node, Kubernetes The Manager selects the node to be deployed corresponding to the configuration file from multiple available nodes in the resource pool by using the Ansible tool, and deploys the Kubernetes master node in the node to be deployed. After the deployment is complete, the node under the user VPC can be configured as a Kubernetes slave node, and the Kubernetes cluster is formed with the Kubernetes master node. The embodiment of the present application ensures the isolation between different Kubernetes clusters by establishing a Kubernetes master node and a Kubernetes cluster under the user's proprietary network.

Corresponding to the method for automatically setting up the Kubernetes master node based on the Ansible tool according to the above embodiment, FIG. 6 is a structural block diagram of an apparatus for automatically setting up the Kubernetes master node based on the Ansible tool according to the embodiment of the present application. Referring to Figure 6, the apparatus includes:

The adding unit 61 is configured to add a creation parameter related to the Kubernetes master node input by the user to the preset configuration template, and generate a configuration file;

a determining unit 62, configured to determine, in the plurality of available nodes, a node to be deployed corresponding to the configuration file, where the available node is an available physical node or a virtual machine node;

The calling unit 63 is configured to invoke the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file.

Optionally, the determining unit 62 further includes:

a detecting unit, configured to detect whether there is a node that is constructing the Kubernetes master node or has built the Kubernetes master node among the plurality of available nodes;

An execution unit, configured to determine, if the node of the Kubernetes master node is established or the node that has built the Kubernetes master node, the plurality of available nodes are determined to be corresponding to the configuration file among the plurality of available nodes. The operation of the node to be deployed.

Optionally, the calling unit 63 includes:

An obtaining unit, configured to obtain, from a binary file server, a binary configuration file associated with the Kubernetes primary node;

a startup unit, configured to start a script component preset in the Ansible tool, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures a primary node of the Kubernetes Operating environment.

Optionally, the Kubernetes master node includes a database component, an interface service component, a control component, and a scheduling component, and the startup unit includes:

a deployment unit, configured to deploy the database component by using the Ansible tool, where network configuration data is obtained from the configuration file, and the network configuration data is loaded to the database component;

And a deployment unit, configured to sequentially deploy the interface service component, the control component, and the scheduling component, wherein the address of the Kubernetes master node is configured according to the configuration file.

Optionally, the terminal device further includes:

a certificate generating unit, configured to generate a first security certificate and a second security certificate based on the configuration file, where the first security certificate is used to control access rights of the database component, and the second security certificate is used to control the interface service Access rights to components;

And a configuration unit, configured to configure the first security certificate to the database component and the interface service component, and configure the second security certificate to the interface service component.

FIG. 9 is a schematic diagram of a terminal device according to an embodiment of the present application. As shown in FIG. 9, the terminal device 9 of this embodiment includes a processor 90 and a memory 91 in which computer readable instructions 92 executable on the processor 90 are stored, for example, based on an Ansible tool. The program to build the Kubernetes master node. When the processor 90 executes the computer readable instructions 92, the steps in the method embodiments for automatically setting up the Kubernetes master node based on the Ansible tool are implemented, for example, steps S101 to S103 shown in FIG. Alternatively, when the processor 90 executes the computer readable instructions 92, the functions of the units in the apparatus embodiment for automatically setting up the Kubernetes master node based on the Ansible tool are implemented, such as the functions of the units 61 to 63 shown in FIG. 6.

Illustratively, the computer readable instructions 92 may be partitioned into one or more modules/units that are stored in the memory 91 and executed by the processor 90, To complete this application. The one or more modules/units may be a series of computer readable instruction segments capable of performing a particular function, the instruction segments being used to describe the execution of the computer readable instructions 92 in the terminal device 9. For example, the computer readable instructions 92 may be partitioned into an add unit, a determination unit, and a call unit, each unit having a specific function as described above.

The terminal device may include, but is not limited to, a processor 90 and a memory 91. It will be understood by those skilled in the art that FIG. 9 is only an example of the terminal device 9, does not constitute a limitation of the terminal device 9, may include more or less components than those illustrated, or combine some components, or different components. For example, the terminal device may further include an input/output device, a network access device, a bus, and the like.

The so-called processor 90 can be a central processing unit (Central Processing Unit, CPU), can also be other general-purpose processors, digital signal processors (DSP), application specific integrated circuits (Application Specific Integrated Circuit (ASIC), Field-Programmable Gate Array (FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components, etc. The general purpose processor may be a microprocessor or the processor or any conventional processor or the like.

The memory 91 may be an internal storage unit of the terminal device 9, such as a hard disk or a memory of the terminal device 9. The memory 91 may also be an external storage device of the terminal device 9, for example, a plug-in hard disk equipped on the terminal device 9, a smart memory card (SMC), and a secure digital (SD). Card, flash card, etc. Further, the memory 91 may also include both an internal storage unit of the terminal device 9 and an external storage device. The memory 91 is configured to store the computer readable instructions and other programs and data required by the terminal device. The memory 91 can also be used to temporarily store data that has been output or is about to be output.

In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a standalone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application, in essence or the contribution to the prior art, or all or part of the technical solution may be embodied in the form of a software product stored in a storage medium. A number of instructions are included to cause a computer device (which may be a personal computer, server, or network device, etc.) to perform all or part of the steps of the methods described in various embodiments of the present application. The foregoing storage medium includes: a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, and the like, which can store program codes. .

The above embodiments are only used to explain the technical solutions of the present application, and are not limited thereto; although the present application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that they can still The technical solutions described in the embodiments are modified, or the equivalents of the technical features are replaced by the equivalents. The modifications and substitutions of the embodiments do not depart from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims (20)

A method for automatically setting up a Kubernetes master node based on an Ansible tool, which is characterized in that the Kubernetes master node is built by executing a preset deployment script, including: Adding a user-entered creation parameter related to the Kubernetes master node to a preset configuration template to generate a configuration file; Determining a node to be deployed corresponding to the configuration file among a plurality of available nodes, wherein the available node is an available physical node or a virtual machine node; Calling the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file. The method according to claim 1, wherein the determining, before determining the node to be deployed corresponding to the configuration file among the plurality of available nodes, further comprises: Detecting, among the plurality of available nodes, whether a node that is building the Kubernetes master node or has built the Kubernetes master node exists; If the nodes of the Kubernetes master node or the Kubernetes master node are being built, the node to be deployed corresponding to the configuration file is determined among the plurality of available nodes. operating. The method of claim 1, wherein the calling the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file comprises: Obtaining a binary configuration file associated with the Kubernetes master node from a binary file server; The script component preset in the Ansible tool is started, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures an operating environment of the Kubernetes master node. The method according to claim 3, wherein the Kubernetes master node comprises a database component, an interface service component, a control component, and a scheduling component, wherein the script component preset in the Ansible tool is started to cause the The Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures an operating environment of the Kubernetes master node, including: Deploying the database component by using the Ansible tool, wherein network configuration data is obtained from the configuration file, and the network configuration data is loaded to the database component; The interface service component, the control component, and the scheduling component are sequentially deployed, wherein an address of the Kubernetes master node is configured according to the configuration file. The method of claim 4, wherein the method further comprises: Generating a first security certificate and a second security certificate based on the configuration file, where the first security certificate is used to control access rights of the database component, and the second security certificate is used to control access rights of the interface service component; Configuring the first security certificate to the database component and the interface service component and configuring the second security certificate to the interface service component. A device for automatically setting up a Kubernetes master node based on an Ansible tool, which is characterized in that the Kubernetes master node is built by executing a preset deployment script, including: Adding a unit for adding a creation parameter related to the Kubernetes master node input by the user to a preset configuration template to generate a configuration file; a determining unit, configured to determine, in the plurality of available nodes, a node to be deployed corresponding to the configuration file, where the available node is an available physical node or a virtual machine node; a calling unit, configured to invoke an Ansible tool, and build the Kubernetes master node in the to-be-deployed node based on the configuration file. The apparatus according to claim 6, wherein the determining unit further comprises: a detecting unit, configured to detect whether there is a node that is constructing the Kubernetes master node or has built the Kubernetes master node among the plurality of available nodes; An execution unit, configured to determine, if the node of the Kubernetes master node is established or the node that has built the Kubernetes master node, the plurality of available nodes are determined to be corresponding to the configuration file among the plurality of available nodes. The operation of the node to be deployed. The device according to claim 6, wherein the calling unit comprises: An obtaining unit, configured to obtain, from a binary file server, a binary configuration file associated with the Kubernetes primary node; a startup unit, configured to start a script component preset in the Ansible tool, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures a primary node of the Kubernetes Operating environment. The device according to claim 8, wherein the Kubernetes master node comprises a database component, an interface service component, a control component, and a scheduling component, wherein the startup unit comprises: a deployment unit, configured to deploy the database component by using the Ansible tool, where network configuration data is obtained from the configuration file, and the network configuration data is loaded to the database component; And a deployment unit, configured to sequentially deploy the interface service component, the control component, and the scheduling component, wherein the address of the Kubernetes master node is configured according to the configuration file. The device of claim 9 further comprising: a certificate generating unit, configured to generate a first security certificate and a second security certificate based on the configuration file, where the first security certificate is used to control access rights of the database component, and the second security certificate is used to control the interface service Access rights to components; And a configuration unit, configured to configure the first security certificate to the database component and the interface service component, and configure the second security certificate to the interface service component. A terminal device, comprising: a memory and a processor, wherein the memory stores computer readable instructions executable on the processor, and the processor implements the following steps when the computer readable instructions are executed : Adding a user-entered creation parameter related to the Kubernetes master node to a preset configuration template to generate a configuration file; Determining a node to be deployed corresponding to the configuration file among a plurality of available nodes, wherein the available node is an available physical node or a virtual machine node; Calling the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file. The terminal device according to claim 11, wherein before determining the node to be deployed corresponding to the configuration file among the plurality of available nodes, the method further includes: Detecting, among the plurality of available nodes, whether a node that is building the Kubernetes master node or has built the Kubernetes master node exists; If the nodes of the Kubernetes master node or the Kubernetes master node are being built, the node to be deployed corresponding to the configuration file is determined among the plurality of available nodes. operating. The terminal device according to claim 11, wherein the calling the Ansible tool to build the Kubernetes master node in the node to be deployed based on the configuration file comprises: Obtaining a binary configuration file associated with the Kubernetes master node from a binary file server; The script component preset in the Ansible tool is started, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures an operating environment of the Kubernetes master node. The terminal device according to claim 13, wherein the Kubernetes master node comprises a database component, an interface service component, a control component, and a scheduling component, wherein the script component preset in the Ansible tool is started to make The Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures an operating environment of the Kubernetes master node, including: Deploying the database component by using the Ansible tool, wherein network configuration data is obtained from the configuration file, and the network configuration data is loaded to the database component; The interface service component, the control component, and the scheduling component are sequentially deployed, wherein an address of the Kubernetes master node is configured according to the configuration file. The terminal device according to claim 14, further comprising: Generating a first security certificate and a second security certificate based on the configuration file, where the first security certificate is used to control access rights of the database component, and the second security certificate is used to control access rights of the interface service component; Configuring the first security certificate to the database component and the interface service component and configuring the second security certificate to the interface service component. A computer readable storage medium storing computer readable instructions, wherein the computer readable instructions, when executed by at least one processor, implement the following steps: Adding a user-entered creation parameter related to the Kubernetes master node to a preset configuration template to generate a configuration file; Determining a node to be deployed corresponding to the configuration file among a plurality of available nodes, wherein the available node is an available physical node or a virtual machine node; Calling the Ansible tool to build the Kubernetes master node in the to-be-deployed node based on the configuration file. The computer readable storage medium of claim 16, wherein the computer readable instructions are further executed by the at least one processor to: Detecting, among the plurality of available nodes, whether a node that is building the Kubernetes master node or has built the Kubernetes master node exists; If the nodes of the Kubernetes master node or the Kubernetes master node are being built, the node to be deployed corresponding to the configuration file is determined among the plurality of available nodes. operating. The computer readable storage medium of claim 16, wherein the computer readable instructions are executed by at least one processor to implement the following steps: Obtaining a binary configuration file associated with the Kubernetes master node from a binary file server; The script component preset in the Ansible tool is started, so that the Ansible tool installs the binary configuration file in the node to be deployed according to the script component, and configures an operating environment of the Kubernetes master node. The computer readable storage medium of claim 18, the Kubernetes master node comprising a database component, an interface service component, a control component, and a scheduling component, wherein the computer readable instructions are implemented by at least one processor The following steps: Deploying the database component by using the Ansible tool, wherein network configuration data is obtained from the configuration file, and the network configuration data is loaded to the database component; The interface service component, the control component, and the scheduling component are sequentially deployed, wherein an address of the Kubernetes master node is configured according to the configuration file. A computer readable storage medium according to claim 19, wherein said computer readable instructions, when executed by at least one processor, further implement the following steps: Generating a first security certificate and a second security certificate based on the configuration file, where the first security certificate is used to control access rights of the database component, and the second security certificate is used to control access rights of the interface service component; Configuring the first security certificate to the database component and the interface service component and configuring the second security certificate to the interface service component.