A lightweight cloud-native application deployment method for multi-operating system hybrid systems

By adopting a lightweight hierarchical scheduling architecture and cross-language adaptation mechanism, the problem of unified deployment in multi-operating system environments is solved, achieving efficient resource utilization and improved iterative stability, making it suitable for lightweight cloud-native deployment of multi-language applications.

CN123114508APending Publication Date: 2026-11-17BEIJING JINHONGRUI INFORMATION TECH CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611249302.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-18
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

Existing technologies cannot achieve unified scheduling and deployment in multi-operating system environments. Traditional cloud-native architectures have high resource overhead, cannot run on low-configuration edge nodes, and lack a unified deployment process and canary iteration mechanism, resulting in high risk and slow iteration for version updates.

Method used

It adopts a lightweight hierarchical scheduling architecture, maintains node management and task scheduling through a distributed consistency mechanism, scans heterogeneous operating system nodes, builds resource profiles, achieves cross-language runtime adaptation, combines a three-dimensional scheduling strategy for unified deployment, and supports canary iteration and self-healing rollback mechanisms.

Benefits of technology

It enables lightweight and unified deployment in heterogeneous operating system environments, reduces resource consumption, supports unified scheduling and canary releases of multi-language applications, improves iteration stability and deployment efficiency, and reduces version update risks.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114508A_ABST
    Figure CN123114508A_ABST
Patent Text Reader

Abstract

This invention belongs to the field of cloud computing and distributed systems technology, specifically relating to a lightweight cloud-native application deployment method for multi-operating system hybrid deployments. This invention proposes a novel, lightweight, cross-heterogeneous operating system deployment method that supports unified multi-language execution. Through a layered scheduling architecture, a multi-language runtime adaptation mechanism, unified declarative deployment logic, and a canary iteration operation and maintenance mechanism, it solves the unified deployment challenge in multi-system hybrid scenarios. The lightweight distributed scheduling architecture of this invention requires no heavy cloud-native components, has extremely low resource consumption, and is adaptable to heterogeneous edge clusters. It pioneers a multi-language runtime normalization adaptation mechanism, simultaneously compatible with all types of business applications including Java, Python, C, and C++. It possesses lightweight canary release and ultra-fast rollback capabilities, significantly improving the iterative stability of multi-language heterogeneous clusters.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention belongs to the field of cloud computing and distributed system technology, specifically relating to a lightweight cloud-native application deployment method for multi-operating system hybrid systems. Background Technology

[0002] Currently, government and enterprise application clusters and industrial edge clusters commonly feature mixed deployments of multiple operating systems, with cluster nodes containing heterogeneous systems such as Linux, Windows, domestic Kylin, and UnionTech UOS. Simultaneously, business applications exhibit multi-language development characteristics, including Java microservices, Python analysis programs, C / C++ high-performance computing programs, and C language low-level data acquisition programs. Traditional cloud-native deployment systems heavily rely on heavy-duty orchestration architectures, resulting in numerous components, high resource consumption, poor compatibility with heterogeneous operating systems, and an inability to uniformly manage container applications and native process applications.

[0003] Existing technologies generally suffer from the following problems:

[0004] 1. Different operating system nodes need to be deployed and maintained independently, making unified scheduling impossible;

[0005] 2. The runtime environments for various programming languages ​​differ greatly, requiring separate deployment plans and making it impossible to unify the pipeline;

[0006] 3. Traditional cloud-native architectures are cumbersome and cannot run on low-configuration edge nodes, lacking lightweight capabilities;

[0007] 4. The application lacks a standardized deployment process and a canary iteration mechanism, resulting in high risks and slow rollback for version updates. Summary of the Invention

[0008] To address the aforementioned issues, this invention proposes a novel, lightweight, cross-heterogeneous operating system deployment method for cloud-native applications that supports unified operation across multiple languages. Through a layered scheduling architecture, a multi-language runtime adaptation mechanism, unified declarative deployment logic, and a canary iterative operation and maintenance mechanism, it solves the challenge of unified deployment in multi-system hybrid scenarios.

