WO2019184116A1

WO2019184116A1 - Method and device for automatically building kubernetes main node, terminal device and computer-readable storage medium

Info

Publication number: WO2019184116A1
Application number: PCT/CN2018/093710
Authority: WO
Inventors: 邓志弘
Original assignee: 平安科技（深圳）有限公司
Priority date: 2018-03-30
Filing date: 2018-06-29
Publication date: 2019-10-03
Also published as: CN108536519B; CN108536519A

Abstract

The present solution is applicable to the technical field of data processing, and provided thereby are a method for automatically building a Kubernetes main node, a terminal device and a computer-readable storage medium, the method comprising: acquiring a preset script file used for building the Kubernetes main node; executing the script file, so as to generate a configuration file according to creation parameters which are inputted by a user and are related to the Kubernetes main node; and starting a SaltStack tool, so as to build the Kubernetes main node according to the configuration file. The present solution achieves automatic building of a Kubernetes main node and improves building efficiency for the Kubernetes main node.

Description

Method, device, terminal device and readable storage medium for automatically setting up Kubernetes master node

This application claims the priority of the Chinese Patent Application filed on March 31, 2018, the Chinese Patent Office, Application No. 201810276602.8, entitled "Method and Terminal Device for Automatically Establishing Kubernetes Master Node", the entire contents of which are incorporated by reference. In this application.

Technical field

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

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. One application runs inside each container, and different containers are isolated from each other, but a communication mechanism can be established between the containers. Docker container technology allows several containers to run on the same host or virtual machine, each of which is a separate virtual environment or application.

In general, you need to use tools to control the container. Kubernetes is an open source container operation platform that can realize the functions of combining containers into one service and dynamically allocating the host running the container, which provides great convenience for users to use the container. Generally speaking, the Kubernetes cluster includes two types of nodes: the master node and the slave node. The master node is responsible for the management and scheduling of all resources in the Kubernetes cluster. Therefore, to use Kubernetes, the master node needs to be built first. However, in the prior art, the Kubernetes master node is manually built by the user, and the construction process relies on the Internet service, and the construction efficiency and applicability are low.

technical problem

In view of this, the embodiment of the present application provides a method, a device, a terminal device, and a computer readable storage medium for automatically setting up a Kubernetes master node, so as to solve the problem that the prior art needs to manually build a Kubernetes master node, and build efficiency and applicability. Low problem.

Technical solution

A first aspect of the embodiments of the present application provides a method for automatically setting up a Kubernetes master node, including:

Obtain the default script file used to build the Kubernetes master node;

Executing the script file to generate a configuration file according to a creation parameter input by the user related to the Kubernetes master node;

Start the SaltStack tool to build the Kubernetes master node according to the configuration file.

A second aspect of the embodiments of the present application provides an apparatus for automatically setting up a Kubernetes master node, which may include a unit for implementing the steps of the above method of automatically setting up a Kubernetes master node.

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 of automatically setting up the Kubernetes master node 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, the computer readable instructions being implemented by a processor to implement the above-mentioned automatic establishment of a Kubernetes master node The steps of the method.

Beneficial effect

The embodiment of the present application obtains a preset script file for setting up a Kubernetes master node, and executes a preset script file to generate a configuration file according to a creation parameter related to the Kubernetes master node input by the user, and finally starts the SaltStack. The tool, under the control of the SaltStack tool, automatically constructs the Kubernetes master node according to the configuration file, realizes the automatic establishment of the Kubernetes master node, and does not need to rely on the Internet service, thereby improving the building efficiency and the applicability to the construction environment.

DRAWINGS

1 is a flowchart of an implementation of a method for automatically setting up a Kubernetes master node in the first embodiment of the present application;

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

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

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

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

6 is a structural block diagram of an apparatus for automatically setting up a Kubernetes master node 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 according to an embodiment of the present application. As shown in Figure 1, the method includes the following steps:

S101: Obtain a preset script file for setting up a Kubernetes master node.

