Cloud native operating system experiment platform building method and device and storage medium

Abstract

The invention relates to the technical field of computers, and provides a cloud native operating system experiment platform building method and device and a storage medium, which are applied to a server cluster, the server cluster comprises a plurality of servers, and each server comprises a plurality of preset credential processors and an operating system corresponding to the preset credential processors. And obtaining configuration requirements of the server. And according to the configuration requirement and a preset configuration requirement, deploying a Kubernetes application on the server, and constructing a Kubernetes cluster. The method comprises the following steps of: aiming at a Kubernetes cluster, creating and running a plurality of Qemu virtual machines on the Kubernetes cluster through a Kubernetes extension tool. The preset credential processor, the operating system, the Kubernetes application and the Qemu virtual machine support the same preset instruction set. When the experiment is carried out, the instruction among the preset credential processor, the operating system, the Kubernetes application and the Qemu virtual machine does not need to be translated, so that the performance loss of the operating system experiment platform in the experiment process is reduced.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method, device and storage medium for building a cloud native operating system experimental platform. Background Art

[0002] Xinchuang, or the information technology application innovation industry, refers to my country's independently innovative information technology and industry, mainly referring to the independently innovative technologies of the IT industry chain, such as operating systems, servers, databases, and middleware. It is mainly driven by industry applications to build a domestic information technology software and hardware underlying architecture system and a full-cycle ecosystem, laying a solid digital foundation for the future development of science and technology. The goal of Xinchuang is to achieve independent control, so that there are more choices in technology for the world's leading information technology products, and to control key technologies from being locked in by foreign companies.

[0003] In the existing technology, the operating system experimental platforms for the information and innovation industry currently mostly rely on foreign hardware equipment and software systems. During the experiment process of the operating system experimental platform, there is a problem of performance loss. Summary of the invention

[0004] Based on this, it is necessary to provide a method, device and storage medium for building a cloud native operating system experimental platform for the above-mentioned technical problems. Applied to a server cluster, the server cluster includes multiple servers, and the server includes multiple preset trusted processors and an operating system corresponding to the preset trusted processor to obtain the configuration requirements of the server. According to the configuration requirements and the preset configuration requirements, the Kubernetes application is deployed on the server to build a Kubernetes cluster. For the Kubernetes cluster, multiple Qemu virtual machines are created and run on the Kubernetes cluster through the Kubernetes extension tool. Because the preset trusted processor, operating system, Kubernetes application and Qemu virtual machine support the same preset instruction set. When conducting experiments, there is no need to translate the instructions between the preset trusted processor, operating system, Kubernetes application and Qemu virtual machine, thereby reducing the performance loss of the operating system experimental platform during the experiment.

[0005] In a first aspect, an embodiment of the present invention provides a method for building a cloud native operating system experimental platform, which is applied to a server cluster, wherein the server cluster includes multiple servers, and the servers include multiple preset trusted processors and an operating system corresponding to the preset trusted processors. The method includes:

[0006] Obtaining configuration requirements of the server;

[0007] According to the configuration requirements and preset configuration requirements, deploy the Kubernetes application on the server to build a Kubernetes cluster;

[0008] For the Kubernetes cluster, using the Kubernetes extension tool, create and run multiple Qemu virtual machines on the Kubernetes cluster;

[0009] Among them, the preset trusted computing processor, the operating system, the Kubernetes application and the Qemu virtual machine support the same preset instruction set.

[0010] In one embodiment, deploying the Kubernetes application on the server to build a Kubernetes cluster according to the configuration requirements and preset configuration requirements includes:

[0011] Determining whether the configuration requirement meets the preset configuration requirement, wherein the configuration requirement includes: attribute identification information, memory size, and network connection status of the server;

[0012] If yes, deploy the Kubernetes application on the server.

[0013] In one embodiment, the operation mode of the Qemu virtual machine includes a normal operation mode and a debugging operation mode, and the Kubernetes cluster is created and operated on the Kubernetes cluster by using a Kubernetes extension tool, and the Qemu virtual machine is also created and operated on the Kubernetes cluster.

[0014] The initial Kubernetes extension tool is customized for the debugging operation mode of the Qemu virtual machine.

[0015] In one embodiment, the debugging operation mode of the Qemu virtual machine is customized to the initial Kubernetes extension tool, including:

[0016] Obtain multiple source codes of the Kubernetes extension tool;

