Java application slimming deployment method and system based on Docker in domestic CPU and OS environment

Abstract

The present invention discloses a method and system for slimming and deploying Java applications based on Docker in the domestic CPU and OS environment, belonging to the technical field of software development. The technical problem to be solved by the present invention is how to slim down Java applications and improve system resource utilization, thereby reducing the pressure on domestic environment servers and operation and maintenance. The adopted technical solution is as follows: This method separates Java applications into a common dependency component lib directory and business code using maven plugins and deploys them using Docker; for the business code with a size of 200 - 300 KB for each application after extraction, respective containers are created, and each application container is mounted with the common dependency directory. Multiple applications use the required functions from the common dependency, and through decoupling, the file size of the application system is reduced; specifically as follows: Extract the dependencies of the application to complete the slimming and packaging of the project; Use Docker containers for deployment; Use continuous integration tools for automated update deployment of subsequent system upgrades and operation and maintenance.

Description

Technical Field

[0001] The present invention relates to the technical field of software development, and in particular to a Docker-based java application slimming deployment method and system in a domestic CPU and OS environment. Background Art

[0002] With the development of domestic computer technology, large and medium-sized enterprises and government agencies have informatized their business functions, and application systems have become increasingly large as their businesses expand. In addition, with microservices as the mainstream system architecture solution, software applications in domestic CPU and OS environments have also shifted from a single architecture to microservices.

[0003] Currently, a system project may have as many as a dozen Java applications. If applications are deployed in the usual way, a single Java application will be 100-200 MB in size, and the entire system will be as large as 1-2 GB. When the system goes online, it will be necessary to upload hundreds of MB or several GB of deployment files for the first deployment or code update, which will cause considerable trouble for operation and maintenance personnel to deploy the system. In addition, the current domestic CPU and OS environment has a different architecture from the x86 server, and the server performance is lower than that of the x86 server. Starting these Java applications at the same time in this environment will cause certain pressure on the domestic environment server and increase the system overhead.

[0004] Therefore, how to slim down Java applications and improve system resource utilization, thereby reducing the pressure on domestic environment servers and operation and maintenance is a technical problem that needs to be solved urgently. Summary of the invention

[0005] The technical task of the present invention is to provide a Docker-based Java application slimming deployment method and system in a domestic CPU and OS environment to solve the problem of how to slim down Java applications, improve system resource utilization, and thus reduce the pressure on domestic environment servers and operations.

[0006] The technical task of the present invention is achieved in the following way: a slimming deployment method of Java application based on Docker in a domestic CPU and OS environment, which is to separate the Java application into a public dependency component lib directory and business code using a Maven plug-in, and deploy it using Docker; after extraction, each application has a business code size of 200-300KB and creates its own container, each application container is mounted with a public dependency directory, and multiple applications use the required functions from the public dependency, so that the file size of the application system is reduced by decoupling; the details are as follows:

[0007] Extract application dependencies and complete project slimming and packaging;

[0008] Deploy using Docker containers;

[0009] Use continuous integration tools to automate update deployment for subsequent system upgrades and maintenance.

[0010] As a preferred option, the project slimming and packaging is as follows:

[0011] Separate the Java application into two parts: dependencies and business code;

[0012] Separate the common dependencies of multiple Java applications into the same directory.

[0013] Preferably, the public dependency is used as a data volume container for multiple applications to mount and create corresponding containers; the public dependency update is as follows:

[0014] Add public dependencies to version control, and the update and change status of each project can be obtained from the version update record in a timely manner, making management more convenient;

[0015] Use automated integration tools to automatically deploy updates of public dependencies to the data volumes on the server where the data volume containers are mounted, greatly facilitating application system upgrades and maintenance.

[0016] Better yet, the project is slimmed down and packaged for SpringBoot, as follows:

[0017] Introduce the plug-in into the SpringBoot application configuration file;

[0018] Configure the location of the project's referenced dependency files and define the location according to the actual needs of the project deployment, so that the SpringBoot application can find the location of the dependency and use the dependency;

[0019] Configure the directory where the dependent jar files are extracted and stored, store the dependencies in the specified directory, and place this directory in the appropriate location on the server during deployment;

