Method, electronic device and storage medium for generating a trustworthy operating system pipeline

Abstract

The present invention discloses a method, electronic device and storage medium for generating a trusted operating system pipeline, and belongs to the technical field of cloud computing and operating system. The present invention aims to solve the technical problem of how to improve the efficiency and quality of operating system image generation, and adopts the following technical solutions: compile and produce software packages: in an independent environment, compile software source packages by category; produce software sources: produce software sources according to a dependency graph of the software packages; produce ISO images: compile an operating system ISO image using corresponding command tools according to the software sources; verify the ISO image: use an integrated pipeline for automated verification, specifically: automatically install the ISO image to be tested, automatically start the virtual machine, and automatically verify the software package version through a script.

Description

Technical Field

[0001] The present invention relates to the field of cloud computing and operating system technology, and specifically to a method, electronic device and storage medium for generating a trusted operating system pipeline. Background Art

[0002] An operating system is a collection of system software that manages computer hardware resources, controls the execution of other programs, and provides an interactive interface for users. An operating system is a key component of a computer system, responsible for basic tasks such as managing and allocating memory, determining the priorities of system resource supply and demand, controlling input and output devices, operating networks, and managing file systems. There are many different types of operating systems, ranging from simple to complex, from embedded operating systems in mobile phones to large-scale operating systems in supercomputers. Currently, popular modern operating systems include Android, BSD, iOS, Linux, Mac OS X, Windows, Windows Phone, and z / OS. With the exception of a few operating systems like Windows and z / OS, most operating systems are Unix-like.

[0003] With the development of informatization and digitalization, computer operating systems have gradually become an indispensable infrastructure in people's lives. Operating systems used in different fields and application scenarios also have their own advantages and disadvantages.

[0004] The specific process of operating system image production in the prior art is as follows:

[0005] ① Automated deployment technology: Automated deployment technology can automatically install systems, applications, and configuration files in batches through scripts, reducing the tediousness and possibility of errors in manual operations.

[0006] ②Virtualization technology: Virtualization technology can virtualize servers, realize resource sharing and isolation, effectively reduce costs and improve management efficiency, and also facilitate the production and management of images.

[0007] ③ Unified management platform: The unified management platform can integrate the management tools and processes of each link, making the entire process of image production visible, controllable and operable, and improving management efficiency and quality.

[0008] In short, the background technologies for streamlining operating system image production are multifaceted, including automated deployment, virtualization, and unified management platforms. The development and application of these technologies have continuously improved the efficiency and quality of image production, driving the development of streamlining operating system image production.

[0009] However, the existing operating system image production process has the problems of low efficiency and poor quality. Therefore, how to improve the efficiency and quality of operating system image generation is a technical problem that needs to be solved urgently. Summary of the Invention

[0010] The technical task of the present invention is to provide a method, electronic device and storage medium for generating a trusted operating system pipeline to solve the problem of how to improve the efficiency and quality of operating system image generation.

[0011] The technical task of the present invention is achieved in the following way: a method for generating a trustworthy operating system pipeline, the method is as follows:

[0012] Compile and create software packages: In an independent environment, compile software source code packages by category;

[0013] Create software source: Create software source according to the dependency graph of the software package;

[0014] Create ISO image: Use the corresponding command tool to compile the operating system ISO image according to the software source;

[0015] Verify the ISO image: Use an integrated pipeline to automate verification, specifically: automatically install the ISO image to be tested, automatically start the virtual machine, and automatically verify the software package version through scripts.

[0016] As a preferred method, compile and make the software package as follows:

[0017] Start a minimally installed VM using the XML configuration file: Use the graphical tool virt-manager or the command virsh create boot_from_disk.xml to start a VM. The VM hardware configuration is 4 cores and 8GB of memory. The disk is mounted to the VM using the virtio driver in qcow2 format. The network bridge uses the virbr0 bridge provided by libvirt by default. Enable the pty virtual console to facilitate subsequent automated configuration operations.

[0018] Traverse the compilation dependencies of software source packages and group packages that have no mutual compilation dependencies.

[0019] More optimally, traverse the compilation dependencies of the software source packages and group the packages that have no mutual compilation dependencies into the following groups:

[0020] ① Use the rpm-qR command to query the relevant dependent packages: When querying the dependent packages of openssl, the dependent packages of openssl are: coreutils, openssl-libs and perl;

[0021] ② Separate openssl and coreutils, which have no mutual compilation dependencies, into different groups;

[0022] ③ Select a set of software source code packages, log in to the started virtual machine through SSH, compile the software source code packages in sequence, and generate software binary packages;

[0023] ④Compile the remaining groups in sequence according to step ②; when compiling each group, start a new virtual machine.

[0024] As a preference, the software source is made as follows:

[0025] Aggregate software packages: Put all software packages into the "everything / Packages" folder, put the minimum set of software packages required to create the final ISO disc image into the "OS / Packages" folder, and put subsequent upgrade packages into the "update / Packages" folder.

[0026] Create a software source index file based on the software package dependency graph: execute createrepo. / in the everything, OS, and update folders to generate the index. The index file is generated in the repodata folder.

[0027] Expose all software packages and software source index files via HTTP (such as nginx service).

[0028] As a preferred method, the ISO image is created as follows:

[0029] Start a new virtual machine with minimal installation and create a local software source: create three local software sources: everything, OS, and update. The three local software sources are mapped to http: / / 192.168.122.1 / inlinux / everything, http: / / 192.168.122.1 / inlinux / OS / , and http: / / 192.168.122.1 / inlinux / update / through HTTP services; write the corresponding configuration of everything, OS, or update to / etc / yum.repo.d / inspur.repo, and you can use the local software source to install software packages;

[0030] Use the oemaker command to build the ISO image.

[0031] Preferably, the configuration corresponding to the OS is as follows:

[0032] [OS];

[0033] name=OS;

[0034] baseurl=http: / / 192.168.122.1 / inlinux / OS / ;

[0035] enabled=1;

[0036] gpgcheck=0;

[0037] Among them, baseurl indicates the URL address of the local software source; enabled indicates whether the source is enabled;

[0038] gpgcheck indicates whether to verify the validity of the package.

[0039] Better yet, use the oemaker command to build the ISO image:

[0040] Build command: oemaker -t standard -p [OS-PRODUCT-NAME] -v [OS-VERSION] -r [OS-RELEASE-NAME] -s [URL];

[0041] Among them, [OS-PRODUCT-NAME] indicates the operating system product name, such as InLinux;

[0042] [OS-VERSION] indicates the operating system version name, such as 23.12;

[0043] [OS-RELEASE-NAME] indicates the release version name, such as LTS;

[0044]

URL

[0045] The final generated ISO file is InLinux-23.12-LTS.ISO.

[0046] As a preference, verify the ISO image as follows:

[0047] Use the built ISO image to create a virtual machine that boots from CDROM. Use the libvirt toolkit on the Ubuntu system to start a virtual machine system, that is, use virt-install to start a virtual machine. The virtual configuration is: 8192MB of memory, 4 cores of CPU, use ubuntu.iso as CDROM, use DISK.qcow2 as the virtual disk, use virbr0 as the network bridge, and enable remote VNC.

[0048] Use expect+virsh console to automatically install the operating system to disk: Use libvirt's console command to access the virtual machine's console. When the screen prints "login," enter your username, such as root. When the screen prints "Password," enter your password to successfully log in to the virtual machine. Then, when you see a # (#) on the screen, enter the automated installation command. Finally, when you see a # (#) on the screen again, enter exit.

[0049] Use the generated disk to create a virtual machine that boots from hd;

[0050] Log in to the virtual machine, execute the verification script, and verify the software version and basic functions.

[0051] An electronic device comprising: a memory and at least one processor;

[0052] wherein the memory stores computer-executable instructions;

[0053] The at least one processor executes the computer execution instructions stored in the memory, so that the at least one processor executes the method of generating the trusted operating system pipeline as described above.

[0054] A computer-readable storage medium stores computer execution instructions. When a processor executes the computer execution instructions, the method of generating a trusted operating system pipeline as described above is implemented.

[0055] The method, electronic device, and storage medium for generating a trusted operating system pipeline of the present invention have the following advantages:

[0056] (1) The present invention streamlines the software source and ISO production process, which can quickly complete the production process from the underlying software source to the final ISO image;