[0017] Determining an initial source code related to the debugging operation mode from among the plurality of source codes;

[0018] According to the debugging operation mode, a preset source code is added to the initial source code, wherein the preset source code includes a preset instruction, and the preset instruction is used to instruct to start the debugging operation mode.

[0019] In one embodiment, the method further comprises:

[0020] For multiple Qemu virtual machines created and running on the Kubernetes cluster, a corresponding persistent volume is dynamically allocated to each of the Qemu virtual machines through a distributed file system deployed on the Kubernetes cluster.

[0021] In one embodiment, the step of creating and running multiple Qemu virtual machines on the Kubernetes cluster through the Kubernetes extension tool includes:

[0022] Determine a control node and multiple working nodes among multiple servers installed with Kubernetes applications included in the Kubernetes cluster;

[0023] Through the Kubernetes extension tool, the Qemu virtual machine is created and run on the control node and multiple working nodes.

[0024] In one embodiment, the method further comprises:

[0025] Deploy a web interface for interacting with the Kubernetes cluster.

[0026] In one embodiment, the method further comprises:

[0027] For multiple preset trusted computing processors included in multiple servers, obtain the operating system installation image corresponding to the preset trusted computing processors;

[0028] According to the operating system installation image, the operating system corresponding to the preset trusted computing processor is installed on the server.

[0029] In a second aspect, an embodiment of the present invention provides a device for building a cloud native operating system experimental platform, which is applied to a server cluster, wherein the server cluster includes multiple servers, and the servers include multiple preset trusted processors and an operating system corresponding to the preset trusted processors. The device includes:

[0030] A configuration requirement acquisition module, used to acquire the configuration requirements of the server;

[0031] A Kubernetes cluster building module, used to deploy Kubernetes applications on the server and build a Kubernetes cluster according to the configuration requirements and preset configuration requirements;

[0032] A virtual machine creation module is used to create and run multiple Qemu virtual machines on the Kubernetes cluster through a Kubernetes extension tool for the Kubernetes cluster;

[0033] Among them, the preset trusted computing processor, the operating system, the Kubernetes application and the Qemu virtual machine support the same preset instruction set.

[0034] In a third aspect, an embodiment of the present invention provides a computer-readable storage medium having a computer program stored thereon, characterized in that when the computer program is executed by a processor, the steps of a method for building a cloud-native operating system experimental platform described in the first aspect are implemented.

[0035] The technical solution provided by the embodiment of the present invention has the following advantages compared with the prior art:

[0036] A method for building a cloud-native operating system experimental platform provided in an embodiment of the present invention is applied to a server cluster, where the server cluster includes multiple servers, and the server includes multiple preset trusted computing processors and an operating system corresponding to the preset trusted computing processors, to obtain the configuration requirements of the server. According to the configuration requirements and the preset configuration requirements, the Kubernetes application is deployed on the server to build a Kubernetes cluster. For the Kubernetes cluster, multiple Qemu virtual machines are created and run on the Kubernetes cluster through the Kubernetes extension tool. Because the preset trusted computing processor, operating system, Kubernetes application, and Qemu virtual machine support the same preset instruction set. When conducting experiments, there is no need to translate the instructions between the preset trusted computing processor, operating system, Kubernetes application, and Qemu virtual machine, thereby reducing the performance loss of the operating system experimental platform during the experiment. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0038] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, for ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

[0039] Figure 1 A schematic diagram of a process for building a cloud native operating system experimental platform provided by an embodiment of the present invention;

[0040] Figure 2 A schematic diagram of the structure of a cloud native operating system experimental platform building device provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0041] In order to more clearly understand the above-mentioned objectives, features and advantages of the present invention, the scheme of the present invention will be further described below. It should be noted that the embodiments of the present invention and the features in the embodiments can be combined with each other without conflict.

[0042] In the following description, many specific details are set forth to facilitate a full understanding of the present invention, but the present invention may also be implemented in other ways different from those described herein; it is obvious that the embodiments in the specification are only part of the embodiments of the present invention, rather than all of the embodiments.

[0043] Xinchuang, or the information technology application innovation industry, refers to my country's independently innovative information technology and industry, mainly referring to the independently innovative technologies of the IT industry chain, such as operating systems, servers, databases, and middleware. It is mainly driven by industry applications to build a domestic information technology software and hardware underlying architecture system and a full-cycle ecosystem, laying a solid digital foundation for the future development of science and technology. The goal of Xinchuang is to achieve independent control, so that there are more choices in technology for the world's leading information technology products, and to control key technologies from being locked in by foreign companies.