[0009] The technical solution adopted in this invention is as follows:

[0010] A lightweight cloud-native application deployment method for multi-operating system hybrid environments includes:

[0011] A simplified distributed scheduling cluster is launched at the scheduling control layer. It maintains the four core capabilities of node management, task scheduling, configuration parsing and state synchronization through a distributed consistency mechanism, eliminating heavy and redundant orchestration components.

[0012] Scan heterogeneous operating system nodes within the cluster, including Linux nodes, Windows nodes, Kylin nodes, and UnionTech UOS nodes. A unified lightweight agent program deployed on each node reports the operating system type, kernel architecture, dynamic library version, CPU and memory resources, and available language runtime environment, thereby constructing a heterogeneous node resource profile and a global scheduling resource pool.

[0013] Runtime normalization adaptation is performed on the Java, Python, C, and C++ applications to be deployed: for Java applications, virtual machine startup parameters are unified and path and permission differences are masked; for Python applications, interpreter versions are unified and third-party dependencies are normalized; for C / C++ applications, cross-system compilation and linking rules are unified and dynamic library call interfaces are adapted. Then, redundant debugging files and invalid resources are trimmed to generate a cross-system lightweight deployment package.

[0014] The optimal node is matched based on a three-dimensional strategy of "system compatibility + language compatibility + real-time node load". When there is no optimal native node, it runs in a compatible environment through the built-in cross-system adaptation environment and sends deployment instructions to the target node agent.

[0015] The target node agent pulls the deployment package, completes environment initialization, permission adaptation and application launch in containerized mode or system native process mode, and performs health checks;

[0016] During version iteration, instances of new and old versions are run in parallel, and traffic is distributed in a gradient of 10% → 50% → 100%. Java memory anomalies, missing Python dependencies, C / C++ dynamic link failures, and cross-system permission conflicts are monitored in real time. In case of anomalies, the scheduling weight is adjusted to switch back to the stable version without rebuilding the image or the runtime environment.

[0017] Furthermore, the lightweight agent program resides on each heterogeneous node, performs automatic cluster registration, periodic reporting of resource status, and environmental information detection, and preloads a multi-language adaptation environment for Java / Python / C / C++.

[0018] Furthermore, in the three-dimensional scheduling strategy: Java and Python applications are preferentially scheduled to Linux or domestic operating system nodes, and C / C++ applications are preferentially scheduled to Windows nodes; when the target language does not have a native runtime environment on the candidate node, the built-in cross-system adaptation environment is enabled to achieve compatible operation.

[0019] Furthermore, the health check includes: detecting the application process status, interface availability, and language runtime status; and triggering a redeployment adaptation instead of just issuing an alarm when the check fails.

[0020] Furthermore, the ultra-fast rollback achieves second-level flow switching by retaining the stable version instance in the resource pool and only modifying the traffic scheduling weight and the process start-up direction of the node agent, without involving deployment package reconstruction.

[0021] A lightweight cloud-native application deployment system for multi-operating system hybrid environments includes:

[0022] The scheduling and control layer contains a simplified distributed scheduling cluster for execution node management, task scheduling, configuration parsing, and state synchronization.

[0023] The heterogeneous node resource layer includes Linux, Windows, Kylin, and UnionTech UOS nodes. Each node deploys a unified lightweight agent program, supporting both containerized application scheduling and system native process scheduling modes.

[0024] The application management layer includes a multi-language runtime normalization adaptation module, a lightweight encapsulation module, a health detection module, a canary release module, and an exception self-healing rollback module;

[0025] Among them, the scheduling and control layer issues instructions to the node agent based on the heterogeneous node resource profile and three-dimensional scheduling strategy, and the application management and control layer performs runtime normalization, gray-scale flow switching and weight rollback.

[0026] The beneficial effects of this invention are:

[0027] 1. Lightweight distributed scheduling architecture, no need for heavy cloud-native components, extremely low resource consumption, and adaptable to heterogeneous edge clusters;

