Layered rapid deployment method and device for large-scale application group

Abstract

The invention discloses a hierarchical rapid deployment method and device for a large-scale application group, and the method comprises the steps: S1, achieving the management and scheduling of a containerized application program based on a container arrangement engine Kubernetes; and S2, constructing a dependency relationship network of the applications through a dependency analysis algorithm, and realizing rapid deployment of the application groups under the same server and the application groups under different servers by adopting a layering strategy. According to the technical scheme, the deployment efficiency and the resource utilization rate are improved.

Description

Technical Field

[0001] The present invention belongs to the technical field of automated deployment of distributed applications, and particularly relates to a hierarchical rapid deployment method and device for large-scale application groups. Background Art

[0002] With the rapid development of microservices architecture and containerization technology, the deployment and management of application programs increasingly rely on container orchestration technology. Container orchestration technology is a tool and platform for managing and coordinating containerized application programs, which can automate the deployment, scaling, and management of containers, providing an efficient, reliable, and scalable way to run distributed applications.

[0003] The container orchestration engine is the core of container orchestration technology, responsible for packaging application programs into containers and performing automated deployment and management according to custom rules and policies. However, in the process of automated deployment, the deployment of multiple application dependencies easily leads to problems such as chaotic deployment order and frequent application restarts. Especially when it comes to the migration and rapid deployment of large-scale application groups, handling dependency relationships occupies a large amount of host resources. Summary of the Invention

[0004] The technical problem to be solved by the present invention is to provide a hierarchical rapid deployment method and device for large-scale application groups, so as to improve the deployment efficiency and resource utilization rate.

[0005] To achieve the above object, the present invention adopts the following technical solutions:

[0006] A hierarchical rapid deployment method for large-scale application groups, comprising:

[0007] Step S1: Based on the container orchestration engine Kubernetes, implement the management and scheduling of containerized application programs;

[0008] Step S2: Construct a dependency relationship network of applications through a dependency analysis algorithm, and adopt a hierarchical strategy to achieve the rapid deployment of application groups under the same server and application groups under different servers.

[0009] Preferably, the rapid deployment of a new application group under the same server includes:

[0010] Obtain the workload configuration file of the existing application group, and export the workload configuration files of the existing application group from Kubernetes, including Deployment, Service, ConfigMap, and Secret;

[0011] Use the mesh tracing analysis algorithm, combined with Nacos, configuration files, and environment variables, to parse the dependency relationships of each application;

[0012] Perform unified offset processing on the port mapping of the existing application group, and modify the port dependencies in the environment variables and configuration files of each application;

[0013] Copy the host-mounted files to the new mount directory, and batch-copy the host-mounted files of each application to the new mount directory; adopt the homologous directory detection algorithm to automatically replace or manually modify special paths;

[0014] Deploy the new application group in layers according to the dependency relationship, and automate the deployment of the application group in sequence according to the dependency relationship network of the applications.

[0015] Preferably, quickly deploy the new application group on different servers, including:

[0016] Install and run Kubernetes in the new server, and install and configure the Kubernetes container orchestration engine in the new server;

[0017] Obtain the workload configuration file of the existing application group, obtain the configuration file of the application group from the source server, and copy it to the new server;

[0018] Use the mesh tracing analysis algorithm to analyze the dependency relationship of the applications;

[0019] Copy the host-mounted files to the mount directory of the new server, copy the host-mounted files of each application to the mount path of the new server, and adopt the homologous directory detection algorithm to automatically replace or manually modify special paths;

[0020] Deploy the new application group in layers according to the dependency relationship.

[0021] Preferably, use the container lifecycle probe to detect the running status of the dependent applications, and deploy the application group in sequence according to the dependency relationship order.

[0022] The present invention also provides a hierarchical and rapid deployment device for a large-scale application group, including:

[0023] The first processing module is used to manage and schedule containerized application programs based on the container orchestration engine Kubernetes;