[0044] In the prior art, operating system experimental platforms for the information and innovation industry currently mostly rely on foreign hardware equipment and software systems. Specifically, when conducting experiments on the operating system experimental platform, it is necessary to debug the operating system, usually by using Qemu to create and run a virtual machine in debuggable mode, using gdb's remote debug function to connect to the debugged virtual machine, and using gdb to parse the symbol table and debug the operating system kernel or kernel module. However, currently users cannot directly debug the logged-in virtual machine, and need to further create a virtual machine in the logged-in virtual machine for debugging. In addition, since the hardware equipment, the corresponding software system, and the virtual machine support different instruction sets, this results in the need for multi-layer translation of instructions during the debugging process, resulting in performance loss.

[0045] Therefore, the present invention provides a method for building a cloud-native operating system experimental platform, which is applied to a server cluster, where the server cluster includes multiple servers, and the server includes multiple preset trusted processors and an operating system corresponding to the preset trusted processors, to obtain the configuration requirements of the server. According to the configuration requirements and the preset configuration requirements, the Kubernetes application is deployed on the server to build a Kubernetes cluster. For the Kubernetes cluster, multiple Qemu virtual machines are created and run on the Kubernetes cluster through the Kubernetes extension tool. Because the preset trusted processor, operating system, Kubernetes application and Qemu virtual machine support the same preset instruction set. When conducting experiments, there is no need to translate the instructions between the preset trusted processor, operating system, Kubernetes application and Qemu virtual machine, thereby reducing the performance loss of the operating system experimental platform during the experiment.

[0046] In one embodiment, Figure 1 As shown, Figure 1 A flow chart of a method for building a cloud-native operating system experimental platform provided in an embodiment of the present invention is applied to a server cluster, wherein the server cluster includes multiple servers, the multiple servers are in the same network segment, and the multiple servers communicate and interact with each other. Each server includes multiple preset trusted computing processors, which are mainly domestic trusted computing processors, such as domestic Kunpeng 920 processors. Exemplarily, each server includes 2 domestic Kunpeng 920 processors, but is not limited to this. The present invention is not specifically limited, and those skilled in the art can set it according to actual conditions.

[0047] The operating system corresponding to the preset trusted computing processor refers to an operating system that can run on the preset trusted computing processor. For example, for the domestically produced Kunpeng 920 processor, the corresponding operating system is the openEuler-22.03-LTS-aarch64 operating system, but is not limited to this. The present invention does not specifically limit this, and personnel in this field can set it according to actual conditions.

[0048] Based on this, the method for building a cloud native operating system experimental platform specifically includes the following steps:

[0049] S10: Obtain configuration requirements of the server.

[0050] Configuration requirements refer to whether the current server can deploy a Kubernetes cluster. The configuration requirements include: attribute identification information of the server, such as the host name, MAC address, unique identifier of each server, and open specific ports that allow network traffic to flow. Memory size, such as 2GiB of RAM. Network link status refers to the status of the network link for communication between multiple servers.

[0051] Kubernetes, or K8s for short, is an abbreviation that uses the number 8 to replace the eight characters in the middle of the name, "ubernete". It is an open source containerized application management platform for multiple hosts. The goal of Kubernetes is to make the deployment of containerized applications simple and powerful. Kubernetes provides a mechanism for application deployment, planning, updating, and maintenance.

[0052] Specifically, obtain the current preset configuration requirements of each server.

[0053] S11: Deploy Kubernetes applications on the server and build a Kubernetes cluster according to the configuration requirements and preset configuration requirements.

[0054] The preset configuration requirements are used to determine whether the current configuration requirements of each server are capable of deploying the Kubernetes application.

[0055] Specifically, according to the obtained configuration requirements of the server and the preset configuration requirements, the Kubernetes application is deployed on each server, and a Kubernetes cluster is built based on multiple deployed Kubernetes applications.

[0056] Optionally, based on the above embodiments, in some embodiments of the present invention, one implementation method for building a Kubernetes cluster may be to create a Kubernetes cluster by using the Kubeadm tool, wherein the Kubeadm tool is a deployment tool for the Kubernetes cluster, and mainly creates a Kubernetes cluster by executing the kubeadminit command on the control-plane node and specifying specific parameters. After the cluster is created, the kubeadmjoin command is executed on each other node, and the password provided by the control plane is used to add the other nodes to the Kubernetes cluster.