[0028] 2. Achieve unified scheduling and deployment for mixed environments with multiple operating systems, including Linux, Windows, and domestically developed operating systems;

[0029] 3. It pioneered a multi-language runtime normalization adaptation mechanism, which is compatible with all types of business applications including Java, Python, C, and C++.

[0030] 4. It supports unified management of both container applications and native system processes, adapting to various business models;

[0031] 5. Build a lightweight, fully automated deployment system to replace traditional manual script deployment, resulting in high deployment efficiency and strong consistency;

[0032] 6. It has lightweight canary release and ultra-fast rollback capabilities, which greatly improves the iteration stability of multi-language heterogeneous clusters. Attached Figure Description

[0033] Figure 1 This is a schematic diagram of the overall architecture for a lightweight cloud-native deployment that integrates multiple operating systems.

[0034] Figure 2This is a schematic diagram of the lightweight unified deployment process for multilingual applications.

[0035] Figure 3 This is a diagram illustrating the principles of lightweight grayscale deployment and rapid self-healing rollback. Detailed Implementation

[0036] The technical solution of the present invention will now be described in detail with reference to the accompanying drawings.

[0037] This invention adopts a three-layer lightweight heterogeneous deployment architecture, realizing a full-link deployment system from top-level scheduling, middle-layer heterogeneous node resources, and bottom-level application operation management. It does not rely on traditional heavy cloud-native orchestration architecture, and the overall architecture is lightweight, cross-platform, and multi-language compatible.

[0038] The overall architecture is divided into three layers:

[0039] 1. Lightweight distributed scheduling and control layer:

[0040] A minimalist distributed scheduling cluster is constructed, employing a distributed consistency mechanism to complete global task decisions. Only core capabilities such as task scheduling, node management, configuration parsing, and state synchronization are retained, while all redundant components are removed. The scheduling layer has extremely low overall resource consumption and is adaptable to various application environments. The scheduling layer is responsible for uniformly receiving application deployment tasks, parsing deployment rules, matching the best node, and issuing execution instructions.

[0041] 2. Multi-operating system heterogeneous node resource layer:

[0042] The cluster connects to heterogeneous nodes including Linux, Windows, and domestic operating systems (Kylin, UnionTech UOS). All nodes deploy a unified lightweight agent program to achieve automatic cluster registration, status reporting, and resource detection. The node layer supports both containerized application scheduling and system native process scheduling, enabling unified management of different types of business applications such as microservices, executable programs, and script processes.

[0043] 3. Multilingual application operation and full lifecycle management layer:

[0044] A unified runtime adaptation system is built for four mainstream programming languages: Java, Python, C, and C++. Through runtime environment normalization, dependency auto-completion, and cross-system interface adaptation, it enables consistent operation of multi-language applications on any heterogeneous nodes. It also integrates deployment verification, health checks, canary releases, anomaly self-healing, and rapid rollback capabilities, achieving full lifecycle management of applications from deployment, operation, iteration to fault recovery.

[0045] The present invention proposes a lightweight, cross-system, multi-language compatible automated deployment method, which is divided into four core steps: adaptive construction of cluster environment, multi-language application adaptation and encapsulation, intelligent cross-node scheduling and deployment, and gray-scale iteration and self-healing operation and maintenance.

[0046] 1. Adaptive construction and feature awareness across multi-operating system clusters:

[0047] After system startup, it automatically scans all network nodes, identifying each node's operating system type, kernel architecture, dynamic library version, available runtime environment, and CPU and memory resource status, thus creating a resource profile of heterogeneous nodes. The system automatically distinguishes the compatibility differences between Linux nodes, Windows nodes, and nodes running domestic operating systems, records the language runtime environments that each node can support, and forms a global scheduling resource pool.

[0048] This step addresses the issues of chaotic heterogeneous cluster environments, imperceptible system differences, and inability to achieve unified scheduling, providing data support for subsequent cross-system deployments.