[0020] Use the Maven command to package the project. After packaging, the project is divided into dependency files and jar packages. Upload the dependency files and jar packages, store the common dependencies in the same directory, and store the application in a unified shared storage to complete the application slimming packaging.

[0021] As a preferred method, the deployment using Docker containers is as follows:

[0022] Use the docker command to create a data volume container with public dependencies;

[0023] Use a unified Java environment image suitable for domestic CPU and OS architecture. Each application uses this image to mount the application's unified shared storage directory to the specified directory in the container, and simultaneously mount the public dependency data volume container to create the corresponding container. The mounted data volume container does not need to remain in the running state. Set the Docker container to start automatically at boot to complete the Docker deployment.

[0024] As a preferred continuous integration tool, Jenkins is used. The specific details of Jenkins automated deployment are as follows:

[0025] Create a corresponding build project for each application in Jenkins, and clone the project from the application code repository on the host where Jenkins is located;

[0026] Each application build project is associated with the application clone directory and application code repository of the host where Jenkins is located, and the deployment command of each project is configured. After the configuration is completed, subsequent automatic update and deployment can be realized.

[0027] Preferably, automated update deployment means that each application corresponds to a build project. After each application build is configured, the application packaging, uploading, and container restart can be automatically completed. The application deployment is as follows:

[0028] After the first deployment details are completed based on Docker, the subsequent operation and maintenance deployment uses continuous integration tools to achieve automatic update deployment of the application;

[0029] Each application creates a dedicated project in the continuous integration tool, which is associated with the application code repository;

[0030] Configure the deployment command in the project. After clicking Build for subsequent deployments, the continuous integration tool can use the latest code of the application to package the application.

[0031] Upload the packaged application to the server and restart the application container to complete the application update deployment, thereby reducing the deployment difficulty for operation and maintenance personnel.

[0032] A java application slimming deployment system based on Docker in a domestic CPU and OS environment, the system includes:

[0033] The extraction unit is used to separate the Java application into two parts: public dependencies and business code, and then extract the application dependencies to complete the project slimming and packaging;

[0034] The deployment module is used to deploy using Docker containers, that is, to create a public dependency data volume container, mount the application's unified shared storage directory to a specified location in the container, and simultaneously mount the public dependency data volume container to create each application container;

[0035] The update module is used to use continuous integration tools to perform automated update deployment for later system upgrades and maintenance. That is, the application container is set to start automatically at startup, and the later system upgrades and maintenance use continuous integration tools to achieve automated update deployment.

[0036] Preferably, the extraction unit is applied to SpringBoot, including:

[0037] Import submodules to introduce plug-ins into the configuration files of SpringBoot applications;

[0038] Configuration submodule 1 is used to configure the location of the project reference dependency files. The location is defined according to the actual needs of the project deployment, so that the SpringBoot application can find the location of the dependency and use the dependency;

[0039] Configuration submodule 2 is used to configure the directory where the dependent jars are extracted and stored. Dependencies are stored in the specified directory. When deploying, just put this directory in the appropriate location on the server.

[0040] The packaging submodule is used to package the project using the Maven command. After packaging, the project is divided into dependency files and jar packages. The dependency files and jar packages are uploaded, the common dependencies are stored in the same directory, and the applications are stored in a unified shared storage to complete the application slimming packaging;

[0041] The deployment module includes:

[0042] Create a submodule to create a data volume container with public dependencies using the docker command;

[0043] The mount submodule is used to use a unified Java environment image suitable for domestic CPU and OS architecture. Each application uses this image to mount the application's unified shared storage directory to the specified directory in the container, and at the same time mount the public dependency data volume container to create the corresponding container. The mounted data volume container does not need to be kept in the running state. Set the Docker container to start automatically at boot to complete the Docker deployment;

[0044] The continuous integration tool uses Jenkins, and the update modules are as follows:

[0045] The cloning submodule is used to create a corresponding build project for each application in Jenkins and clone the project from the application code repository on the host where Jenkins is located;

[0046] The association submodule is used to associate each application build project with the application clone directory and application code repository of the host where Jenkins is located, and configure the deployment command of each project. After the configuration is completed, subsequent automatic update and deployment can be realized.

[0047] A computer-readable storage medium, characterized in that a computer program is stored in the computer-readable storage medium, and the computer program can be executed by a processor to implement the Docker-based Java application slimming deployment method in the domestic CPU and OS environment as mentioned above.