[0057] Optionally, based on the above embodiment, in some embodiments of the present invention, an implementation manner of S11 may be:

[0058] S111: Determine whether the configuration requirements meet the preset configuration requirements.

[0059] The preset configuration requirements refer to the configuration requirements that each server needs to have when deploying Kubernetes applications.

[0060] Specifically, for the configuration requirements, it is determined whether the configuration requirements meet the preset configuration requirements.

[0061] Exemplarily, following the above embodiment, for the attribute identification information of the server included in the configuration requirements, such as the host name, MAC address, and unique identifier of each server, determine whether each server has its own attribute identification information. If so, it is satisfied. Whether there is an open specific port that allows network traffic to flow through. If so, it is satisfied. Memory size, such as having 2GiB of RAM, determine whether the memory size is greater than or equal to the preset memory size such as 2GiB of RAM. If greater than or equal to, it is satisfied. The network link status refers to the status of the network link for communication between multiple servers. Determine whether there are network links for mutual communication between multiple servers. If there are network links for mutual communication, it is satisfied. However, it is not limited to this, and the present invention is not specifically limited. People in this field can set it according to actual conditions.

[0062] S112: When it is determined that the configuration requirement meets the preset configuration requirement, the Kubernetes application is deployed on the server.

[0063] Specifically, for the configuration requirements, when it is determined that the configuration requirements meet the preset configuration requirements, the Kubernetes application is deployed on the server that meets the preset configuration requirements.

[0064] Optionally, based on the above embodiments, in some embodiments of the present invention, deploying a Kubernetes application on a server can be done by deploying a Kubernetes container runtime on the server and simultaneously enabling the IPv4 traffic forwarding function of the Linux kernel.

[0065] It should be noted that the Pods contained in the Kubernetes cluster communicate with each other through the container network interface based on the Pod network plug-in.

[0066] S12: For the Kubernetes cluster, use the Kubernetes extension tool to create and run multiple Qemu virtual machines on the Kubernetes cluster.

[0067] Among them, the Kubernetes extension tool refers to Kubevirt, which is used to install virtual machines on Kubernetes.

[0068] The above-mentioned preset ICT processor, operating system, Kubernetes application and Qemu virtual machine support the same preset instruction set. The preset instruction set can be, for example, an aarch64 instruction set, which is used to instruct the preset ICT processor, operating system, Kubernetes application and Qemu virtual machine to perform operations.

[0069] Specifically, for Kubernetes clusters, multiple Qemu virtual machines are created and run on the Kubernetes cluster through Kubernetes extension tools such as Kubevirt. The same preset instruction set is supported for the preset trusted processor, operating system, Kubernetes application, and Qemu virtual machine.

[0070] Optionally, based on the above embodiment, in some embodiments of the present invention, an implementation manner of S12 may be:

[0071] S121: Determine a control node and multiple working nodes among multiple servers installed with Kubernetes applications included in the Kubernetes cluster.

[0072] Specifically, for multiple servers installed with Kubernetes applications included in the Kubernetes cluster, one server is determined as a control node among the multiple servers, and the remaining servers are determined as working nodes to bear the workload.

[0073] Optionally, based on the above embodiments, in some embodiments of the present invention, a control node and multiple working nodes may be determined by random selection.

[0074] S122: Use the Kubernetes extension tool to create and run Qemu virtual machines on the control node and multiple worker nodes.

[0075] Specifically, through Kubernetes extension tools such as Kubevirt, Qemu virtual machines are created and run on the control node and multiple worker nodes.

[0076] In this way, the cloud-native operating system experimental platform construction method provided in this embodiment is applied to a server cluster, which includes multiple servers, and the server includes multiple preset trusted innovation processors and an operating system corresponding to the preset trusted innovation processor to obtain the configuration requirements of the server. According to the configuration requirements and the preset configuration requirements, the Kubernetes application is deployed on the server to build a Kubernetes cluster. For the Kubernetes cluster, multiple Qemu virtual machines are created and run on the Kubernetes cluster through the Kubernetes extension tool. Because the preset trusted innovation processor, operating system, Kubernetes application and Qemu virtual machine support the same preset instruction set. When conducting experiments, there is no need to translate the instructions between the preset trusted innovation processor, operating system, Kubernetes application and Qemu virtual machine, thereby reducing the performance loss of the operating system experimental platform during the experiment.