[0049] 2. Principle of unified adaptation and lightweight encapsulation for multi-language applications:

[0050] To address the runtime characteristics of different programming language applications, this invention designs a language runtime normalization adaptation mechanism:

[0051] For Java applications: Unify virtual machine startup parameters, adapt to cross-system JAR package dependencies, and shield path and permission differences between different systems;

[0052] For Python applications: unify interpreter versions, standardize third-party dependency libraries, and resolve binary dependency inconsistencies between Windows and Linux systems;

[0053] For C / C++ and C language applications: unify cross-system compilation and linking rules, adapt to dynamic library calling interfaces of different systems, and shield system call differences;

[0054] At the same time, the application package is lightweighted and trimmed, eliminating redundant debugging files, unnecessary dependencies, and invalid resources to form a unified deployment package that is smaller in size and more compatible across systems.

[0055] 3. Cross-operating system intelligent scheduling and unified deployment principle:

[0056] This invention abandons the traditional single-system deployment logic and adopts a three-dimensional scheduling strategy of system adaptability + language adaptability + node load:

[0057] Prioritize matching the optimal system node based on the application language characteristics. For example, Java / Python programs are prioritized for scheduling to Linux and domestic system nodes, while C / C++ programs are prioritized for scheduling to Windows nodes.

[0058] When no optimal native node is available, compatibility is achieved through a built-in cross-system adaptation environment.

[0059] The scheduling process is fully automated, requiring no manual intervention in system environment configuration or differentiation of application types, enabling unified deployment and delivery of multi-system and multi-language applications.

[0060] The deployment process supports standardized configuration definitions, replacing traditional script-based deployment with unified deployment description rules, enabling reusable configurations, migrated environments, and automated deployment.

[0061] 4. The principle of gray-scale release and rapid self-healing rollback:

[0062] This invention incorporates a lightweight version iteration mechanism, supporting the parallel execution of new and old version instances, and achieving safe canary deployment through gradient traffic distribution. The system monitors multi-language application runtime anomalies in real time, including Java memory errors, missing Python dependencies, C / C++ linking failures, and abnormal system permissions.

[0063] Once a version anomaly or operational failure is detected, the system automatically triggers a rapid rollback mechanism, quickly switching back to a stable version without rebuilding the image or reconstructing the runtime environment, thus achieving low-risk iteration and highly reliable operation and maintenance.

[0064] The overall workflow of this invention is as follows:

[0065] 1. System initialization: Automatically detects heterogeneous operating system nodes across the entire network and builds a cluster resource feature database;

[0066] 2. Perform cross-system adaptation and lightweight encapsulation for multi-language applications (Java, Python, C, C++) to be deployed;

[0067] 3. The scheduling layer intelligently matches the optimal deployment node based on the application language type and node system characteristics;

[0068] 4. The deployment pipeline automatically distributes deployment configurations, starts application processes or containers, and completes environment initialization and health checks;

[0069] 5. Enter routine operation and maintenance, and perform gray-scale iteration, real-time monitoring, anomaly self-healing and version rollback.

[0070] like Figure 1 As shown, the architecture of this invention is a lightweight layered deployment architecture, which is divided into a scheduling and control layer, a heterogeneous resource layer, and an application management and control layer from top to bottom. Each layer is decoupled and independent, and works in synergy. It abandons the redundant design of traditional heavy cloud-native architecture and is suitable for multi-system and multi-language mixed deployment scenarios.

[0071] 1. Top layer: Lightweight distributed scheduling and control layer

[0072] The core consists of a minimalist distributed scheduling cluster, which implements global decision-making based on a distributed consistency mechanism. It retains only four core capabilities: node management, task scheduling, configuration parsing, and state synchronization, eliminating redundant service components and running resident with low resources. Its core functions are to receive deployment tasks for multi-language applications, parse standardized deployment configurations, match the optimal node using a three-dimensional scheduling algorithm, and issue deployment and maintenance instructions to achieve unified global management and control.