[0024] The second processing module is used to construct the dependency relationship network of the applications through the dependency analysis algorithm, and adopt a hierarchical strategy to achieve the rapid deployment of the application group under the same server and the application group under different servers.

[0025] Preferably, the second processing module is used to quickly deploy the new application group under the same server, including:

[0026] The first processing unit is used to obtain the workload configuration files of the existing application group, and export the workload configuration files of the existing application group from Kubernetes, including Deployment, Service, ConfigMap, and Secret;

[0027] The second processing unit is used to use the mesh tracing analysis algorithm, combine Nacos, configuration files, and environment variables to parse the dependency relationships of each application;

[0028] The third processing unit is used to perform unified offset processing on the port mappings of the existing application group, and modify the port dependencies in the environment variables and configuration files of each application;

[0029] The fourth processing unit is used to copy the host-mounted files to the new mount directory, batch copy the host-mounted files of each application to the new mount directory; use the homologous directory detection algorithm to automatically replace or manually modify special paths;

[0030] The fifth processing unit is used to deploy the new application group in layers according to the dependency relationships, and automate the deployment of the application group in sequence according to the dependency relationship network of the applications.

[0031] Preferably, the second processing module is used to quickly deploy the new application group under different servers, including:

[0032] The sixth processing unit is used to install and run Kubernetes in the new server, and install and configure the Kubernetes container orchestration engine in the new server;

[0033] The seventh processing unit is used to obtain the workload configuration files of the existing application group, obtain the configuration files of the application group from the source server, and copy them to the new server;

[0034] The eighth processing unit is used to analyze the dependency relationships of the applications using the mesh tracing analysis algorithm;

[0035] The ninth processing unit is used to copy the host-mounted files to the mount directory of the new server, copy the host-mounted files of each application to the mount path of the new server, and use the homologous directory detection algorithm to automatically replace or manually modify special paths;

[0036] The tenth processing unit is used to deploy the new application group in layers according to the dependency relationships.

[0037] Preferably, the second processing module uses container lifecycle probes to detect the running status of the dependent applications, and deploys the application group in sequence according to the dependency relationship order.

[0038] Based on the container orchestration engine Kubernetes, the present invention realizes the management and scheduling of containerized applications. By means of a dependency analysis algorithm, a dependency relationship network of the applications is constructed, and a hierarchical strategy is adopted to achieve the rapid deployment of application groups. Through the present invention, the rapid replication and deployment of existing applications can be effectively realized on the same server or different servers. Through dependency analysis and hierarchical deployment, the present invention effectively avoids the ineffective occupation of system resources, ensures that the startup sequence of each application conforms to its dependency requirements, and reduces unnecessary resource consumption during the startup process. The present invention can quickly replicate an existing application group to a new server or a new environment, and is particularly applicable to scenarios such as cluster migration, backup, and application group expansion. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] In order to more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the drawings required for the description of the embodiments or the prior art. Obviously, the drawings in the following description are only the embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can also be obtained according to the provided drawings.

[0040] Figure 1 It is a flowchart of a hierarchical rapid deployment method for large-scale application groups;

[0041] Figure 2 It is a flowchart of the deployment of an application group on the same server;

[0042] Figure 3 It is a flowchart of the deployment of an application group on different servers;

[0043] Figure 4 It is a flowchart of a mesh tracing analysis algorithm;

[0044] Figure 5 It is a flowchart of a homologous directory detection algorithm;

[0045] Figure 6 It is a flowchart of a hierarchical parallel deployment algorithm. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0046] The following will clearly and completely describe the technical solutions in the embodiments of the present invention with reference to the drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0047] To make the above objects, features, and advantages of the present invention more obvious and understandable, the present invention will be further described in detail below with reference to the drawings and specific embodiments.

[0048] Example 1:

[0049] As Figure 1 shown, an embodiment of the present invention provides a hierarchical rapid deployment method for large-scale application groups, including:

[0050] Step S1: Based on the container orchestration engine Kubernetes, manage and schedule containerized application programs;

[0051] Step S2: Build a dependency relationship network of the application through a dependency analysis algorithm, and adopt a hierarchical strategy to achieve rapid deployment of application groups under the same server and application groups under different servers.

[0052] As an implementation manner of the embodiment of the present invention, the rapid deployment of a new application group under the same server includes:

[0053] 11) Obtain the workload configuration file (YAML) of the existing application group, and export the workload configuration file of the existing application group from Kubernetes, including Deployment, Service, ConfigMap, and Secret;

[0054] 12) Analyze the dependencies of each application, use the mesh tracing analysis algorithm, and combine Nacos, configuration files, and environment variables to parse the dependencies of each application. Build a dependency relationship network of the application to ensure that the dependency relationship is clear and definite;

[0055] 13) Modify the port mapping and environment variables. To avoid port conflicts, perform a unified offset processing on the port mapping of the existing application group. Through a unified offset, modify the port dependencies in the environment variables and configuration files of each application to ensure isolation between the new application group and the existing application group;

[0056] 14) Copy the host-mounted files to the new mount directory, and batch-copy the host-mounted files of each application to the new mount directory. Use the same-source directory detection algorithm for the same-source directory, uniformly replace the source path, and special paths can be modified separately;

[0057] 15) Deploy the new application group in layers according to the dependency relationship. According to the dependency relationship network of the application, automatically deploy the application group in sequence. Adopt the method of detecting the container life cycle probe to detect the running status of the dependent application, and ensure that the corresponding application is started after all dependent services are started, avoiding frequent restarts and high resource occupancy;

[0058] As an implementation manner of the embodiment of the present invention, the rapid deployment of a new application group under different servers includes:

[0059] (21) Install and run Kubernetes in the new server, install and configure the Kubernetes container orchestration engine in the new server to provide an orchestration environment for the deployment of the new application group;

[0060] (22) Obtain the workload configuration file (YAML) of the existing application group, obtain the configuration file of the application group from the source server, and copy it to the new server;

[0061] (23) Analyze the dependencies of each application, use the mesh tracing analysis algorithm to analyze the dependencies of the applications to ensure that the dependencies in the new server are consistent;

[0062] (24) Copy the host-mounted files to the mount directory of the new server, copy the host-mounted files of each application to the mount path of the new server, and also use the same-source directory detection algorithm to automatically replace or manually modify special paths;

[0063] (25) Deploy the new application group in layers according to the dependencies, use the container lifecycle probe to detect the running status of the dependent applications, and deploy the application group in sequence according to the dependency order to ensure the stability and efficiency of the deployment process;

[0064] Furthermore, the mesh tracing analysis algorithm constructs a complete application dependency network by parsing the communication data, configuration files, and environment variables between applications; using this algorithm, the interaction mode between an application and its dependent services can be quickly identified, providing a basis for subsequent deployment. The same-source directory detection algorithm can automatically detect the source directory during the file mounting process of the application group, and batch replace the file mounting paths according to the directory structure of the new deployment environment. For special mounting paths, they can be modified individually through manual intervention. Container lifecycle probe detection uses container lifecycle probe detection technology to monitor the running status of each application during the application group deployment process, especially the startup status of the dependent applications. Probe detection can effectively avoid the problem of repeated restarts caused by the incomplete startup of dependent applications, thereby improving the deployment efficiency.

[0065] As an implementation method of the embodiment of the present invention, the fast deployment process on the same server is as Figure 2 shown. Taking the kubernetes container orchestration engine as an example, the specific implementation steps include:

[0066] (11) Obtain the workload configuration file (YAML) of the existing application group, including:

[0067] 111) From the existing Kubernetes cluster, use the Kubernetes command-line tool (kubectl) to obtain the workload configuration files of the target application group (such as YAML files like Deployment, StatefulSet, Service, ConfigMap, etc.). These files describe in detail the deployment structure, resource requirements, environment variables, port mappings, and service configurations of each application.