[0048] The Docker-based Java application slimming deployment method and system in the domestic CPU and OS environment of the present invention have the following advantages:

[0049] (I) The present invention uses a Maven plug-in to separate a Java application into a public dependency component lib directory and business code, and uses Docker to deploy them; after extraction, each application has a business code of only two to three hundred KB in size to create its own container, and each application container is mounted with the public dependency directory. A dozen applications only need to use the required functions from the public dependency, instead of deploying the commonly used dependencies and their own business code together as before. In this way, the file size of the entire system can be greatly reduced through decoupling;

[0050] (2) Project slimming and packaging will significantly reduce the size of the application system; deploying applications in Docker containers will improve the application's operating performance and reduce the system overhead of servers in domestic CPU and OS environments, freeing up more server system resources for other applications. In terms of operation and maintenance, Docker containers are fast and light, with a startup time of seconds, which greatly saves deployment time;

[0051] (III) The present invention solves the time-consuming problem of uploading files for the first deployment of a Java microservice project by decoupling applications;

[0052] (IV) The present invention utilizes Docker deployment to greatly improve the utilization rate of server system resources and application performance under the domestic CPU and OS architecture, reduce server system overhead, and release more server system resources for other applications to use, thus effectively solving the problem of server performance bottlenecks caused by the huge application system under the domestic CPU and OS environment;

[0053] (V) The present invention allows operation and maintenance to update only a small volume of business code when updating the code, thus solving the problem of having to upload a large number of files for each update;

[0054] (VI) The present invention can check the changes of public dependencies through version control, solving the problem of chaotic operation and maintenance management;

[0055] (VII) The present invention can use automated deployment tools such as Jenkins to automatically update and deploy projects, making operation and maintenance work simple and convenient. BRIEF DESCRIPTION OF THE DRAWINGS

[0056] The present invention is further described below in conjunction with the accompanying drawings.

[0057] Attached Figure 1 A schematic diagram for extracting dependencies;

[0058] Attached Figure 2 Deploy a sample diagram for a container. DETAILED DESCRIPTION

[0059] The following detailed description is made of the Java application slimming deployment method and system based on Docker in the domestic CPU and OS environment of the present invention with reference to the accompanying drawings and specific embodiments of the specification.

[0060] Embodiment 1:

[0061] The invention discloses a java application slimming deployment method based on Docker in a domestic CPU and OS environment. The method is to separate the java application into a public dependency component lib directory and business code by using a Maven plug-in, and deploy the java application by using Docker. After the separation, each business code of the application with a size of 200-300KB is used to create its own container. Each application container is mounted with a public dependency directory. Multiple applications use the required functions from the public dependency. The file size of the application system is reduced by decoupling. The details are as follows:

[0062] S1. Extract the application dependencies and complete the project slimming and packaging;

[0063] S2. Deploy using Docker containers;

[0064] S3. Use continuous integration tools to automate update deployment for subsequent system upgrades and maintenance.

[0065] In this embodiment, the project slimming and packaging of step S1 is specifically as follows:

[0066] S101. Separate the Java application into two parts: dependency and business code;

[0067] S102. Separate the common dependencies of multiple Java applications into the same directory, as shown in the following figure. Figure 2 As shown in the figure, the originally reusable dependencies are extracted to a unified directory, which greatly reduces the size of the application system.

[0068] The public dependency in this embodiment is used as a data volume container for multiple applications to mount and create corresponding containers; the public dependency update is as follows:

[0069] (1) Add public dependencies to version control, so that each project's update changes can be timely obtained from the version update record, making management more convenient;

[0070] (2) Use automated integration tools to automatically deploy updates of common dependencies to the data volume on the server where the data volume container is mounted, which greatly facilitates application system upgrades and maintenance.

[0071] The project slimming and packaging in step S1 of this embodiment is applied to SpringBoot, as follows:

[0072] (1) Introduce the plug-in into the configuration file of the SpringBoot application;

[0073] (2) Configure the location of the project's referenced dependency files and define the location according to the actual requirements of the project deployment, so that the SpringBoot application can find the location of the dependency and use the dependency;