In the embodiment of the present application, the Kubernetes master node is mainly built by the SaltStack tool. First, the preset script file for setting up the Kubernetes master node is obtained. For convenience of description, the Kubernetes and Kubernetes master nodes are introduced. Kubernetes is an open source platform for automated container operations. It enables the deployment, scheduling, and inter-cluster expansion of containers. The physical server or virtual machine on which the Kubernetes platform is installed 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 also includes multiple subordinate objects of the Kubernetes master node, namely the Kubernetes Node, which is used to actually run the container allocated by the Kubernetes master node.

For the construction process, compared with the traditional manual programming of the Kubernetes master node, in the embodiment of the present application, the Kubernetes master node is mainly built by the script file, and the script file is a determined series of control computer operations. Combination, in which logical branches can be implemented, and script files can be written in Shell language or the like.

Optionally, after receiving the construction instruction of the user about the Kubernetes master node, acquiring the script file stored on the file server PackageServer. In the embodiment of the present application, the user may be provided with a setup option for setting up a Kubernetes master node, and the setup option may be presented to the user in the form of a graphical interface or a command line, and the obtained confirmation result of the user is obtained. After the user builds the instruction, the operation of acquiring the script file is performed. In addition, the script file can be placed in the file server PackageServer after the pre-setting is completed. The PackageServer is a high-speed download server, which can be used to place various binary files and script files, and the contents thereof are usually fixed, so it can be applied in this application. In the embodiment, the real-time and reliability of the script file acquisition is improved. On this basis, because the Kubernetes platform is suitable for different operating systems, such as Windows, Linux, etc., and under different environments, the underlying build code has a certain degree of difference, so it can be written for multiple operating systems. Script file and place multiple script files in the PackageServer. After receiving the setup instruction about the Kubernetes master node issued by the user through the terminal device, identifying the operating system of the terminal device and obtaining the package The script file corresponding to the operating system of the terminal device stored on the server prevents the obtained script file from matching the running environment and cannot be executed.

S102: execute the script file to generate a configuration file according to a creation parameter input by the user related to the Kubernetes master node.

After obtaining the preset script file, the script file is executed, and the creation parameters related to the Kubernetes master node are obtained during the execution of the script file, and some of the creation parameters such as the version number of the Kubernetes master node are automatically acquired, and another part is automatically acquired. Creating parameters such as log file paths, etc., requires detecting user input and looking up the contents of the log file path from the user's input. The creation parameters related to the Kubernetes master node include the attribute parameters of the Kubernetes master node, such as the installation version, the Internet Protocol address of the Kubernetes master node, the host identifier (name) of the Kubernetes master node, and the area identifier, etc., and also constitute the Kubernetes master. Attribute parameters of each component of the node, etc. After the creation parameters entered by the user are obtained, the script file generates a configuration file according to the creation parameters. The configuration file is written in script language. It is similar to the script file. For the convenience of description, the configuration file can be named as the deployment script. In the subsequent steps, the configuration file is executed to build the Kubernetes master node through the SaltStack tool.

Optionally, an input template is generated according to each type of the creation parameter related to the Kubernetes master node, and a creation parameter input by the user through the input template is obtained. Since each type of the created parameter is determined, an input template can be generated according to the type of the created parameter, and the input template includes the names of the various types of the created parameters, so that the user can input the content corresponding to each type of name, and the error of creating the parameter input is reduced. may. In addition, the input template can also be configured in the script file. When the creation parameters need to be obtained, the script file is executed, and the input template is automatically provided to the user.

S103: Start a SaltStack tool to build the Kubernetes master node according to the configuration file.

In the past, tools such as kops were able to build the main node of Kubernetes, but in the specific construction process, users need to write code to complete the configuration of the Internet Protocol address of the main node such as Kubernetes. Therefore, in the embodiment of the present application, the Kubernetes master node is built by using the SaltStack tool. It should be noted that the SaltStack tool is an open source infrastructure management tool, which is divided into two parts: the management master node (SaltMaster) and the management slave node (SaltMinion). Similar to the relationship between the Kubernetes master node and the Kubernetes slave node, the management master node of the SaltStack tool mainly manages the management slave nodes, and the management slave nodes run on the physical servers or virtual machines that need to be managed, and execute the management master node transmission. Instructions, and build the main Kubernetes node according to the configuration file, the specific process will be explained later.