[0068] 112) Through the kubectl get command, the complete YAML configuration file of the existing application group can be extracted and used as the basis for the deployment of the new application group.

[0069] (12) Analyze the dependencies of each application, including:

[0070] 121) Use the mesh tracing analysis algorithm to analyze the dependencies between applications. Specifically, the dependencies of each service can be analyzed from the following aspects:

[0071] ① Nacos registry: Parse the service registration information in the Nacos service discovery platform to obtain the mutual call relationships between services.

[0072] ② Configuration file: Read the configuration file of the application (such as application.properties or application.yaml), and extract the dependency configurations such as the call addresses between services and database connection information from it.

[0073] ③ Environment variables: By analyzing the environment variables in the application container (such as the database host and service port it depends on), further understand the dependencies between services.

[0074] 122) Mesh tracing analysis algorithm: This algorithm constructs an application dependency network by parsing service logs, registry information, configuration files, and environment variables. This network shows the direct call relationships, indirect dependencies, and multi-level service dependency chains between applications. As Figure 4 shown, it includes the following steps:

[0075] ① Step S1221: Obtain the ports opened by each application and the ports it depends on;

[0076] ② Step S1222: Sum the number of times each port of the application is depended on, and the application with the largest number of dependencies is used as the searchRoot;

[0077] ③ Step S1223: Starting from the searchRoot application, find the dependent applications and construct a dependency chain. The dependent applications can continue to be used as the searchRoot;

[0078] ④ Step S1224: Repeat steps S1222 and S1223 until all applications are traversed to form an application dependency chain network.

[0079] (13) Modify port mapping and environment variables, including:

[0080] 131) Unified port mapping offset: To avoid port conflicts between newly deployed application groups and existing application groups, it is first necessary to add a unified offset to the port mapping of existing applications. The offset can be automatically generated based on the existing port range to ensure that the ports of each application group do not overlap. For example, if the existing application port is 8080, the port of the new application group can be adjusted to 18080.

[0081] 132) Modify environment variables or configuration files: By modifying the environment variables and service port configuration files in the YAML configuration, ensure that the service calls of the new application group and the port information of the dependencies correctly reflect the new offset. For complex multi-layer application architectures, it is also necessary to adjust the dependency addresses in the relevant configuration files.

[0082] (14) Copy the host-mounted files to the new mount directory, including:

[0083] 141) Homologous directory detection algorithm: This algorithm is used to detect whether the host directories mounted by applications have the same source path. For the same source directories, they can be batch-modified to the unified path of the new application group. For example, modify the path / data / app1 / to / data / new_app1 / . If there are special paths that need to be processed separately, modify these paths one by one according to actual requirements. As Figure 5 shown, the algorithm includes the following steps:

[0084] ① Step S1411: Obtain the complete absolute paths of the files and directories mounted by the application on the host;

[0085] ② Step S1412: Split the path into a directory chain;

[0086] ③ Step S1413: Perform a depth-first traversal on each directory chain to form multiple paths L from the root directory to its subdirectories (for example: if the directory chain is A->B->C, then after traversal, three paths A, A->B, and A->B->C can be formed);

[0087] ④ Step S1414: Calculate the frequency of occurrence of the same paths for all paths L formed in S1413. Among the paths with frequencies greater than 1, having the same frequency, and sharing the same root directory, select the deepest path (for example: if there are three paths A->B, A->B->C, and A->B->C-D that all appear 5 times, then select the path A->B->C-D) to construct a list S of homologous paths to be converted;

[0088] ⑤ Step S1415: Modify the deepest-level directory of each path in the list S of homologous paths to be converted in Step S1414 to form a converted path, and form a path conversion correspondence table.