[0074] (3) Configure the directory where the dependent jar files are extracted and stored, store the dependencies in the specified directory, and place this directory in the appropriate location on the server during deployment;

[0075] (4) Use the Maven command to package the project. After packaging, the project is divided into dependency files and jar packages. Upload the dependency files and jar packages, store the common dependencies in the same directory, and store the application in a unified shared storage to complete the application slimming packaging.

[0076] Since the startup of Docker container can be realized in seconds and the utilization rate of system resources is high, and the container basically consumes no additional system resources except for running the application in it, the performance of the application is very high. The use of Docker can well solve the problem of server performance bottleneck caused by the huge application system in the domestic CPU and OS environment. For the public dependency part, since the application dependency package needs to be updated when the system is upgraded later, it is chosen to create it as a data volume container, which specifically provides data volumes for other application containers to mount. The use of data volume containers can better manage the relationship between containers and data volumes, and more reasonably control the life cycle of data volumes.

[0077] Applications use the data volume container of common dependencies to create their corresponding containers. Each application creates a container by mounting a unified shared storage directory with a specified directory in the container. The advantage of creating one container for one application is that the applications do not interfere with each other. Even if one application cannot provide services normally, it does not affect the operation of other applications. In addition, the application can make full use of the system resources in the container to improve the performance of the application. By using the container network mechanism, the network between different containers is connected so that each application container can communicate with each other.

[0078] As attached Figure 1 As shown, the deployment using the Docker container in step S2 of this embodiment is as follows:

[0079] S201. Use the docker command to create a data volume container for public dependencies;

[0080] S202. Use a unified Java environment image suitable for domestic CPU and OS architecture. Each application uses this image to mount the application's unified shared storage directory to the specified directory in the container, and simultaneously mount the public dependency data volume container to create the corresponding container. The mounted data volume container does not need to remain in the running state. Set the Docker container to start automatically at boot to complete the Docker deployment.

[0081] In this embodiment, the continuous integration tool in step S3 is Jenkins, and the Jenkins automated deployment is as follows:

[0082] S301. Create a corresponding build project for each application in Jenkins, and clone the project from the application code repository on the host where Jenkins is located;

[0083] S302. Each application build project is associated with the application clone directory and application code repository of the host where Jenkins is located, and the deployment command of each project is configured. After the configuration is completed, subsequent automatic update deployment is realized.

[0084] In this embodiment, the automatic update deployment means that each application corresponds to a build project. After configuring the build of each application, the packaging, uploading and container restart of the application can be automatically completed; the deployment of the application is as follows:

[0085] ① After the first deployment details are completed based on Docker, the subsequent operation and maintenance deployment uses continuous integration tools to achieve automatic update deployment of the application;

[0086] ② Each application creates a dedicated project in the continuous integration tool, and the project is associated with the application code repository;

[0087] ③. Configure the deployment command in the project. After clicking Build for subsequent deployment, the continuous integration tool can use the latest code of the application to package the application.

[0088] ④. Upload the packaged application to the server and restart the application container to complete the application update deployment, thereby reducing the deployment difficulty for operation and maintenance personnel.

[0089] Embodiment 2:

[0090] The java application slimming deployment system based on Docker in the domestic CPU and OS environment of the present invention comprises:

[0091] The extraction unit is used to separate the Java application into two parts: public dependencies and business code, and then extract the application dependencies to complete the project slimming and packaging;

[0092] The deployment module is used to deploy using Docker containers, that is, to create a public dependency data volume container, mount the application's unified shared storage directory to a specified location in the container, and simultaneously mount the public dependency data volume container to create each application container;

[0093] The update module is used to use continuous integration tools to perform automated update deployment for later system upgrades and maintenance. That is, the application container is set to start automatically at startup, and the later system upgrades and maintenance use continuous integration tools to achieve automated update deployment.

[0094] The extraction unit in this embodiment is applied to SpringBoot, including:

[0095] Import submodules to introduce plug-ins into the configuration files of SpringBoot applications;

[0096] Configuration submodule 1 is used to configure the location of the project reference dependency files. The location is defined according to the actual needs of the project deployment, so that the SpringBoot application can find the location of the dependency and use the dependency;

[0097] Configuration submodule 2 is used to configure the directory where the dependent jars are extracted and stored. Dependencies are stored in the specified directory. When deploying, just put this directory in the appropriate location on the server.

