Kubernetes container cloud X86 and ARM architecture hybrid rapid deployment method, device and medium
By directly deploying the compiled JAR packages on the Kubernetes container cloud and utilizing the Init container for automated processing, the complexity and time consumption of mixed x86 and ARM architecture deployments are resolved, enabling rapid deployment and efficient operation and maintenance.
Patent Information
- Application Number
- CN202511554714.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-10-29
- Publication Date
- 2026-02-17
Smart Images
Figure CN121541969A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of software deployment technology, specifically to a method, device, and medium for rapid deployment of hybrid x86 and ARM architectures on a Kubernetes container cloud. Background Technology
[0002] With the widespread adoption of domestic IT innovation technologies, the ARM architecture has become extremely popular, and many enterprises are using Kubernetes container technology to deploy their services. In this process, users need to build a Dockerfile and then create business containers based on the image. It is evident that existing technologies have the following problems:
[0003] ① Creating an image using Dockerfile requires distinguishing between x86 and ARM applications, dependencies, and base images, which is a complex process with a high learning curve.
[0004] ②Building and pushing images consumes a lot of time, making it impossible to quickly deploy services and slow to respond to business changes.
[0005] Traditional Kubernetes hybrid cluster environment deployment services (nodeSelector) require providing a container image Dockerfile. The Dockerfile contains the operating system, dependent environment, application packages, and application startup process. For example, if you need to deploy a Java application, the Dockerfile needs to include the underlying base image (x86, ARM), JDK dependency runtime environment, application JAR package, and startup command. The process of deploying one service takes 30 minutes.
[0006] For enterprises using a hybrid x86 and ARM architecture, the above process requires a significant amount of time to master the Dockerfile. In the event of online issues or urgent functional verification, these cumbersome steps can be daunting for business personnel.
[0007] Therefore, how to achieve rapid deployment of hybrid x86 and ARM architectures on Kubernetes container clouds and reduce development and operation costs is a technical problem that urgently needs to be solved. Summary of the Invention
[0008] The technical objective of this invention is to provide a method, device, and medium for rapid deployment of hybrid x86 and ARM architectures on a Kubernetes container cloud, in order to solve the problem of how to achieve rapid deployment of hybrid x86 and ARM architectures on a Kubernetes container cloud and reduce development and maintenance costs.
[0009] The technical objective of this invention is achieved as follows: a rapid deployment method for hybrid x86 and ARM architectures on a Kubernetes container cloud. This method involves directly deploying JAR packages compiled from x86 and ARM servers to the container cloud without writing Dockerfiles to build images; specifically as follows:
[0010] Compile the latest code to generate an application package;
[0011] Provides a base image of an X86 and ARM operating system containing the program's runtime environment;
[0012] Upload the application package to the FTP server according to business requirements;
[0013] The application package runs in a Pod, and the Pod has one or more Init containers that start before the application container.
[0014] As a preferred method, the application package is generated by compiling the latest code as follows:
[0015] The Java application is compiled into an "armpr.jar" application package on the ARM server;
[0016] The Java application is compiled into an "x86pr.jar" application package on the x86 server.
[0017] Even better, for Java applications, a base image including the JDK environment is provided.
[0018] Ideally, for Java applications, the "armpr.jar" and "x86pr.jar" application packages should be uploaded to the FTP server according to business requirements.
[0019] More preferably, the Init container includes init container 1, init container 2, and init container 3;
[0020] Among them, the init container 1pause is the Pod's inherent container, used to maintain the Pod's network space;
[0021] container 2 init pulls the IP: / ftp / armpr.jar package to the / myapp directory and configures a shared directory;
[0022] The init container 3 runs dependent images and automatically mounts the init container 2 / myapp directory. At this time, the init container 3 has the application package / myapp / armpr.jar. After checking that the directory exists, the init container 3 runs the jar application package (Java-jar / myapp / armpr.jar). The whole process does not require manual configuration and management. The init container 3 automatically checks, assembles and runs the application.
[0023] More preferably, the Init container has the following characteristics:
[0024] ① Always run until completion;
[0025] ② Each Init container must complete successfully before the next startup.
[0026] Even better, the Pod's Init container and other containers share storage.
[0027] Better yet, when a Pod specifies multiple Init containers, the multiple Init containers will run sequentially one by one; each Init container must run successfully before the next one can run; when all Init containers have finished running, Kubernetes will initialize the application container for the Pod and run it as usual.
[0028] An electronic device includes: a memory and at least one processor;
[0029] The memory contains computer programs;
[0030] The at least one processor executes the computer program stored in the memory, causing the at least one processor to perform the rapid deployment method for hybrid x86 and ARM architectures on a Kubernetes container cloud as described above.
[0031] A computer-readable storage medium storing a computer program that can be executed by a processor to implement the hybrid rapid deployment method for x86 and ARM architectures on a Kubernetes container cloud as described above.
[0032] The method, device, and media for rapid deployment of hybrid x86 and ARM architectures on Kubernetes container clouds of the present invention have the following advantages:
[0033] (i) The jar package compiled based on the X86 and ARM architecture of this invention can be directly deployed to the container cloud without writing Dockerfile to build the image, which reduces the learning cost of development and operation and maintenance, and also saves a lot of time for development and operation and maintenance personnel, so that business personnel can focus more on the business itself and better support business use and operation and maintenance.
[0034] (ii) This invention enables a service deployment process to be completed in 2-3 minutes, which greatly optimizes the problems of long cycle and difficult maintenance of traditional architecture; if this process can be saved, the promotion of ARM container technology will definitely take another step forward.
[0035] (III) This invention solves the problems of Dockerfile image creation requiring differentiation between X86 and ARM applications, dependencies, and base images, which is complex, has a high learning cost, and consumes a lot of time in building and pushing images, making it difficult to quickly deploy services and respond to business changes. It allows users to directly deploy services based on application packages. Attached Figure Description
[0036] The invention will be further described below with reference to the accompanying drawings.
[0037] Appendix Figure 1 This diagram illustrates a method for rapid deployment of hybrid x86 and ARM architectures on a Kubernetes container cloud. Detailed Implementation
[0038] The following detailed description of the method, device, and media for rapid deployment of hybrid X86 and ARM architectures on a Kubernetes container cloud, with reference to the accompanying drawings and specific embodiments, is provided in reference to the present invention.
[0039] Example 1:
[0040] This embodiment provides a rapid hybrid deployment method for x86 and ARM architectures on a Kubernetes container cloud. This method directly deploys the JAR packages compiled from x86 and ARM servers to the container cloud, eliminating the need to write Dockerfiles to build images. Details are as follows:
[0041] S1. Compile the latest code to generate the application package;
[0042] S2. Provide a base image of an X86 and ARM operating system containing the program's runtime environment;
[0043] S3. Upload the application package to the FTP server according to business requirements;
[0044] S4. The application package runs in a Pod, and the Pod has one or more Init containers that start before the application container.
[0045] In this embodiment, step S1, compiling the latest code to generate the application package, is specifically as follows:
[0046] S101, Java applications are compiled into an "armpr.jar" application package on the ARM server;
[0047] S102, Java applications are compiled into an "x86pr.jar" application package on an x86 server.
[0048] In this embodiment, for Java applications, a base image containing the JDK environment is provided.
[0049] In this embodiment, for Java applications, the "armpr.jar" and "x86pr.jar" application packages are uploaded to the FTP server according to business requirements.
[0050] In step S4 of this embodiment, the Init containers include init container 1, init container 2, and init container 3;
[0051] Among them, the init container 1pause is the Pod's inherent container, used to maintain the Pod's network space;
[0052] container 2 init pulls the IP: / ftp / armpr.jar package to the / myapp directory and configures a shared directory;
[0053] The init container 3 runs dependent images and automatically mounts the init container 2 / myapp directory. At this time, the init container 3 has the application package / myapp / armpr.jar. After checking that the directory exists, the init container 3 runs the jar application package (Java-jar / myapp / armpr.jar). The whole process does not require manual configuration and management. The init container 3 automatically checks, assembles and runs the application.
[0054] The Init container in this embodiment has the following characteristics:
[0055] ① Always run until completion;
[0056] ② Each Init container must complete successfully before the next startup.
[0057] In this embodiment, the Pod's Init container and the container share storage.
[0058] In this embodiment, when a Pod specifies multiple Init containers, the multiple Init containers will run sequentially one by one; each Init container must run successfully before the next one can run; when all Init containers have finished running, Kubernetes will initialize the application container for the Pod and run it as usual.
[0059] Example 2:
[0060] This invention also provides an electronic device, including: a memory and a processor;
[0061] The memory stores the instructions executed by the computer.
[0062] The processor executes computer execution instructions stored in the memory, causing the processor to execute the hybrid rapid deployment method of x86 and ARM architecture on Kubernetes container cloud in any embodiment of the present invention.
[0063] The processor can be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), off-the-shelf programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The processor can be a microprocessor or any conventional processor.
[0064] Memory is 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 by accessing data stored in the memory. Memory can mainly include a program storage area and a data storage area. The program storage area can store the operating system, at least one application program required for a function, etc.; the data storage area can store data created based on the use of the terminal, etc. In addition, memory can also include high-speed random access memory, and can also include non-volatile memory, such as hard disks, RAM, plug-in hard disks, smart memory cards (SMC), secure digital cards (SD cards), flash memory cards, at least one disk storage device, flash memory device, or other volatile solid-state storage devices.
[0065] Example 3:
[0066] This embodiment also provides a computer-readable storage medium storing multiple instructions, which are loaded by a processor to cause the processor to execute the hybrid rapid deployment method for x86 and ARM architectures on a Kubernetes container cloud according to any embodiment of the present invention. Specifically, a system or apparatus equipped with a storage medium may be provided, on which software program code implementing the functions of any of the above embodiments is stored, and the computer (or CPU or MPU) of the system or apparatus may read and execute the program code stored in the storage medium.
[0067] In this case, the program code read from the storage medium can itself implement the function of any of the above embodiments, and therefore the program code and the storage medium storing the program code constitute part of the present invention.
[0068] Storage media embodiments 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-RYM, DVD-RW, DVD+RW), magnetic tapes, non-volatile memory cards, and ROMs. Alternatively, program code can be downloaded from a server computer via a communication network.
[0069] Furthermore, it should be clear that not only can the program code read by the computer be executed, but also the operating system or other components operating on the computer can be instructed based on the program code to perform some or all of the actual operations, thereby realizing the function of any of the embodiments described above.
[0070] Furthermore, it is understood that the program code read from the storage medium is written to the memory set in the expansion board inserted into the computer or to the memory set in the expansion unit connected to the computer. Then, based on the instructions of the program code, the CPU or other components installed on the expansion board or expansion unit execute some and all of the actual operations, thereby realizing the function of any of the embodiments described above.
[0071] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features; and these modifications or substitutions 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 mixed X86 and ARM architecture rapid deployment on a kubernetes container cloud, characterized in that, The method is based on X86 server and ARM server compilation generated jar package directly deployed to container cloud, no longer write Dockerfile to build image; The specific is as follows: Compile the latest code to generate application package; Provide an X86 and ARM operating system base image containing program running environment; Upload application package to FTP according to business requirements; Application package runs in Pod, Pod has one or more Init containers started before application container.
2. The method of claim 1, wherein the method further comprises: The specific steps of compiling the latest code to generate application package are as follows: Java application is compiled into "armpr.jar" application package on ARM server; Java application is compiled into "x86pr.jar" application package on X86 server.
3. The method of claim 1 or 2, wherein, For java application, provide a base image containing jdk environment.
4. The method of claim 3, wherein, For java application, upload "armpr.jar" and "x86pr.jar" application packages to FTP according to business requirements. 5.The method of claim 4, wherein, Init container includes init container 1, init container 2 and init container 3; Among them, init container 1 pause is Pod inherent container, used to maintain Pod network space; Init container 2 pulls IP: / ftp / armpr.jar package to / myapp directory, and configures shared directory; Init container 3 runs dependent image, automatically mounts / myapp directory of init container 2, and has / myapp / armpr.jar application package under init container 3 at this time, checks the existence of directory, and then init container 3 runs jar application package, the whole process does not need manual configuration management, and init container 3 automatically checks and splices and runs. 6.The method of claim 5, wherein, Init container has the following characteristics: ① Always run to completion; ② Each Init container must be successfully completed before the next one is started.
7. The method of claim 6, wherein the method further comprises: Pod's Init container and container share storage.
8. The method of claim 7, wherein the method further comprises: When a Pod specifies multiple Init containers, multiple Init containers will run sequentially; Each Init container must run successfully before the next one can run; When all Init containers run successfully, Kubernetes will initialize application container for Pod and run as usual.
9. An electronic device, comprising: It includes: Memory and at least one processor; The memory has a computer program stored thereon; The at least one processor executes the computer program stored in the memory, so that the at least one processor executes the kubernetes container cloud X86 and ARM architecture mixed rapid deployment method of any one of claims 1 to 8.
10. A computer readable storage medium characterized by The computer readable storage medium has a computer program stored therein, and the computer program can be executed by the processor to realize the kubernetes container cloud X86 and ARM architecture mixed rapid deployment method of any one of claims 1 to 8.