[0057] (2) The present invention improves production efficiency: the streamlined mirror production process can break down complex processes into simple steps, thereby improving production efficiency and reducing the error rate in the production process;

[0058] (3) The present invention reduces labor costs: The image production process can use scripts to automatically complete some simple operations, reducing the tediousness and error possibility of manual operations and reducing labor costs;

[0059] (4) The present invention improves image quality: the image production process can provide a set of standard processes, so that each link is carried out in an orderly manner, thereby reducing the error rate and improving the image quality;

[0060] (5) The present invention facilitates management and maintenance: the standardized image production process can facilitate management personnel to better manage and maintain the image, thereby improving system stability;

[0061] (6) The present invention achieves standardization: the image production process can formulate a set of standard image production specifications, so that different image productions have a consistent quality level, thus achieving standardization;

[0062] (7) The present invention can reduce the complexity and error potential of manual operations, thereby improving efficiency and quality. The implementation of the present invention requires the use of multiple technologies, including automated deployment technology, virtualization technology, and a unified management platform;

[0063] (8) The present invention can realize the automation and standardization of image production, improve resource utilization, reduce IT costs, and promote digital transformation;

[0064] (9) The present invention can be applied to various scenarios such as cloud computing platforms and containerized platforms to achieve flexible, efficient and secure image production and management, thereby improving the efficiency and quality of operating system image generation. At the same time, the present invention can make the entire image production process visible, controllable and operable, facilitating monitoring and adjustment by management personnel, and improving system stability and security. BRIEF DESCRIPTION OF THE DRAWINGS

[0065] The present invention will be further described below with reference to the accompanying drawings.

[0066] Attachment Figure 1 A flowchart of a method for generating a trusted operating system pipeline;

[0067] Attachment Figure 2 To make a screenshot of the software source interface;

[0068] Attachment Figure 3 Screenshot of the interface for making ISO image. DETAILED DESCRIPTION

[0069] The method, electronic device and storage medium for generating a trusted operating system pipeline of the present invention are described in detail below with reference to the drawings and specific embodiments of the specification.

[0070] Example 1:

[0071] As attached Figure 1 As shown, this embodiment provides a method for generating a trusted operating system pipeline, which is specifically as follows:

[0072] S1. Compile and create software packages: In an independent environment, compile software source code packages by category;

[0073] S2. Create software source: Create software source according to the dependency graph of the software package;

[0074] S3. Create ISO image: Use the corresponding command tool to compile the operating system ISO image according to the software source;

[0075] S4. Verify the ISO image: Use an integrated pipeline to automate the verification, specifically: automatically install the ISO image to be tested, automatically start the virtual machine, and automatically verify the software package version through scripts.

[0076] The compilation and production of the software package in step S1 of this embodiment is specifically as follows:

[0077] S101. Start a minimally installed virtual machine using the XML configuration file: Use the graphical tool virt-manager or the command virsh create boot_from_disk.xml to start a virtual machine. The virtual machine hardware configuration is 4 cores and 8G memory. The disk is mounted to the virtual machine through the virtio driver and the disk uses the qcow2 format. The bridge uses the virbr0 bridge provided by libvirt by default. The pty virtual console is enabled to facilitate subsequent automated configuration operations. The key code is as follows:

[0078]

[0079]

[0080]

[0081] S102: traverse the compilation dependency relationships of the software source code packages, and group packages that do not have mutual compilation dependency relationships.

[0082] In step S102 of this embodiment, the compilation dependency relationships of the software source code packages are traversed to group the packages that do not have mutual compilation dependencies as follows:

[0083] ① Use the command rpm-qR to query the relevant dependent packages: When querying the dependent packages of openssl, the dependent packages of openssl are: coreutils, openssl-libs and perl; the key code is as follows:

[0084] [root@localhost~]#rpm-qR openssl

[0085] coreutils

[0086] openssl-libs

[0087] perl

[0088] It can be concluded that the dependent packages of openssl are: coreutils, openssl-libs, perl.

[0089] ② Separate openssl and coreutils, which have no mutual compilation dependencies, into different groups;

[0090] For example, separate openssl and coreutils into different groups:

[0091] The rpm–qR command shows that Openssl depends on coreutils;

[0092] [root@localhost~]#rpm-qR openssl

[0093] coreutils

[0094] openssl-libs

[0095] perl.