[0077] Optionally, based on the above embodiment, in some embodiments of the present invention, the operation mode of the Qemu virtual machine includes a normal operation mode and a debugging operation mode. Since Kubevirt does not support remote debugging of the Qemu virtual machine, it is impossible to complete kernel code analysis, modification and testing tasks on Kubernetes. Based on this, for the debugging operation mode of the Qemu virtual machine, before executing S12, it also includes:

[0078] S21: Customize the initial Kubernetes extension tool for the debugging operation mode of the Qemu virtual machine.

[0079] Specifically, in order to enable debugging of the Qemu virtual machine, the initial Kubernetes extension tool, Kubevirt, is further customized for the debugging operation mode of the Qemu virtual machine.

[0080] Optionally, based on the above embodiment, in some embodiments of the present invention, an implementation manner of S21 may be:

[0081] S211: Get multiple source codes of Kubernetes extension tools.

[0082] S212: Determine an initial source code related to the debugging operation mode from among the plurality of source codes.

[0083] Specifically, multiple source codes of Kubevirt, a Kubernetes extension tool, are obtained, and multiple initial source codes related to the debugging operation mode are determined from the multiple source codes.

[0084] Optionally, based on the above embodiments, in some embodiments of the present invention, one implementation method of S212 is to first find the pkg / virt-launcher / virtwrap / convrter / converter.go file in multiple source codes of Kubevirt, and further find the Convert_v1_VirtualMachineInstance_To_api_Domain() function in the converter.go file.

[0085] S213: Adding a preset source code to the initial source code according to the debugging operation mode.

[0086] The preset source code includes a preset instruction, and the preset instruction is used to instruct to start the debugging operation mode, and the preset instruction is "-s".

[0087] Specifically, after the initial source code related to the debugging operation mode is found, a preset source code including preset instructions is added to the initial source code, and the preset instructions are used to instruct to start the debugging operation mode.

[0088] Exemplarily, add a preset source code at the end of Convert_v1_VirtualMachineInstance_To_api_Domain(). Optionally, the preset source code is:

[0089] initializeQEMUCmdAndQEMUArg(domain)