[0089] 142) Mounted file copying: Use system tools (such as the rsync or cp command) to batch copy the application-related mounted files on the host to the new path. For a large number of file mounts, the copy tasks can be executed in parallel to reduce the operation time.

[0090] (15) Deploy the new application group in layers according to the dependency relationship, including:

[0091] 151) Dependency relationship layering strategy: According to the application dependency relationship network constructed previously, deploy the application group in layers. First, deploy the most basic dependent applications, such as databases, cache services, etc. After ensuring that they are fully started, then start the upper-layer applications that depend on these services in sequence. Through this step-by-step layering deployment method, the problem of frequent application restarts caused by unmet dependencies can be avoided.

[0092] 152) Container lifecycle probe detection: Monitor the startup and running status of each application through the probes of Kubernetes (such as liveness probe and readiness probe). The probes will regularly detect whether the dependent applications have been fully started and are ready. If the dependent service has not been fully started, the application that depends on it will be postponed from starting, thus avoiding ineffective startups, restarts, and waste of system resources.

[0093] 153) As Figure 6 shown, the layered deployment is carried out according to the following steps:

[0094] ① Step S1531: Set the number of parallel deployment trips T;

[0095] ② Step S1532: According to the application dependency chain, obtain the dependency frequency N of each application that has not been set with a priority;

[0096] ③ Step S1533: Take the application A corresponding to Max(N) in Step S1532, traverse all the dependency chains containing application A, and arrange them in descending order of chain length to form L;

[0097] ④ Step S1534: Traverse L in Step S1533, take one application from each chain in turn, and set the priority to Y (Y starts from 1 and is incremented by 1 after being used T times) until all the applications in each chain are set with priorities;

[0098] ⑤ Step S1535: Repeat Step S1532, Step S1533, and Step S1534;

[0099] ⑥ Step S1536: Layer the applications in ascending order of priority Y.

[0100] After layering the applications, ensure that the basic services (such as databases and caches) have been started. Start the upper-layer applications layer by layer according to the probe detection status, continuously monitor the application status, and perform scheduling and repair in a timely manner.

[0101] As an implementation manner of the embodiment of the present invention, the rapid deployment process under different servers is as Figure 3 shown, and the specific implementation steps include:

[0102] (21) Install and run Kubernetes in the new server, including:

[0103] 211) Install a Kubernetes cluster on the new server to ensure that it has the same configuration and orchestration environment as the source server. This can be done through standard Kubernetes installation methods (such as kubeadm or minikube).

[0104] 212) Configure the network, storage, and security policies of the new server to ensure that it can support the upcoming application group and ensure normal network communication.

[0105] (22) Obtain the workload configuration files (YAML) of the existing application group, including:

[0106] Obtain the workload configuration files of the existing application group (including Deployment, StatefulSet, etc.) from the source server and migrate these YAML files to the new server. This step can usually be achieved through a secure file transfer protocol (such as SCP or SFTP).

[0107] (23) Analyze the dependencies of each application, including:

[0108] 231) Execute the mesh tracing analysis algorithm again on the new server to ensure that the application dependencies remain unchanged in the new environment. At this time, it may be necessary to adjust the network addresses and environment variables of service calls to adapt to the network structure of the new server.

[0109] 232) Use tools such as Nacos to re-register the services to ensure normal communication between services.

[0110] (24) Copy the host-mounted files to the mount directory of the new server, including:

[0111] (241) In the new server, use the homologous directory detection algorithm to batch replace the mounted directories of the host. For those mounted directories that are the same as the source server, a unified directory structure can be used for replacement. Migrate the necessary application data and configuration files to the mounted directory of the new server through a network transfer tool (such as rsync).

[0112] (25) As Figure 6 shown, deploy the new application group in layers according to the dependency relationship, including:

[0113] ① Step S251: Set the number of parallel deployment schedules T;

[0114] ② Step S252: According to the application dependency chain, obtain the dependency frequency N of each application that has not been set with priorities currently;