According to the embodiment shown in FIG. 1 , in the embodiment of the present application, the script file can be stored in the file server PackageServer and obtain the creation related to the Kubernetes master node by acquiring a preset script file for setting up the Kubernetes master node. After executing the script file, generate the configuration file corresponding to the created parameter, and finally start the SaltStack tool. Specifically, through the management master node and the management slave node in the SaltStack tool, the Kubernetes master node is built according to the configuration file, and the Kubernetes master node is implemented. Automated construction reduces user operations and improves construction efficiency.

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

S201: Configure a management master node and a plurality of management slave nodes under the SaltStack tool, wherein the management master node is connected to the plurality of management slave nodes.

The SaltStack tool applies a client/server architecture that enables remote command execution and configuration management. The SaltStack tool includes a management master node and multiple management slave nodes. The management master node is equivalent to the SaltStack tool server. It is responsible for resource management. The multiple management slave nodes are equivalent to the SaltStack tool client, and are responsible for executing the instructions issued by the management master node. . In this embodiment, an area that provides a specific service for a user is referred to as an available area, and the inside of the available area is specifically divided into a resource management area and a public service area, wherein the resource management area is used to deploy a resource management related program and A component that can access a physical server or virtual machine in a public service area, which is equivalent to a server in a client/server architecture. Therefore, the management master node runs in the resource management area; the public service area is used to deploy a program or service that provides a specific service to the user. , equivalent to the client in the client/server architecture, so the management slave node is installed in the public service area. After the SaltStack tool is started, the management master node and the plurality of management slave nodes are automatically configured. When the management slave node starts, the private key and the public key are generated according to the encryption algorithm, and after the generation is completed, the public key is sent to the management master node. The management master node verifies and accepts the public key to establish a connection with the management slave node. It is worth mentioning that the management master node and the management slave node pass the message through the message queue ZeroMQ, that is, the management master node posts the message to the message queue ZeroMQ, and the management slave node obtains the message by subscribing to the message queue ZeroMQ.

S202: Call the management master node, so that one of the plurality of management slave nodes constructs the Kubernetes master node according to the configuration file.

After the management master node and multiple management slave nodes under the SaltStack tool are configured, the SaltStack tool calls the management master node, and the management master node selects one of the plurality of management slave nodes, and the selected management slave node receives the setup instructions, according to the configuration. The file is built on the Kubernetes master node, which essentially builds the Kubernetes master node on the physical server or virtual machine where the management slave node is located.

According to the embodiment shown in FIG. 2, in the embodiment of the present application, by configuring the management master node and the plurality of management slave nodes under the SaltStack tool, the management master node and the plurality of management slave nodes are connected, and the communication is realized through the message queue ZeroMQ. And call the management master node, so that the management master node selects one of the plurality of management slave nodes, and builds the Kubernetes master node according to the configuration file under the selected management slave node, which embodies the specific process of setting up the Kubernetes master node through the SaltStack tool, and improves The stability of building the main Kubernetes node.

Referring to FIG. 3, FIG. 3 is a flowchart of an implementation of a method for automatically setting up a Kubernetes master node according to Embodiment 3 of the present application. With respect to the embodiment corresponding to FIG. 2, in this embodiment, S202 is refined to obtain S301~S303, which are as follows:

S301: Detect whether the Kubernetes master node exists under the multiple management slave nodes.

Since the creation parameters are related to the Kubernetes master node, after the SaltStack tool is started and the management master node and the plurality of management slave nodes are configured, the management master node searches for multiple management slave nodes connected thereto to find out whether there is a corresponding parameter corresponding to the creation parameter. The main node of Kubernetes.

S302: If the Kubernetes master node does not exist under the multiple management slave nodes, select a management slave node corresponding to the creation parameter from the multiple management slave nodes as a slave node.

If the Kubernetes master node is not found under all management slave nodes, it proves that the Kubernetes master node has not been created. It is worth mentioning that, in the embodiment of the present application, the Kubernetes master node is built under the management slave node, so in step S102, the acquired creation parameters related to the Kubernetes master node also include the user-configured management slave node correlation. The parameters, then in this step, the corresponding management slave node can be selected from the plurality of management slave nodes according to the creation parameters, as a slave node. If it is detected that the creation parameter does not include a parameter related to the management slave node, one of the plurality of management slave nodes may be randomly selected as a slave node, or may be performed in multiple management slave nodes according to a preset selection mechanism. select.