[0073] 2. Middle Layer: Resource Layer for Heterogeneous Nodes Across Multiple Operating Systems

[0074] It aggregates three types of heterogeneous operating system nodes, including Linux nodes, Windows nodes, and domestic Kylin / Tongxin UOS nodes. All nodes are equipped with lightweight agent components to achieve automatic cluster registration, resource status reporting, and environment information detection. All nodes uniformly support dual operating modes of containerized application scheduling and system native process scheduling, which can be compatible with different types of business. At the same time, it pre-loads a multi-language adaptation environment to support the running of Java, Python, C, and C++ applications.

[0075] 3. Bottom Layer: Multi-language Application Lifecycle Management Layer

[0076] It integrates multi-language runtime normalization and adaptation modules, lightweight deployment modules, health monitoring modules, canary release modules, and anomaly self-healing and rollback modules. It is specifically designed for four types of application development languages, providing environment adaptation, dependency normalization, and lightweight encapsulation. At the same time, it covers the entire process management of applications from deployment and launch, operation monitoring, version iteration, and fault self-healing, resolving multi-language and multi-system compatibility conflicts.

[0077] like Figure 2 The diagram shows the core deployment method's visual flow, a fully automated closed-loop deployment chain with no manual script intervention throughout. The specific process logic is as follows:

[0078] Step 1: Cluster Environment Adaptive Awareness Modeling: After system initialization, all heterogeneous nodes are automatically scanned to collect information such as system type, kernel parameters, hardware resources, and language runtime environment, to build a global heterogeneous resource feature library and complete the node capability tagging classification.

[0079] Step 2: Lightweight Adaptation and Packaging for Multi-Language Applications: Based on the runtime characteristics of applications in different languages ​​such as Java, Python, C, and C++, we complete cross-system dependency normalization adaptation and runtime environment standardization and packaging, while cutting out redundant application resources and generating a cross-system general lightweight deployment package.

[0080] Step 3: Three-dimensional intelligent scheduling and matching: Based on the three-dimensional strategy of "system adaptability, language adaptability, and real-time node load", the system intelligently selects the optimal deployment node, distinguishes the deployment scenarios of high-performance programs, general business, and dedicated system applications, and achieves precise scheduling.

[0081] Step 4: Automated Deployment and Environment Initialization: The scheduling layer issues deployment instructions, and the node agent automatically completes the deployment package retrieval, environment configuration, permission adaptation, and process / container startup without manual intervention, completing the deployment fully automatically.

[0082] Step 5: Deploy a closed-loop health check: After deployment, continuously monitor the application process status, interface availability, and language runtime status. If the check passes, the deployment is considered complete; if the check fails, a redeployment and adaptation will be automatically triggered.

[0083] like Figure 3 As shown, this is the core mechanism for application iterative operation and maintenance, which addresses the pain points of high risk and slow fault rollback in multi-system and multi-language application version updates, achieving low-risk iteration and high-reliability self-healing. The principle is as follows:

[0084] 1. Parallel canary deployment of new and old versions: The new version application and the historical stable version instances run in parallel within the cluster. Instead of a direct full replacement, a 10%→50%→100% gradient traffic distribution strategy is adopted to gradually increase the traffic of the new version business and avoid the risk of batch failures.

[0085] 2. Real-time monitoring across all dimensions: Monitor system resource status, application operation metrics, and runtime anomalies in multiple languages ​​around the clock, accurately identifying various faults such as Java memory overflow, missing Python dependencies, C / C++ dynamic linking failures, and cross-system permission conflicts.

[0086] 3. Rapid self-healing rollback without reconstruction: The rollback mechanism is automatically triggered after an anomaly is detected. There is no need to rebuild the deployment package or rebuild the runtime environment. The traffic is quickly switched back to the stable version by adjusting the scheduling weight, achieving second-level fault recovery and ensuring the continuous and stable operation of heterogeneous cluster services.

Claims