[0090] domain.Spec.QEMUCmd.QEMUArg=append(domain.Spec.QEMUCmd.QEM UArg,api.Arg{Value:”-s”}

[0091] In this way, the cloud native operating system experimental platform building method provided by the present invention is customized through the initial Kubernetes extension tool, namely Kubevirt, so that the Qemu virtual machine can be started in the debugging operation mode, thereby completing the kernel code analysis, modification and testing tasks on the Kubernetes platform.

[0092] Optionally, based on the above embodiment, in some embodiments of the present invention, while executing S12, the following is further included:

[0093] For multiple Qemu virtual machines created and running on the Kubernetes cluster, the corresponding persistent volumes are dynamically allocated to each Qemu virtual machine through the distributed file system deployed on the Kubernetes cluster.

[0094] Among them, the distributed file system refers to Ceph, which is the persistent volume resource provider of Kubernetes. Ceph can achieve TB-level data persistence and reduce the cost of server storage hardware facilities.

[0095] Specifically, when multiple Qemu virtual machines are created and run on a Kubernetes cluster, the corresponding persistent volumes are dynamically allocated to each Qemu virtual machine through Ceph, a distributed file system deployed on the Kubernetes cluster.

[0096] It should be noted that Ceph provides multiple storage modes, including CephFS and RBD. For CephFS, it is RWX, and a storage volume can be used by multiple Kubernetes Pods at the same time; RBD belongs to RWO, and a storage volume can only be used by at most one Kubernetes Pod at the same time. Based on this, dynamic allocation of persistent volumes is based on actual conditions.

[0097] In this way, the cloud native operating system experimental platform construction method provided by the present invention can reduce the server storage hardware facility cost by dynamically allocating corresponding persistent volumes to each Qemu virtual machine.

[0098] Optionally, based on the above embodiments, in some embodiments of the present invention, in order to realize the interaction between the user and the Kubernetes cluster, it also includes: deploying a Web interface for interacting with the Kubernetes cluster.

[0099] In this way, the cloud-native operating system experimental platform building method provided by the present invention improves the user experience by deploying a Web interface that interacts with the Kubernetes cluster, through which operations such as user registration, user login, user creation and deletion of experimental environments can be realized.

[0100] Optionally, based on the above embodiments, in some embodiments of the present invention, for multiple preset trusted computing processors included in multiple servers, such as the domestically produced Kunpeng 920 processor, the method further includes:

[0101] For multiple preset trusted computing processors included in multiple servers, obtain the operating system installation image corresponding to the preset trusted computing processors.

[0102] Specifically, for multiple preset trusted computing processors included in multiple servers, download and obtain the operating system installation image corresponding to the preset trusted computing processors.

[0103] Exemplarily, following the above embodiment, for the domestic Kunpeng 920 processor, the operating system installation image corresponding to the domestic Kunpeng 920 processor is downloaded, that is, the openEuler-22.03-LTS-aarch64 operating system installation image, but it is not limited to this. The present invention is not specifically limited, and those skilled in the art can set it according to actual conditions.

[0104] According to the operating system installation image, install the operating system corresponding to the preset trusted computing processor on the server.

[0105] Specifically, when the operating system installation image corresponding to the preset trusted computing processor is obtained, the operating system corresponding to the preset trusted computing processor is installed on the server according to the operating system installation image.

[0106] Optionally, based on the above embodiments, in some embodiments of the present invention, when installing an image according to the operating system and installing an operating system corresponding to a preset trusted computing processor on the server, it should be noted that due to poor support for swap by Kubernetes, the swap partition is disabled when the operating system is partitioned to improve performance. When further partitioning the operating system, more than 1TB of space is allocated to the / var partition to ensure the normal operation of Kubernetes. And the attribute identification information of each server is used to avoid the inability to identify each server. Finally, the IP addresses of each server machine cannot be repeated, and ensure that they are in the same local area network to ensure that each node in the server cluster can access each other through the network.

[0107] It should be understood that although Figure 1 The steps in the flowchart are shown in sequence as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified in this document, there is no strict order restriction for the execution of these steps, and these steps can be executed in other orders. Moreover, Figure 1 At least part of the steps may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least part of the sub-steps or stages of other steps.

[0108] In one embodiment, Figure 2 As shown, a cloud native operating system experimental platform building device is provided, which is applied to a server cluster. The server cluster includes multiple servers, and the servers include multiple preset trusted computing processors and operating systems corresponding to the preset trusted computing processors, including: a configuration requirement acquisition module 10, a Kubernetes cluster construction module 11, and a virtual machine creation module 12.

[0109] Wherein, the configuration requirement acquisition module 10 is used to acquire the configuration requirements of the server;

[0110] A Kubernetes cluster building module 11 is used to deploy a Kubernetes application on the server and build a Kubernetes cluster according to the configuration requirements and preset configuration requirements;

[0111] A virtual machine creation module 12 is used to create and run multiple Qemu virtual machines on the Kubernetes cluster through a Kubernetes extension tool for the Kubernetes cluster;

[0112] Among them, the preset trusted computing processor, the operating system, the Kubernetes application and the Qemu virtual machine support the same preset instruction set.

[0113] In the above embodiment, on a server cluster, the server cluster includes multiple servers, and the server includes multiple preset trusted processors and an operating system corresponding to the preset trusted processor. The configuration requirement acquisition module obtains the configuration requirements of the server. The Kubernetes cluster construction module deploys the Kubernetes application on the server and builds a Kubernetes cluster according to the configuration requirements and the preset configuration requirements. The virtual machine creation module creates and runs multiple Qemu virtual machines on the Kubernetes cluster through the Kubernetes extension tool for the Kubernetes cluster. Because the preset trusted processor, operating system, Kubernetes application and Qemu virtual machine support the same preset instruction set. When conducting experiments, there is no need to translate the instructions between the preset trusted processor, operating system, Kubernetes application and Qemu virtual machine, thereby reducing the performance loss of the operating system experimental platform during the experiment.

[0114] For the specific limitations of the cloud native operating system experimental platform construction device, please refer to the limitations of the cloud native operating system experimental platform construction method above, which will not be repeated here. Each module in the above-mentioned server can be implemented in whole or in part through software, hardware and a combination thereof. The above-mentioned modules can be embedded in or independent of the processor in the computer device in the form of hardware, or can be stored in the memory of the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

[0115] An embodiment of the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program is implemented by a processor to implement the method for building a cloud native operating system experimental platform provided by an embodiment of the present invention. For example, the computer program is implemented by the processor to implement Figure 1 The technical solution of any of the method embodiments shown has similar implementation principles and technical effects, which will not be repeated here.

[0116] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to the memory, database or other medium used in the embodiments provided by the present invention can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory or optical memory, etc. Volatile memory can include random access memory (RAM) or external cache memory. As an illustration and not limitation, RAM is available in many forms, such as static random access memory (SRAM) and dynamic random access memory (DRAM).

[0117] The technical features of the above embodiments may be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0118] The above-mentioned embodiments only express several implementation methods of the present invention, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the invention patent. It should be pointed out that, for ordinary technicians in this field, several variations and improvements can be made without departing from the concept of the present invention, and these all belong to the protection scope of the present invention. Therefore, the protection scope of the patent of the present invention shall be subject to the attached claims.