S303: Build the Kubernetes master node according to the configuration file under the setup slave node.

After the slave node is selected, the Kubernetes master node is built according to the configuration file under the setup slave node. In addition, a flag can be set for the setup slave node, and a flag stamp can be set for the setup slave node to prove that the setup slave node has been used to create a Kubernetes master node. After the flag stamp setting is completed, if the new Kubernetes master node is set again, then when the operation of step S301 is performed, that is, whether there is a Kubernetes master node under the plurality of management slave nodes, whether there is a mark stamp according to the management slave node To determine whether the management slave node has been used to create a Kubernetes master node, improving detection efficiency.

It can be seen from the embodiment shown in FIG. 3 that in the embodiment of the present application, by detecting whether there is a Kubernetes master node under multiple management slave nodes, resource waste caused by repeated construction is prevented.

Please refer to FIG. 4. FIG. 4 is a flowchart of an implementation of a method for automatically setting up a Kubernetes master node according to Embodiment 4 of the present application. With respect to the embodiment corresponding to FIG. 1, 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 S103 is refined to obtain S401~S402, which are as follows:

S401: Deploy the database component by using the SaltStack tool, and obtain network configuration data related to the creation parameter, and load the network configuration data 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). The Controller Manager component and the Kube Scheduler component provide a schematic diagram of a Kubernetes cluster as shown in FIG. 7 for facilitating the explanation of the content of the embodiment of the present application. 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, configuring the components under the Kubernetes master node, shutting down the firewall, and minimizing the network access based on the firewall policy, that is, managing the resource management area where the master node is located and the management slave node. The network between the public service areas is open.

The database component, the Etcd component, is a distributed key-value storage service that guarantees data consistency through a distributed Raft algorithm and provides Hypertext Transfer Protocol (HTTP) and 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, which can be deployed through the SaltStack tool, specifically, the management slave node is configured according to The file configuration database component obtains the database component configuration file from the file server through the configuration file. The database component configuration file is a binary file, which is used to configure the database component service, and the configuration content also includes the database name and the data path. After the database component is configured, obtain the network configuration data related to the creation parameters and load the network configuration data into the database component. The network configuration data may be obtained by presetting a network configuration template in the script file, and extracting the content related to the network configuration data in the creation parameter when the parameter is created, and adding the content to the network configuration template, thereby Obtained directly from the network configuration template when network configuration data is required. When a Kubernetes slave node is added, and the node to be joined sends a request to the database component, the database component can identify the node to be joined as a Kubernetes slave node according to the network configuration data.

S402: Deploy the interface service component, the control component, and the scheduling component in sequence, and modify a service address of the interface service component.

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 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. It is mentioned in step S102 that the configuration file is essentially a script file written by the scripting language. Therefore, in this step, the interface service configuration file in the file server is automatically extracted according to the configuration file, and the interface service component is performed according to the interface service configuration file. Configuration. In addition, the creation parameter input by the user includes the database component address and the interface service address, and the configuration file is generated by the creation parameter, so in the step, the database component address and the interface service component address are also configured in the interface service component through the configuration file, wherein the database The component address is the address of the database service in the database component, and the database component address is configured in the interface service component to enable the interface service component to access the database component through the database component address; the interface service component address is the local address of the interface service component. It is worth mentioning that the interface service component includes two types of communication interfaces, one is used to provide an interface for Kubernetes slave nodes to access database components, and needs to be authenticated by a security certificate. The specific content is introduced later; It is an interface for data interaction with the scheduling component and the control component. This interface is the internal interface of the component and does not require permission authentication.

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 control component configuration file and the scheduling component configuration file are obtained from the file server through the configuration file, and the control component configuration file and the scheduling component configuration file are all binary files, wherein the control component configuration file is used to configure the control component related services, and the component configuration is scheduled. Files are used to configure the scheduling component. The configuration process also includes setting environment variables, including control component and version environment variables of the scheduling component. The environment variables are determined by the creation parameters input by the user, and the environment variables are automatically configured in the control component and the scheduling component through the configuration file. In addition, the service address of the interface service component is automatically modified according to the configuration file, so that the control component and the scheduling component can respectively perform data interaction with the interface service component, wherein the service address refers to an address that the interface service component provides the service to. After configuring all the components under the Kubernetes master node, you can create the Domain Name System (DNS) service, which is kube-dns, which is responsible for creating DNS services inside the Kubernetes cluster, so that the containers can be searched through the domain name. It is convenient to build services between containers. Optionally, a dashboard is created, and the dashboard is a user interface of the Kubernetes cluster, which is convenient for the user to view and operate the resources of the Kubernetes cluster through the dashboard.