[0096] ③ Select a set of software source code packages, log in to the started virtual machine through SSH, compile the software source code packages in sequence, and generate software binary packages;

[0097] For example: Rpm package compilation command rpmbuild-ba*.src.rpm;

[0098] ④Compile the remaining groups in sequence according to step ②; when compiling each group, start a new virtual machine.

[0099] The specific software source in step S2 of this embodiment is as follows:

[0100] S201. Aggregate software packages: Put all software packages into the folder "everything / Packages", put the minimum set of software packages required to create the final ISO image into the folder "OS / Packages", and put subsequent upgrade packages into the folder "update / Packages".

[0101] S202. Create a software source index file based on the software package dependency graph: execute createrepo. / in the "everything", "OS", and "update" folders to generate an index. The index file is generated in the "repodata" folder.

[0102] S203. Expose all software packages and software source index files via HTTP (such as nginx service).

[0103] The details of making the ISO image in step S3 of this embodiment are as follows:

[0104] S301. Start a new virtual machine with minimal installation and create a local software source: create three local software sources: everything, OS, and update. The three local software sources are mapped to http: / / 192.168.122.1 / inlinux / everything, http: / / 192.168.122.1 / inli nux / OS / , and http: / / 192.168.122.1 / inlinux / update / through HTTP services respectively; write the corresponding configuration of everything, OS, or update to / etc / yum.repo.d / inspur.repo, and then you can use the local software source to install the software package; the software source configuration is as follows:

[0105] [OS]

[0106] name=OS

[0107] baseurl=http: / / 192.168.122.1 / inlinux / OS /

[0108] enabled=1

[0109] gpgcheck=0

[0110] [everything]

[0111] name=everything

[0112] baseurl=http: / / 192.168.122.1 / inlinux / everything /

[0113] enabled=1

[0114] gpgcheck=0

[0115] [update]

[0116] name=updatebaseurl=http: / / 192.168.122.1 / inlinux / update /

[0117] enabled=1

[0118] gpgcheck=0;

[0119] S302. Use the oemaker command to build an ISO image.

[0120] The configuration corresponding to the OS in step S301 of this embodiment is specifically as follows:

[0121] [OS];

[0122] name=OS;

[0123] baseurl=http: / / 192.168.122.1 / inlinux / OS / ;

[0124] enabled=1;

[0125] gpgcheck=0;

[0126] Among them, baseurl indicates the URL address of the local software source; enabled indicates whether to enable the source; gpgcheck indicates whether to verify the legitimacy of the package.

[0127] In step S302 of this embodiment, the ISO image is constructed using the oemaker command as follows:

[0128] Build command: oemaker -t standard -p [OS-PRODUCT-NAME] -v [OS-VERSION] [OS-RELEASE-NAME] -s [URL];

[0129] Among them, [OS-PRODUCT-NAME] indicates the operating system product name, such as InLinux;

[0130] [OS-VERSION] indicates the operating system version name, such as 23.12;

[0131] [OS-RELEASE-NAME] indicates the release version name, such as LTS;

[0132]

URL

[0133] The final generated ISO file is InLinux-23.12-LTS.ISO.

[0134] The verification of the ISO image in step S4 of this embodiment is as follows:

[0135] S401. Use the built ISO image to create a virtual machine that boots from CDROM. Use the libvirt toolkit on the Ubuntu system to start a virtual machine system, that is, use virt-install to start a virtual machine. The virtual configuration is: 8192MB of memory, 4 cores of CPU, use ubuntu.iso as CDROM, use DISK.qcow2 as virtual disk, use virbr0 as network bridge, and enable remote VNC. The key code is as follows:

[0136] virt-install--virt-type kvm--name boot_from_iso--ram 8192\

[0137] --vcpus=4--cdrom= / path_to_iso / ubuntu.iso\

[0138] --disk / path_to_disk / DISK.qcow2,bus=virtio,size=10,format=qcow2\

[0139] --network bridge=virbr0\

[0140] --graphics vnc,listen=0.0.0.0–noautoconsole;

[0141] S402. Use expect+virsh console to automatically install the operating system to disk: Use libvirt's console command to access the virtual machine's console. When the screen prints "login," enter your username, such as root. When the screen prints "Password," enter your password to successfully log in to the virtual machine. Then, when you see a # on the screen, enter the automated installation command. Finally, when you see a # on the screen again, enter exit. The key code is as follows:

[0142] expect< <EOF

[0143] set time

TIMEOUT

[0144] spawn virsh console

VMNAME

[0145] expect"Escape character is*"{send"\n"}

[0146] expect"*login:*"{send"

USERNAME

[0147] expect"Password*"{send"

PASSWORD

[0148] expect"*#*"{send"

COMMAND

[0149] expect "*#*" {send "exit\n"}

[0150] expect eof

[0151] EOF.

[0152] By using scripts similar to the above, you can automate the installation of the operating system and perform a step-by-step installation process.

[0153] S403. Use the generated disk to create a virtual machine that starts from HD.

[0154] S404. Log in to the virtual machine, execute the verification script, and verify the software version and basic functions.

[0155] Example 2:

[0156] This embodiment also provides an electronic device, including: a memory and at least one processor;

[0157] wherein the memory stores computer-executable instructions;

[0158] The at least one processor executes the computer execution instructions stored in the memory, so that the at least one processor executes the method, electronic device and storage medium for generating a trusted operating system pipeline as described in any one of the present inventions.

[0159] The processor may be a central processing unit (CPU), other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The processor may be a microprocessor or any conventional processor, etc.

[0160] The memory can be used to store computer programs and / or modules. The processor implements various functions of the electronic device by running or executing the computer programs and / or modules stored in the memory, and calling the data stored in the memory. The memory can mainly include a program storage area and a data storage area. The program storage area can store an operating system, at least one application required for a function, etc.; the data storage area can store data created based on the use of the terminal, etc. In addition, the memory can also include high-speed random access memory and non-volatile memory, such as a hard disk, internal memory, a plug-in hard disk, a smart memory card (SMC), a secure digital (SD) card, a flash memory card, at least one disk storage period, a flash memory device, or other volatile solid-state memory devices.

[0161] Example 3:

[0162] This embodiment also provides a computer-readable storage medium, which stores a plurality of instructions, which are loaded by a processor to enable the processor to execute the method, electronic device, and storage medium for generating a trustworthy operating system pipeline in any embodiment of the present invention. Specifically, a system or device equipped with a storage medium can be provided, on which software program codes for implementing the functions of any of the above embodiments are stored, and a computer (or CPU or MPU) of the system or device can be enabled to read and execute the program codes stored in the storage medium.

[0163] In this case, the program code itself read from the storage medium can realize the function of any one of the above-mentioned embodiments, and thus the program code and the storage medium storing the program code constitute part of the present invention.

[0164] Examples of storage media for providing program code include floppy disks, hard disks, magneto-optical disks, optical disks (such as CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RAM, DVD-RW, DVD+RW), magnetic tapes, non-volatile memory cards, and ROMs. Alternatively, the program code can be downloaded from a server computer via a communication network.

[0165] In addition, it should be clear that the functions of any of the above embodiments can be achieved not only by executing the program code read by the computer, but also by enabling the operating system operating on the computer to complete part or all of the actual operations based on the instructions of the program code.

[0166] In addition, it can be understood that the program code read from the storage medium is written into the memory provided in the expansion board inserted into the computer or into the memory provided in the expansion unit connected to the computer, and then based on the instructions of the program code, the CPU installed on the expansion board or expansion unit is enabled to perform part or all of the actual operations, thereby realizing the functions of any of the above embodiments.

[0167] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the above embodiments, or replace some or all of the technical features therein with equivalents. However, these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for generating a trusted operating system pipeline, characterized in that: The method is as follows: Compile and create software packages: In an independent environment, compile software source code packages by category, and traverse the compilation dependencies of the software source code packages, grouping packages that have no mutual compilation dependencies; the details are as follows: ① Use the rpm-qR command to query the relevant dependent packages: When querying the dependent packages of openssl, the dependent packages of openssl are: coreutils, openssl-libs and perl; ② Separate openssl and coreutils, which have no mutual compilation dependencies, into different groups; ③ Select a set of software source code packages, log in to the started virtual machine through SSH, compile the software source code packages in sequence, and generate software binary packages; ④Compile the remaining groups in sequence according to step ②; when compiling each group, start a new virtual machine; Create software source: Create software source according to the dependency graph of the software package; Create ISO image: Use the corresponding command tool to compile the operating system ISO image according to the software source; Verify ISO images: Use integrated pipelines for automated verification, specifically: automatically install the ISO image to be tested, automatically start the virtual machine, and automatically verify the software package version through scripts; The production software sources are as follows: Aggregate software packages: Put all software packages into the "everything / Packages" folder, put the minimum set of software packages required to create the final ISO disc image into the "OS / Packages" folder, and put subsequent upgrade packages into the "update / Packages" folder. Create a software source index file based on the software package dependency graph: execute createrepo . / in the everything, OS, and update folders to generate the index. The index file is generated in the repodata folder. Expose all software packages and software source index files via HTTP; The details of making an ISO image are as follows: Start a new virtual machine with minimal installation and create a local software source: create three local software sources: everything, OS, and update. These three local software sources are mapped to http: / / 192.168.122.1 / inlinux / everything, http: / / 192.168.122.1 / inlinux / OS / , and http: / / 192.168.122.1 / inlinux / update / through HTTP services. Write the corresponding configuration of everything, OS, or update to / etc / yum.repo.d / inspur.repo. Then you can use the local software source to install software packages. Use the oemaker command to build the ISO image.

2. The method for generating a trusted operating system pipeline according to claim 1, characterized in that: Compile and make the software package as follows: Start a minimally installed virtual machine and use the XML configuration file: Use the graphical tool virt-manager or the command virsh create boot_from_disk.xml to start a virtual machine. The virtual machine hardware configuration is 4 cores and 8G memory. The disk is mounted to the virtual machine through the virtio driver and the disk uses the qcow2 format. The bridge uses the virbr0 bridge provided by libvirt by default. Enable the pty virtual console console to facilitate subsequent automated configuration operations.

3. The method for generating a trusted operating system pipeline according to claim 1, wherein: The configuration corresponding to the OS is as follows: [OS]; name=OS; baseurl=http: / / 192.168.122.1 / inlinux / OS / ; enabled=1; gpgcheck=0; Among them, baseurl indicates the URL address of the local software source; enabled indicates whether the source is enabled; gpgcheck indicates whether to verify the validity of the package.

4. The method for generating a trusted operating system pipeline according to claim 1, wherein: Use the oemaker command to build the ISO image: Build command: oemaker -t standard -p 【OS-PRODUCT-NAME】 -v 【OS-VERSION】 -r 【OS-RELEASE-NAME】 -s 【URL】; Among them, [OS-PRODUCT-NAME] indicates the operating system product name; 【OS-VERSION】indicates the operating system version name; [OS-RELEASE-NAME] indicates the release version name; 【URL】indicates the URL corresponding to the source; The final generated ISO file is InLinux-23.12-LTS.ISO.

5. The method for generating a trusted operating system pipeline according to claim 1, wherein: Verify the ISO image as follows: Use the built ISO image to create a virtual machine that boots from CDROM. Use the libvirt toolkit on the Ubuntu system to start a virtual machine system, that is, use virt-install to start a virtual machine. The virtual configuration is: 8192MB of memory, 4 cores of CPU, use ubuntu.iso as CDROM, use DISK.qcow2 as the virtual disk, use virbr0 as the network bridge, and enable remote VNC. Use expect + virsh console to automatically install the operating system to disk: Use libvirt's console command to access the virtual machine's console. When the word "login" is printed on the screen, enter the username. When the screen prints "Password", enter the password and successfully log in to the virtual machine; then when the monitor appears on the screen, enter the command for automated installation, and finally when the monitor appears on the screen again, enter exit; Use the generated disk to create a virtual machine that boots from hd; Log in to the virtual machine, execute the verification script, and verify the software version and basic functions.

6. An electronic device, characterized in that: include: memory and at least one processor; wherein the memory stores computer-executable instructions; The at least one processor executes the computer execution instructions stored in the memory, so that the at least one processor executes the method for generating a trusted operating system pipeline as described in any one of claims 1 to 5.

7. A computer-readable storage medium, characterized in that The computer-readable storage medium stores computer execution instructions. When the processor executes the computer execution, it implements the method for generating a trusted operating system pipeline as described in any one of claims 1 to 5.

Images