[0098] The packaging submodule is used to package the project using the Maven command. After packaging, the project is divided into dependency files and jar packages. The dependency files and jar packages are uploaded, the common dependencies are stored in the same directory, and the applications are stored in a unified shared storage to complete the application slimming packaging;

[0099] The deployment module in this embodiment includes:

[0100] Create a submodule to create a data volume container with public dependencies using the docker command;

[0101] The mount submodule is used to use a unified Java environment image suitable for domestic CPU and OS architecture. Each application uses this image to mount the application's unified shared storage directory to the specified directory in the container, and at the same time mount the public dependency data volume container to create the corresponding container. The mounted data volume container does not need to be kept in the running state. Set the Docker container to start automatically at boot to complete the Docker deployment;

[0102] The continuous integration tool in this embodiment uses Jenkins, and the update module is as follows:

[0103] The cloning submodule is used to create a corresponding build project for each application in Jenkins and clone the project from the application code repository on the host where Jenkins is located;

[0104] The association submodule is used to associate each application build project with the application clone directory and application code repository of the host where Jenkins is located, and configure the deployment command of each project. After the configuration is completed, subsequent automatic update and deployment can be realized.

[0105] Embodiment 3:

[0106] The embodiment of the present invention also provides a computer-readable storage medium, which stores a plurality of instructions, which are loaded by a processor, so that the processor executes the Docker-based Java application slimming deployment method in a domestic CPU and OS environment in any embodiment of the present invention. Specifically, a system or device equipped with a storage medium can be provided, on which a software program code that implements the functions of any of the above embodiments is stored, and a computer (or CPU or MPU) of the system or device reads and executes the program code stored in the storage medium.

[0107] 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 a part of the present invention.

[0108] The storage medium embodiments for providing the program code include a floppy disk, a hard disk, a magneto-optical disk, an optical disk (such as CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RYM, DVD-RW, DVD+RW), a magnetic tape, a non-volatile memory card, and a ROM. Alternatively, the program code can be downloaded from a server computer via a communication network.

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

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

[0111] 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 aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned 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 Docker-based Java application slimming deployment method in a domestic CPU and OS environment. It is characterized in that The method is to use the Maven plug-in to separate the Java application into a public dependency component lib directory and business code, and use Docker to deploy them; after extraction, each application creates its own container with a business code size of 200-300KB, and each application container is mounted with the public dependency directory. Multiple applications use the required functions from the public dependency, and the file size of the application system is reduced by decoupling; the details are as follows: Extract application dependencies and complete project slimming and packaging; Deploy using Docker containers; Use continuous integration tools to automate update deployment for later system upgrades and maintenance; Among them, the project slimming and packaging are as follows: Separate the Java application into two parts: dependencies and business code; Separate the common dependencies of multiple Java applications into the same directory; The project slimming packaging is applied to SpringBoot, as follows: Introduce the plug-in into the SpringBoot application configuration file; Configure the location of the project's referenced dependency files and define the location according to the actual needs of the project deployment, so that the SpringBoot application can find the location of the dependency and use the dependency; Configure the directory where the dependent jar files are extracted and stored, store the dependencies in the specified directory, and place this directory in the appropriate location on the server during deployment; Use Maven command to package the project. After packaging, the project is divided into dependency files and jar packages. Upload the dependency files and jar packages, store the common dependencies in the same directory, and store the application in a unified shared storage to complete the application slimming packaging. The continuous integration tool uses Jenkins, and the Jenkins automated deployment is as follows: Create a corresponding build project for each application in Jenkins, and clone the project from the application code repository on the host where Jenkins is located; Each application build project is associated with the application clone directory and application code repository of the host where Jenkins is located, and the deployment command of each project is configured. After the configuration is completed, subsequent automatic update and deployment can be realized; Automated update deployment means that each application corresponds to a build project. After configuring the build of each application, the application packaging, uploading, and container restart can be automatically completed. The deployment of the application is as follows: After the first deployment details are completed based on Docker, the subsequent operation and maintenance deployment uses continuous integration tools to achieve automatic update deployment of the application; Each application creates a dedicated project in the continuous integration tool, which is associated with the application code repository; Configure the deployment command in the project. After clicking Build for subsequent deployments, the continuous integration tool can use the latest code of the application to package the application. Upload the packaged application to the server and restart the application container to complete the application update deployment.