As shown in the embodiment shown in FIG. 4, in the embodiment of the present application, the Kubernetes master node includes a database component, an interface service component, a control component, and a scheduling component, deploys a database component through the SaltStack tool, and acquires and creates parameters from the network configuration template. Related network configuration data, loading network configuration data into the database component, after the database component configuration is completed, sequentially deploying the interface service component, the control component, and the scheduling component, and modifying the service address of the interface service component, so as to facilitate the control component and the scheduling component Data interaction with the interface service component alone reflects the deployment process of each component under the Kubernetes master node, which improves the automation of component configuration.

Referring to FIG. 5, FIG. 5 is a flowchart of an implementation of a method for automatically setting up a Kubernetes master node according to Embodiment 5 of the present application. With respect to the embodiment corresponding to FIG. 4, in this embodiment, S401 is refined to obtain S501~S502, which are as follows:

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

Since the database component and the interface service component often perform data interaction, in order to improve the security of the above two components, when the database component is deployed, the first security certificate and the second security certificate are automatically generated according to the configuration file, and the first security certificate and the first security certificate are The second security certificate is the Secure Sockets Layer (Secure Socket Layer, SSL) certificate. The first security certificate is used to control access rights to the database component, and the second security certificate is used to control access rights to 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.

After the first security certificate is configured into the database component and the interface service component, after the configuration and startup of the database component service, the Kubernetes slave node and the interface service component need to be verified by the first security certificate before performing data interaction with the database component. The second security certificate is configured into the interface service component. After the interface service component service is started, the Kubernetes slave node needs to be verified by the second security certificate before performing data interaction with the interface service component.

The embodiment shown in FIG. 5 shows that, in the embodiment of the present application, when the database component is deployed, the first security certificate and the second security certificate are generated, and the first security certificate is configured to the database component and the interface service component, and is used for Controls the access rights of Kubernetes from the node and interface service components to the database components, configures the second security certificate to the interface service component, controls the access rights of the Kubernetes slave node to the interface service component, and improves the access of the database component and the interface service component. safety.

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 includes the resource management area and the public service area, and the specific user VPC area, which provides specific services for the cloud platform service. The ECA and SCA in Figure 8 are two instances of the available area, representing East China and South China respectively. District A. As mentioned above, the resource management area is used to deploy resource management related programs and components, and can access physical servers or virtual machines in the public service area, and the public service area is used to deploy programs or services that provide specific services to users. The user VPC communicates with each other. The public service area contains the resource pool. The resource pool is a collection of physical servers or virtual machines that can be run. The Package Server represents the file server. The master1 and master2 in the resource pool represent the Kubernetes master node, and the VPC1 and VPC2. Node represents the Kubernetes slave node, and the default user isolation between user VPCs of different users. The management area is a general level with respect to the higher level of the available area. It can open and manage the resource management area and the public service area of all available areas. The Manager in the management area in Figure 8 represents Kubernetes. Manager is a hypervisor that can manage Kubernetes clusters.

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 cluster of database components. Among them, the database is used to store data, and the database component cluster as a distributed lock guarantees consistency. Kubernetes The Manager manages the physical server or virtual machine of the public service area by calling the management master node of the resource management area. There are multiple management slave nodes in the resource pool of the public service area, when Kubernetes When the Manager deploys the Kubernetes master node, the available management slave nodes are selected from the plurality of management slave nodes of the resource pool, and the Kubernetes master node is deployed on the management slave node. After the deployment is complete, the node under the user VPC acts as a Kubernetes slave node and forms a Kubernetes cluster 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 a method for automatically setting up a Kubernetes master node according to the above embodiment, FIG. 6 is a structural block diagram of an apparatus for automatically setting up a Kubernetes master node according to an embodiment of the present application. Referring to FIG. 6, the device is provided. include:

The first obtaining unit 61 is configured to acquire a preset script file for setting up a Kubernetes master node;

a second obtaining unit 62, configured to execute the script file to generate a configuration file according to a creation parameter input by the user related to the Kubernetes master node;

The building unit 63 is configured to start the SaltStack tool to construct the Kubernetes master node according to the configuration file.

Optionally, the building unit 63 includes:

a node configuration unit, configured to configure a management master node and a plurality of management slave nodes under the SaltStack tool, wherein the management master node is connected to the plurality of management slave nodes;

And a calling unit, configured to invoke the management master node, so that one of the plurality of management slave nodes constructs the Kubernetes master node according to the configuration file.

Optionally, the calling unit includes:

a detecting unit, configured to detect whether the Kubernetes master node exists under the plurality of management slave nodes;

a selecting unit, configured to: if the Kubernetes master node does not exist under the plurality of management slave nodes, select a management slave node corresponding to the creation parameter from the plurality of management slave nodes as a slave node;

And establishing a subunit, configured to build the Kubernetes master node according to the configuration file under the setup slave node.

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

a deployment unit, configured to deploy the database component by using the SaltStack tool, and obtain network configuration data related to the creation parameter, and load the network configuration data into the database component;

And sequentially deploying units for sequentially deploying the interface service component, the control component, and the scheduling component, and modifying a service address of the interface service component.

Optionally, the deployment unit further includes:

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

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, a Kubernetes master node is built. program of. When the processor 90 executes the computer readable instructions 92, the steps in the method embodiments of the foregoing automatic establishment of the Kubernetes master node are implemented, for example, steps S101 to S103 shown in FIG. Alternatively, the processor 90, when executing the computer readable instructions 92, implements the functions of the various units of the apparatus embodiments described above, such as the functions of the units 61-63 shown in FIG.

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 can be segmented into a first acquisition unit, a second acquisition unit, and a construction 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

A method for automatically setting up a Kubernetes master node, which comprises:

Obtain the default script file used to build the Kubernetes master node;

Executing the script file to generate a configuration file according to a creation parameter input by the user related to the Kubernetes master node;

Start the SaltStack tool to build the Kubernetes master node according to the configuration file.
The method of claim 1, wherein the launching the SaltStack tool to construct the Kubernetes master node according to the configuration file comprises:

Configuring a management master node and a plurality of management slave nodes under the SaltStack tool, wherein the management master node is connected to the plurality of management slave nodes;

And calling the management master node, so that one of the plurality of management slave nodes constructs the Kubernetes master node according to the configuration file.
The method of claim 2, wherein the invoking the management master node to cause one of the plurality of management slave nodes to construct the Kubernetes master node according to the configuration file comprises:

Detecting whether the Kubernetes master node exists under the plurality of management slave nodes;

If the Kubernetes master node does not exist under the plurality of management slave nodes, selecting a management slave node corresponding to the creation parameter from the plurality of management slave nodes as a slave node;

Constructing the Kubernetes master node according to the configuration file under the setup slave node.
The method of claim 1, wherein the Kubernetes master node comprises a database component, an interface service component, a control component, and a scheduling component, wherein the launching the SaltStack tool to construct the Kubernetes master node according to the configuration file ,include:

Deploying the database component by using the SaltStack tool, and acquiring network configuration data related to the creation parameter, loading the network configuration data to the database component;

The interface service component, the control component, and the scheduling component are deployed in sequence, and the service address of the interface service component is modified.
The method of claim 4, wherein the deploying the database component by the SaltStack tool further comprises:

Generating a first security certificate and a second security certificate according to the configuration file, where the first security certificate is used to control access rights to the database component, and the second security certificate is used to control access rights to 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, comprising:

a first acquiring unit, configured to acquire a preset script file used to build a Kubernetes master node;

a second acquiring unit, configured to execute the script file, to generate a configuration file according to a creation parameter input by the user related to the Kubernetes primary node;

A building unit is configured to start the SaltStack tool to construct the Kubernetes master node according to the configuration file.
The device of claim 6, wherein the building unit further comprises:

a node configuration unit, configured to configure a management master node and a plurality of management slave nodes under the SaltStack tool, wherein the management master node is connected to the plurality of management slave nodes;

And a calling unit, configured to invoke the management master node, so that one of the plurality of management slave nodes constructs the Kubernetes master node according to the configuration file.
The device according to claim 7, wherein the calling unit comprises:

a detecting unit, configured to detect whether the Kubernetes master node exists under the plurality of management slave nodes;

a selecting unit, configured to: if the Kubernetes master node does not exist under the plurality of management slave nodes, select a management slave node corresponding to the creation parameter from the plurality of management slave nodes as a slave node;

And establishing a subunit, configured to build the Kubernetes master node according to the configuration file under the setup slave node.
The device of claim 6, wherein the Kubernetes master node comprises a database component, an interface service component, a control component, and a scheduling component, wherein the building unit comprises:

a deployment unit, configured to deploy the database component by using the SaltStack tool, and obtain network configuration data related to the creation parameter, and load the network configuration data into the database component;

And sequentially deploying units for sequentially deploying the interface service component, the control component, and the scheduling component, and modifying a service address of the interface service component.
The device according to claim 9, wherein the deployment unit further comprises:

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

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 :

Obtain the default script file used to build the Kubernetes master node;

Executing the script file to generate a configuration file according to a creation parameter input by the user related to the Kubernetes master node;

Start the SaltStack tool to build the Kubernetes master node according to the configuration file.
The terminal device according to claim 11, wherein the starting the SaltStack tool to construct the Kubernetes master node according to the configuration file comprises:

Configuring a management master node and a plurality of management slave nodes under the SaltStack tool, wherein the management master node is connected to the plurality of management slave nodes;

And calling the management master node, so that one of the plurality of management slave nodes constructs the Kubernetes master node according to the configuration file.
The terminal device according to claim 12, wherein the calling the management master node to enable one of the plurality of management slave nodes to construct the Kubernetes master node according to the configuration file comprises:

Detecting whether the Kubernetes master node exists under the plurality of management slave nodes;

If the Kubernetes master node does not exist under the plurality of management slave nodes, selecting a management slave node corresponding to the creation parameter from the plurality of management slave nodes as a slave node;

Constructing the Kubernetes master node according to the configuration file under the setup slave node.
The terminal device according to claim 11, wherein the Kubernetes master node comprises a database component, an interface service component, a control component, and a scheduling component, wherein the launching the SaltStack tool to construct the Kubernetes master according to the configuration file Nodes, including:

Deploying the database component by using the SaltStack tool, and acquiring network configuration data related to the creation parameter, loading the network configuration data to the database component;

The interface service component, the control component, and the scheduling component are deployed in sequence, and the service address of the interface service component is modified.
The terminal device according to claim 14, wherein the deploying the database component by using the SaltStack tool further includes:

Generating a first security certificate and a second security certificate according to the configuration file, where the first security certificate is used to control access rights to the database component, and the second security certificate is used to control access rights to 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:

Obtain the default script file used to build the Kubernetes master node;

Executing the script file to generate a configuration file according to a creation parameter input by the user related to the Kubernetes master node;

Start the SaltStack tool to build the Kubernetes master node according to the configuration file.
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:

Configuring a management master node and a plurality of management slave nodes under the SaltStack tool, wherein the management master node is connected to the plurality of management slave nodes;

And calling the management master node, so that one of the plurality of management slave nodes constructs the Kubernetes master node according to the configuration file.
The computer readable storage medium of claim 17, wherein the computer readable instructions are executed by at least one processor to implement the following steps:

Detecting whether the Kubernetes master node exists under the plurality of management slave nodes;

If the Kubernetes master node does not exist under the plurality of management slave nodes, selecting a management slave node corresponding to the creation parameter from the plurality of management slave nodes as a slave node;

Constructing the Kubernetes master node according to the configuration file under the setup slave node.
The computer readable storage medium of claim 16, 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 SaltStack tool, and acquiring network configuration data related to the creation parameter, loading the network configuration data to the database component;

The interface service component, the control component, and the scheduling component are deployed in sequence, and the service address of the interface service component is modified.
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 according to the configuration file, where the first security certificate is used to control access rights to the database component, and the second security certificate is used to control access rights to 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.