Claims

1. A method for building a cloud native operating system experimental platform, characterized in that: Applied to a server cluster, the server cluster includes multiple servers, the servers include multiple preset trusted computing processors, and an operating system corresponding to the preset trusted computing processors, the method includes: Obtaining configuration requirements of the server; According to the configuration requirements and preset configuration requirements, deploy the Kubernetes application on the server to build a Kubernetes cluster; For the Kubernetes cluster, using the Kubernetes extension tool, create and run multiple Qemu virtual machines on the Kubernetes cluster; Among them, the preset trusted computing processor, the operating system, the Kubernetes application and the Qemu virtual machine support the same preset instruction set.

2. The method according to claim 1, characterized in that The step of deploying the Kubernetes application on the server and building a Kubernetes cluster according to the configuration requirements and the preset configuration requirements includes: Determining whether the configuration requirement meets the preset configuration requirement, wherein the configuration requirement includes: attribute identification information, memory size, and network connection status of the server; If so, deploy the Kubernetes application on the server.

3. The method according to claim 1, characterized in that The operation mode of the Qemu virtual machine includes a normal operation mode and a debugging operation mode. For the Kubernetes cluster, before creating and running the Qemu virtual machine on the Kubernetes cluster through the Kubernetes extension tool, the method further includes: The initial Kubernetes extension tool is customized for the debugging operation mode of the Qemu virtual machine.

4. The method according to claim 3, characterized in that The customizing of the initial Kubernetes extension tool for the debugging operation mode of the Qemu virtual machine includes: Obtain multiple source codes of the Kubernetes extension tool; Determining an initial source code related to the debugging operation mode from among the plurality of source codes; According to the debugging operation mode, a preset source code is added to the initial source code, wherein the preset source code includes a preset instruction, and the preset instruction is used to instruct to start the debugging operation mode.

5. The method according to claim 1, characterized in that The method further comprises: For multiple Qemu virtual machines created and running on the Kubernetes cluster, a corresponding persistent volume is dynamically allocated to each of the Qemu virtual machines through a distributed file system deployed on the Kubernetes cluster.

6. The method according to claim 1, characterized in that The Kubernetes extension tool is used to create and run multiple Qemu virtual machines on the Kubernetes cluster, including: Determine a control node and multiple working nodes among multiple servers installed with Kubernetes applications included in the Kubernetes cluster; Through the Kubernetes extension tool, the Qemu virtual machine is created and run on the control node and multiple working nodes.

7. The method according to claim 1, characterized in that The method further comprises: Deploy a web interface for interacting with the Kubernetes cluster.

8. The method according to claim 1, characterized in that The method further comprises: For multiple preset trusted computing processors included in multiple servers, obtain the operating system installation image corresponding to the preset trusted computing processors; According to the operating system installation image, the operating system corresponding to the preset trusted computing processor is installed on the server.

9. A device for building a cloud native operating system experimental platform, characterized in that: Applied to a server cluster, the server cluster includes multiple servers, the servers include multiple preset trusted processors, and an operating system corresponding to the preset trusted processors, the device includes: A configuration requirement acquisition module, used to acquire the configuration requirements of the server; A Kubernetes cluster building module, used to deploy Kubernetes applications on the server and build a Kubernetes cluster according to the configuration requirements and preset configuration requirements; A virtual machine creation module is used to create and run multiple Qemu virtual machines on the Kubernetes cluster through a Kubernetes extension tool for the Kubernetes cluster; Among them, the preset trusted computing processor, the operating system, the Kubernetes application and the Qemu virtual machine support the same preset instruction set.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the steps of a method for building a cloud native operating system experimental platform as described in any one of claims 1 to 8 are implemented.

Images