2. According to the method for slimming down and deploying Java applications based on Docker in a domestic CPU and OS environment as described in claim 1, It is characterized in that Public dependencies are used as data volume containers for multiple applications to mount and create corresponding containers. The public dependency updates are as follows: Add public dependencies to version control, and the update changes of each project can be obtained from the version update record in a timely manner; Use automated integration tools to automatically deploy updates to common dependencies to the data volumes mounted on the server by the data volume container.

3. According to the method for slimming down and deploying Java applications based on Docker in a domestic CPU and OS environment as described in claim 1, It is characterized in that The deployment using Docker container is as follows: Use the docker command to create a data volume container with public dependencies; Use a unified Java environment image suitable for domestic CPU and OS architecture. Each application uses this image to mount the application's unified shared storage directory to the specified directory in the container, and simultaneously mount the public dependency data volume container to create the corresponding container. The mounted data volume container does not need to remain in the running state. Set the Docker container to start automatically at boot to complete the Docker deployment.

4. A Java application slimming deployment system based on Docker in domestic CPU and OS environment, It is characterized in that The system includes, The extraction unit is used to separate the Java application into two parts: public dependencies and business code, and then extract the application dependencies to complete the project slimming and packaging; The deployment module is used to deploy using Docker containers, that is, to create a public dependency data volume container, mount the application's unified shared storage directory to a specified location in the container, and simultaneously mount the public dependency data volume container to create each application container; The update module is used to use continuous integration tools to automate the update deployment of later system upgrades and maintenance. That is, the application container is set to start automatically at startup, and the subsequent system upgrades and maintenance use continuous integration tools to achieve automated update deployment; Among them, the extraction unit is applied to SpringBoot, including: Import submodules to introduce plug-ins into the configuration files of SpringBoot applications; Configuration submodule 1 is used to configure the location of the project reference dependency files. The location is defined according to the actual needs of the project deployment, so that the SpringBoot application can find the location of the dependency and use the dependency; Configuration submodule 2 is used to configure the directory where the dependent jars are extracted and stored. Dependencies are stored in the specified directory. When deploying, just put this directory in the appropriate location on the server. The packaging submodule is used to package the project using the Maven command. After packaging, the project is divided into dependency files and jar packages. The dependency files and jar packages are uploaded, the common dependencies are stored in the same directory, and the applications are stored in a unified shared storage to complete the application slimming packaging; The continuous integration tool uses Jenkins, and the update modules are as follows: The cloning submodule is used to create a corresponding build project for each application in Jenkins and clone the project from the application code repository on the host where Jenkins is located; The association submodule is used to associate each application build project with the application clone directory and application code repository of the host where Jenkins is located, and configure the deployment command of each project. After the configuration is completed, the subsequent automatic update deployment can be realized; Automated update deployment means that each application corresponds to a build project. After configuring the build of each application, the application packaging, uploading, and container restart can be automatically completed. The deployment of the application is as follows: After the first deployment details are completed based on Docker, the subsequent operation and maintenance deployment uses continuous integration tools to achieve automatic update deployment of the application; Each application creates a dedicated project in the continuous integration tool, which is associated with the application code repository; Configure the deployment command in the project. After clicking Build for subsequent deployments, the continuous integration tool can use the latest code of the application to package the application. Upload the packaged application to the server and restart the application container to complete the application update deployment.

5. According to claim 4, the Java application slimming deployment system based on Docker in the domestic CPU and OS environment, It is characterized in that The deployment module includes: Create a submodule to create a data volume container with public dependencies using the docker command; The mounting submodule is used to use a unified Java environment image suitable for domestic CPU and OS architecture. Each application uses this image to mount the application's unified shared storage directory to the specified directory in the container, and simultaneously mounts the public dependency data volume container to create the corresponding container. The mounted data volume container does not need to remain in the running state. Set the Docker container to start automatically at boot to complete the Docker deployment.

6. A computer-readable storage medium, It is characterized in that The computer-readable storage medium stores a computer program, which can be executed by a processor to implement the Docker-based Java application slimming deployment method in a domestic CPU and OS environment as described in any one of claims 1 to 3.

Images