1. A lightweight cloud-native application deployment method for multi-operating system hybrid systems, characterized in that, include: A simplified distributed scheduling cluster is launched at the scheduling control layer. It maintains the four core capabilities of node management, task scheduling, configuration parsing and state synchronization through a distributed consistency mechanism, eliminating heavy and redundant orchestration components. Scan heterogeneous operating system nodes within the cluster, including Linux nodes, Windows nodes, Kylin nodes, and UnionTech UOS nodes. A unified lightweight agent program deployed on each node reports the operating system type, kernel architecture, dynamic library version, CPU and memory resources, and available language runtime environment, thereby constructing a heterogeneous node resource profile and a global scheduling resource pool. Runtime normalization adaptation is performed on the Java, Python, C, and C++ applications to be deployed: for Java applications, virtual machine startup parameters are unified and path and permission differences are masked; for Python applications, interpreter versions are unified and third-party dependencies are normalized; for C / C++ applications, cross-system compilation and linking rules are unified and dynamic library call interfaces are adapted. Then, redundant debugging files and invalid resources are trimmed to generate a cross-system lightweight deployment package. The optimal node is matched based on a three-dimensional strategy of "system compatibility + language compatibility + real-time node load". When there is no optimal native node, it runs in a compatible environment through the built-in cross-system adaptation environment and sends deployment instructions to the target node agent. The target node agent pulls the deployment package, completes environment initialization, permission adaptation and application launch in containerized mode or system native process mode, and performs health checks; During version iteration, instances of new and old versions are run in parallel, and traffic is distributed in a gradient of 10% → 50% → 100%. Java memory anomalies, missing Python dependencies, C / C++ dynamic link failures, and cross-system permission conflicts are monitored in real time. In case of anomalies, the scheduling weight is adjusted to switch back to the stable version without rebuilding the image or the runtime environment.

2. The method for deploying lightweight cloud-native applications across multiple operating systems as described in claim 1, characterized in that, The lightweight agent program resides on each heterogeneous node, performs automatic cluster registration, periodic reporting of resource status, and environmental information detection, and preloads a multi-language adaptation environment for Java / Python / C / C++.

3. The method for deploying lightweight cloud-native applications across multiple operating systems as described in claim 1, characterized in that, In the three-dimensional scheduling strategy: Java and Python applications are preferentially scheduled to Linux or domestic operating system nodes, and C / C++ applications are preferentially scheduled to Windows nodes; when the target language does not have a native runtime environment on the candidate node, the built-in cross-system adaptation environment is enabled to achieve compatible operation.

4. The method for deploying lightweight cloud-native applications across multiple operating systems as described in claim 1, characterized in that, The health check includes: detecting the application process status, interface availability, and language runtime status. If the check fails, a redeployment adaptation is triggered instead of just issuing an alarm.

5. The method for deploying lightweight cloud-native applications across multiple operating systems as described in claim 1, characterized in that, The ultra-fast rollback achieves second-level flow switching by retaining the stable version instance in the resource pool and only modifying the traffic scheduling weight and the process start direction of the node agent, without involving the reconstruction of the deployment package.

6. A lightweight cloud-native application deployment system for multi-operating system hybrid deployment, used in the lightweight cloud-native application deployment method for multi-operating system hybrid deployment as described in any one of claims 1-5, characterized in that, include: The scheduling and control layer contains a simplified distributed scheduling cluster for execution node management, task scheduling, configuration parsing, and state synchronization. The heterogeneous node resource layer includes Linux, Windows, Kylin, and UnionTech UOS nodes. Each node deploys a unified lightweight agent program, supporting both containerized application scheduling and system native process scheduling modes. The application management layer includes a multi-language runtime normalization adaptation module, a lightweight encapsulation module, a health detection module, a canary release module, and an exception self-healing rollback module; Among them, the scheduling and control layer issues instructions to the node agent based on the heterogeneous node resource profile and three-dimensional scheduling strategy, and the application management and control layer performs runtime normalization, gray-scale flow switching and weight rollback.