[0115] ③ Step S253: Select the application A corresponding to Max(N) in Step S2, traverse all the dependency chains containing application A, and arrange them in descending order of chain length to form L;

[0116] ④ Step S254: Traverse L in Step S253, take one application from each chain in turn, and set the priority to Y (Y starts from 1 and is incremented by 1 after being used T times) until all the applications in each chain are set with priorities;

[0117] ⑤ Step S255: Repeat Step S252, Step S253, and Step S254;

[0118] ⑥ Step S256: Layer the applications in ascending order of priority Y;

[0119] After layering the applications, first start the infrastructure services such as the database and cache, start the dependency probe detection to ensure that all dependent application services are started in sequence and run normally, and use the rolling deployment function (Rolling Update) of Kubernetes to gradually release the application services to the new server to ensure the stable operation of the entire application group.

[0120] Embodiment 2:

[0121] The embodiment of the present invention also provides a hierarchical rapid deployment device for a large-scale application group, including:

[0122] The first processing module is used to manage and schedule containerized application programs based on the container orchestration engine Kubernetes;

[0123] The second processing module is used to construct the dependency relationship network of the application through the dependency analysis algorithm and implement the rapid deployment of the application group under the same server and the application group under different servers by adopting a hierarchical strategy.

[0124] As an implementation manner of an embodiment of the present invention, the second processing module is used to quickly deploy a new application group under the same server, including:

[0125] The first processing unit is used to obtain the workload configuration file of the existing application group, and export the workload configuration file of the existing application group from Kubernetes, including Deployment, Service, ConfigMap, and Secret;

[0126] The second processing unit is used to use the mesh tracing analysis algorithm, combine Nacos, the configuration file, and environment variables to analyze the dependency relationships of each application;

[0127] The third processing unit is used to perform a unified offset processing on the port mapping of the existing application group, and modify the port dependencies in the environment variables and configuration files of each application;

[0128] The fourth processing unit is used to copy the host-mounted files to the new mount directory, batch-copy the host-mounted files of each application to the new mount directory; adopt the same-source directory detection algorithm to automatically replace or manually modify special paths;

[0129] The fifth processing unit is used to deploy the new application group in layers according to the dependency relationships, and automatically deploy the application group in sequence according to the dependency relationship network of the applications.

[0130] As an implementation manner of an embodiment of the present invention, the second processing module is used to quickly deploy a new application group under different servers, including:

[0131] The sixth processing unit is used to install and run Kubernetes in the new server, and install and configure the Kubernetes container orchestration engine in the new server;

[0132] The seventh processing unit is used to obtain the workload configuration file of the existing application group, obtain the configuration file of the application group from the source server, and copy it to the new server;

[0133] The eighth processing unit is used to analyze the dependency relationships of the applications using the mesh tracing analysis algorithm;

[0134] The ninth processing unit is used to copy the host-mounted files to the mount directory of the new server, copy the host-mounted files of each application to the mount path of the new server, and adopt the same-source directory detection algorithm to automatically replace or manually modify special paths;

[0135] The tenth processing unit is used to deploy the new application group in layers according to the dependency relationships.

[0136] As an implementation manner of an embodiment of the present invention, the second processing module uses a container lifecycle probe to detect the running status of the dependent application, and deploys the application group in sequence according to the dependency relationship.

[0137] The above embodiments are only descriptions of the preferred manner of the present invention, and do not limit the scope of the present invention. Without departing from the design spirit of the present invention, various deformations and improvements made by those of ordinary skill in the art to the technical solution of the present invention shall fall within the protection scope determined by the claims of the present invention.

Claims

1. A hierarchical rapid deployment method for large-scale application groups, characterized in that: include: Step S1: Based on the container orchestration engine Kubernetes, management and scheduling of containerized applications are implemented; Step S2: construct an application dependency network through a dependency analysis algorithm, and adopt a hierarchical strategy to achieve rapid deployment of application groups on the same server and application groups on different servers.

2. The hierarchical rapid deployment method for large-scale application groups as claimed in claim 1, characterized in that: Rapidly deploy new application clusters on the same server, including: Obtain the workload configuration files of existing application groups and export the workload configuration files of existing application groups from Kubernetes, including Deployment, Service, ConfigMap, and Secret. Use the mesh tracking analysis algorithm, combined with Nacos, configuration files, and environment variables to analyze the dependencies of each application; Perform unified offset processing on the port mapping of the existing application group, and modify the port dependencies in the environment variables and configuration files of each application; Copy the host mount files to the new mount directory, and batch copy the host mount files of each application to the new mount directory; use the same source directory detection algorithm to automatically replace or manually modify special paths; Deploy new application groups in layers according to dependencies, and automatically deploy application groups in sequence based on the application dependency network.

3. The hierarchical rapid deployment method for large-scale application groups as claimed in claim 2, characterized in that: Rapidly deploy new application clusters on different servers, including: Install and run Kubernetes on the new server, and install and configure the Kubernetes container orchestration engine on the new server; Get the workload profile of the existing application group, get the application group profile from the source server, and copy it to the new server; Analyze application dependencies using mesh tracing analysis algorithms; Copy the host mount files to the mount directory of the new server, copy the host mount files of each application to the mount path of the new server, use the same-source directory detection algorithm, and automatically replace or manually modify special paths; Deploy new application clusters in layers based on dependencies.

4. The hierarchical rapid deployment method for large-scale application groups as claimed in claim 3, characterized in that: Use container lifecycle probes to detect the running status of dependent applications and deploy application groups in the order of dependencies.

5. A hierarchical rapid deployment device for large-scale application groups, characterized in that: include: The first processing module is used to manage and schedule containerized applications based on the container orchestration engine Kubernetes; The second processing module is used to construct an application dependency network through a dependency analysis algorithm, and adopt a layered strategy to achieve rapid deployment of application groups under the same server and application groups under different servers.

6. The hierarchical rapid deployment device for large-scale application groups as claimed in claim 5, characterized in that: The second processing module is used to quickly deploy a new application group on the same server, including: The first processing unit is used to obtain the workload configuration file of the existing application group and export the workload configuration file of the existing application group from Kubernetes, including Deployment, Service, ConfigMap, and Secret; The second processing unit is used to use the mesh tracking analysis algorithm, combined with Nacos, configuration files and environment variables, to parse the dependencies of each application; The third processing unit is used to perform unified offset processing on the port mapping of the existing application group and modify the port dependency in the environment variables and configuration files of each application; The fourth processing unit is used to copy the host mount files to the new mount directory, and batch copy the host mount files of each application to the new mount directory; adopt the same source directory detection algorithm to automatically replace or manually modify the special path; The fifth processing unit is used to deploy new application groups in layers according to dependency relationships, and automatically deploy application groups in sequence according to the dependency network of the applications.

7. The hierarchical rapid deployment device for large-scale application groups as claimed in claim 6, characterized in that: The second processing module is used to quickly deploy new application groups on different servers, including: A sixth processing unit is used to install and run Kubernetes in the new server, and install and configure the Kubernetes container orchestration engine in the new server; a seventh processing unit, configured to obtain a workload profile of an existing application group, obtain a profile of the application group from a source server, and copy the profile to a new server; an eighth processing unit, configured to analyze application dependencies using a mesh tracing analysis algorithm; The ninth processing unit is used to copy the host mount file to the mount directory of the new server, copy the host mount file of each application to the mount path of the new server, use the same source directory detection algorithm, and automatically replace or manually modify the special path; The tenth processing unit is used to deploy the new application group in layers according to dependency relationships.

8. The hierarchical rapid deployment device for large-scale application groups as claimed in claim 7, characterized in that: The second processing module uses a container lifecycle probe to detect the running status of dependent applications and deploys the application groups in the order of dependency.

Images