A cloud computing-based method and system for processing software development application updates.

Abstract

This invention provides a cloud-based software development application update processing method and system. It analyzes the dependencies between software application components and generates a software deployment topology map. On the cloud platform, target computing resources are preheated to generate a dynamic resource pool, where application version replacement is performed. When a service anomaly is triggered, the abnormal service traffic is switched to a backup resource node, and the abnormal software application component is updated on that node to generate the updated software application component. The updated software application component is then reconnected to the dynamic resource pool to complete the software development application update processing. This invention achieves precise matching between update tasks and computing resources, ensures the continuity of version replacement, and solves the problems of low deployment efficiency and insufficient stability caused by chaotic dependencies in traditional cloud environments.

Description

Technical Field

[0001] This invention relates to the field of software development application update processing technology, and in particular to a cloud computing-based software development application update processing method and system. Background Technology

[0002] With the widespread adoption of cloud computing and microservice architectures, enterprises face higher demands for software application update processing in the context of continuous delivery and rapid iteration. Therefore, efficiently coordinating the update sequence of various components, rationally allocating resources, and achieving rapid recovery in abnormal situations, while ensuring system stability, has become a core technical challenge for current software operations and maintenance.

[0003] To address these needs, existing solutions rely on static resource allocation and dependency-aware automated updates. These solutions pre-build a call relationship graph between microservices, predicting the computing resources required by each component based on historical data before the update task begins. Fixed resource groups are then allocated in the cloud platform to support the update process. Simultaneously, the dependency relationships in the graph determine the order of component updates, ensuring that downstream components only trigger version replacements after upstream components have completed their updates, thus reducing the risk of service interruptions due to missing dependencies. However, existing solutions have some inherent drawbacks. These include resource idleness or contention during some updates due to reliance on historical experience for resource estimation; the system can only pause the update process of a single abnormal component and requires manual intervention for troubleshooting and recovery, lacking automated fault tolerance mechanisms and reducing the robustness and automation level of the update process. Summary of the Invention

[0004] This invention provides a cloud computing-based software development application update processing method and system to solve problems in the prior art, such as resource idleness or resource contention during some update processes due to resource estimation relying on historical experience; the system can only pause the update process of a certain abnormal component and relies on manual intervention for fault diagnosis and recovery, lacking an automated fault tolerance mechanism, which reduces the robustness and automation level of the update process.

[0005] In a first aspect, the present invention provides a software development application update processing method based on cloud computing, comprising:

[0006] Analyze the dependency topology relationships between software application components and generate a software deployment topology map containing component dependency paths;

[0007] Based on the resource requirement characteristics of the software application components, the target computing resources are preheated on the cloud platform to generate a dynamic resource pool that matches the preset software update task.

[0008] Based on the component dependency path, a software application component update process is started in the dynamic resource pool, wherein the software application component update process performs an application version replacement operation according to the component dependency path;

[0009] When the application version replacement operation triggers a service exception, the service traffic of the abnormal software application component that caused the exception will be switched to the backup resource node.

[0010] The abnormal software application component is updated on the backup resource node to generate the updated software application component;

[0011] The updated software application components are reconnected to the dynamic resource pool until each software application component recorded in the software deployment topology map completes its version replacement, thereby completing the software development application update process.

[0012] Optionally, the dependency topology relationships between software application components are analyzed to generate a software deployment topology map containing component dependency paths, including:

[0013] Obtain interface call feature information between software application components, wherein the interface call feature information includes call direction markers and call frequency parameters;

[0014] An initial dependency graph is constructed based on the invocation direction marker, wherein the nodes of the initial dependency graph represent software application components, and the edges of the initial dependency graph represent component connection paths;

[0015] Extract the runtime status feature parameters of the software application components, and assign weights to the component connection paths based on the correlation between the call frequency parameters and the runtime status feature parameters to generate a weighted dependency graph.

[0016] Traverse the incoming edge weights of each node in the weighted dependency graph, and determine the update priority order of the software application components based on the descending order of the incoming edge weights.

[0017] Map the update priority order to the component connection path to generate the component dependency path;

[0018] A software deployment topology graph is generated based on the component dependency paths and the topology of the weighted dependency graph.

[0019] Optionally, based on the resource requirement characteristics of the software application components, the target computing resources are preheated on the cloud platform to generate a dynamic resource pool that matches the preset software update task, including:

[0020] Obtain historical operating data of the software application component, wherein the historical operating data includes resource requirement parameters;

[0021] Based on the matching degree between the resource requirement parameters and the current cloud platform resource status, the resource allocation priority of each software application component is determined;

[0022] Based on the resource allocation priority and the component dependency paths in the software deployment topology, a resource allocation strategy is generated.

[0023] A virtual resource container corresponding to the resource allocation strategy is created in the cloud platform, and the virtual resource container is loaded into the runtime environment according to preset warm-up parameters to generate a set of virtual resource containers in a ready state.

[0024] The resource loading progress of the virtual resource container set in the preparatory state is monitored in real time. When it is detected that the predecessor dependency component of the first software application component to be updated in the component dependency path has been updated and the virtual resource container corresponding to the component dependency path has reached the resource ready state, the virtual resource container set in the preparatory state is activated to generate a dynamic resource pool.

[0025] Based on the execution status of the software application component's update process, the resource configuration ratio of the virtual resource containers in the dynamic resource pool is adjusted to generate a dynamic resource pool that matches the preset software update task.

[0026] Optionally, based on the component dependency path, a software application component update process is started in the dynamic resource pool, wherein the software application component update process performs an application version replacement operation according to the component dependency path, including:

[0027] Parse the component dependency paths to generate a set of direct predecessor components for each software application component;

[0028] A linear update sequence is generated based on the update completion status of the direct predecessor component set;

[0029] In the dynamic resource pool, resource instances are allocated for the linear update sequence to generate a set of allocated resource instances that match the resource allocation strategy in the software deployment topology graph;

[0030] Atomic version replacement operations are performed on the set of allocated resource instances in the order of the linear update sequence.

[0031] The execution status of the atomic version replacement operation is monitored in real time. When a blocking signal is triggered by the version replacement operation of the current software application component, the update process of all subsequent software application components that depend on the current software application component in the linear update sequence is paused.

[0032] Based on the blocking signal and the component dependency path, the linear update sequence is recalculated to generate an update execution instruction set;

[0033] The update execution instruction set is loaded into an unused resource instance in the dynamic resource pool, generating an update process branch path that runs parallel to the linear update sequence, until all software application components have completed version replacement, thereby completing the software application component update process.

[0034] Optionally, when a service anomaly is triggered by the application version replacement operation, the service traffic of the abnormal software application component is switched to the backup resource node, including:

[0035] The execution status of the application version replacement operation is monitored in real time. When the service response latency of the software application component exceeds a preset threshold or the error rate exceeds a critical value, the software application component is marked as an abnormal software application component.

[0036] Based on the component dependency path and the pre-warmed resource instances in the dynamic resource pool, determine the backup resource node corresponding to the abnormal software application component;

[0037] Send a preset traffic switching instruction to the traffic distribution unit associated with the abnormal software application component to generate traffic redirection configuration information;

[0038] Based on the traffic redirection configuration information, the communication link between the abnormal software application component and the currently running resource instance in the dynamic resource pool is isolated, and a component isolation status identifier is generated;

[0039] Based on the component isolation status identifier and the traffic redirection configuration information, the backup resource node is triggered to load the target version of the software application component and generate a backup component instance running on the backup resource node.

[0040] The backup component instance is connected to the dynamic resource pool, and the component dependency paths in the software deployment topology are synchronously updated according to the traffic redirection configuration information until all service traffic is switched to the backup component instance, so as to complete the switch of the service traffic of the abnormal software application component that has an anomaly to the backup resource node.

[0041] Optionally, the backup resource node updates the abnormal software application component to generate an updated software application component, including:

[0042] Obtain the target version update package corresponding to the abnormal software application component;

[0043] Based on the resource allocation strategy in the dynamic resource pool, a runtime environment is created on the backup resource node, and an environment verification result is generated.

[0044] Based on the environmental verification results, the target version update package is loaded into the storage area of ​​the backup resource node, and a version update ready flag is generated;

[0045] Based on the version update ready flag, the backup resource node performs a replacement operation to terminate the old version process and start the new version process, generating a replacement operation completion status.

[0046] The system monitors the operational metrics in the completion status of the replacement operation in real time. When the resource utilization rate and interface response latency of the operational metrics meet the preset conditions, an update completion confirmation signal is generated.

[0047] Based on the update completion confirmation signal, the software application components running in the backup resource node are marked as the updated software application components.

[0048] Optionally, the updated software application components are reconnected to the dynamic resource pool until all software application components recorded in the software deployment topology map have completed version replacement, thereby completing the software development application update process, including:

[0049] Obtain the updated running status parameters of the software application components to generate a component access ready signal;

[0050] Based on the component access ready signal and the component dependency path, a component access instruction is sent to the corresponding resource instance in the dynamic resource pool to generate resource instance binding information;

[0051] Based on the resource instance binding information, the service traffic of the updated software application component is switched from the backup resource node to the target resource instance in the dynamic resource pool, and a traffic switching completion marker is generated.

[0052] Real-time monitoring of the resource utilization fluctuation range and interface call success rate of the target resource instance; when the resource utilization fluctuation range is within the preset tolerance range and the interface call success rate meets the standard, a version replacement confirmation signal is generated.

[0053] The version status identifier of the software application component is updated according to the version replacement confirmation signal, and a component status update record is generated.

[0054] The version status identifiers of the software application components are traversed. When there are software application components whose version replacement has not been completed, the software application component update process is triggered according to the component status update record and component dependency path and iteratively executed until all version status identifiers are marked as complete, so as to complete the software development application update process.

[0055] Secondly, the present invention provides a cloud computing-based software development application update processing system, comprising:

[0056] The analysis module is used to analyze the dependency topology between software application components and generate a software deployment topology map containing component dependency paths.

[0057] The preheating module is used to preheat the target computing resources on the cloud platform according to the resource requirement characteristics of the software application components, and generate a dynamic resource pool that matches the preset software update task.

[0058] A startup module is used to start a software application component update process in the dynamic resource pool based on the component dependency path, wherein the software application component update process performs an application version replacement operation according to the component dependency path.

[0059] The switching module is used to switch the service traffic of the abnormal software application component to the backup resource node when the application version replacement operation triggers a service exception.

[0060] The update module is used to update the abnormal software application component on the backup resource node and generate the updated software application component.

[0061] The access module is used to reconnect the updated software application components to the dynamic resource pool until each software application component recorded in the software deployment topology map completes its version replacement, thereby completing the software development application update process.

[0062] Thirdly, the present invention provides a computing device, including a processor and a memory, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute a cloud computing-based software development application update processing method as described in any of the first aspects.

[0063] Fourthly, the present invention provides a computer storage medium storing computer program instructions thereon, wherein the computer program instructions, when executed by a processor, implement the software development application update processing method based on cloud computing as described in any one of the first aspects.

[0064] This invention generates a deployment topology graph by analyzing the dependency topology relationships between software components and combines this with cloud platform resource preheating to construct a dynamic resource pool, achieving precise matching between update tasks and computing resources. By starting the update process in an orderly manner according to dependency paths and automatically switching to backup nodes for fault tolerance in case of anomalies, it ensures the continuity of version replacement and significantly reduces the risk of service interruption. Finally, through dynamic migration of abnormal components and full-topology component version replacement, it achieves a highly efficient rolling update effect, solving the problems of low deployment efficiency and insufficient stability caused by chaotic dependencies in traditional cloud environments.

[0065] Furthermore, through dynamic analysis of interface call characteristics and runtime status parameters, quantitative indicators such as call direction and frequency are transformed into dependency path weights, enabling the topology graph to accurately reflect the actual coupling strength between components. Determining update priority based on descending incoming edge weights avoids concurrent update conflicts between strongly dependent components and reduces service jitter during updates through topology optimization of the weighted dependency graph. The component dependency paths and priority order generated by this method provide data support for dynamic resource pool allocation and process startup, ultimately improving the controllability and success rate of updates to complex software systems.

[0066] These or other aspects of the invention will become more apparent from the following description of the embodiments. Attached Figure Description

[0067] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0068] Figure 1 A flowchart illustrating a cloud computing-based software development application update processing method provided in an embodiment of the present invention;

[0069] Figure 2 A schematic diagram of the structure of a cloud computing-based software development application update processing system provided in an embodiment of the present invention;

[0070] Figure 3 This is a schematic diagram of the structure of a computing device provided in an embodiment of the present invention. Detailed Implementation

[0071] To enable those skilled in the art to better understand the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings.

[0072] In some of the processes described in the specification, claims, and accompanying drawings of this invention, multiple operations appearing in a specific order are included. However, it should be clearly understood that these operations may not be executed in the order they appear herein, or may be executed in parallel. The operation numbers, such as 101, 102, etc., are merely used to distinguish different operations and do not represent any execution order. Furthermore, these processes may include more or fewer operations, and these operations may be executed sequentially or in parallel. It should be noted that the descriptions such as "first," "second," etc., in this document are used to distinguish different messages, devices, modules, etc., and do not represent a sequential order, nor do they limit "first" and "second" to different types.

[0073] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0074] Figure 1 A flowchart of a cloud computing-based software development application update processing method is provided as an embodiment of the present invention, such as... Figure 1 As shown, the method includes:

[0075] First, by invoking features and real-time running status, the topology graph is upgraded from a static structure to a dynamic model reflecting the actual coupling strength, resolving dependency misjudgment issues. Second, based on the path weights and resource requirement characteristics of the topology graph, computing resources are pre-allocated and preheated on the cloud platform, forming a dynamic resource pool strongly matched to the update task. Subsequently, rolling updates are triggered according to the priority sorted by dependency path weights, and when a single component anomaly is detected, its traffic is automatically switched to a preheated backup node to complete an isolated update, avoiding the full rollback operation of traditional solutions. Finally, highly reliable and low-latency incremental updates are achieved under a microservice architecture, overcoming the bottlenecks of low resource utilization and high fault tolerance costs in existing technologies. Based on this, the present invention provides a cloud computing-based software development application update processing method, such as... Figure 1 ,include:

[0076] Step 101: Analyze the dependency topology between software application components and generate a software deployment topology map containing component dependency paths.

[0077] In this step, dependency topology refers to the call dependency structure between software application components; component dependency path refers to the call chain from the starting component to the target component in the dependency topology, extracted by the topology sorting algorithm; software deployment topology graph refers to the component deployment relationship described in the form of a graph structure.

[0078] In this embodiment of the invention, the dependency topology is first analyzed by calling the interface logs and runtime monitoring data of the microservice components; then, an initial dependency graph is constructed based on graph theory algorithms; subsequently, dynamic weights are assigned to the edges to generate a weighted dependency graph that reflects the actual dependency strength; finally, key dependency paths are extracted using a topology sorting algorithm to form a software deployment topology graph.

[0079] Step 102: Based on the resource requirement characteristics of the software application components, preheat the target computing resources on the cloud platform to generate a dynamic resource pool that matches the preset software update task.

[0080] In this step, resource requirement characteristics refer to the specifications of computing resources required for the software application components to run; warm-up operation refers to pre-allocating computing resources and loading the runtime environment on the cloud platform; dynamic resource pool refers to the set of computing resources that are elastically allocated according to the update task requirements.

[0081] In this embodiment of the invention, firstly, the resource requirement characteristics of each software application component in the software deployment topology map are analyzed; secondly, virtual machine or container instances are pre-applied for according to the requirement characteristics and the runtime environment image of the target version is loaded; then, memory is pre-allocated and network bandwidth is reserved for the computing nodes; finally, the resources after logical grouping and warming up are used to generate the dynamic resource pool according to the component dependency relationship.

[0082] Step 103: Based on the component dependency path, start the software application component update process in the dynamic resource pool, wherein the software application component update process performs the application version replacement operation according to the component dependency path.

[0083] In this step, the software application component update process refers to the version replacement process executed in the order of dependency paths; the application version replacement operation refers to the process of upgrading the software application component from the old version to the new version.

[0084] In this embodiment of the invention, the update priority of software application components is first determined, and the update process of software application components is started sequentially in the dynamic resource pool; then, the new instance is connected to the service registry to complete the application version replacement operation; finally, after verifying the health status of the new version component, traffic is gradually switched to the new instance.

[0085] Step 104: When the application version replacement operation triggers a service exception, the service traffic of the abnormal software application component that caused the exception will be switched to the backup resource node.

[0086] In this step, abnormal software application components refer to components that fail during version replacement; service traffic refers to the data flow of user requests or inter-component calls; and backup resource nodes refer to pre-reserved computing nodes used to take over traffic and perform isolated repairs in the event of an anomaly.

[0087] In this embodiment of the invention, service anomalies of each software application component are first monitored during the application version replacement operation. When an abnormal software application component is detected, its service traffic is immediately switched to a pre-deployed backup resource node. Subsequently, after the traffic switching is completed, an alarm is automatically triggered and the anomaly context is recorded. Finally, it is ensured that the caller of the abnormal component is automatically redirected to the backup node to maintain service continuity.

[0088] Step 105: Update the abnormal software application component on the backup resource node to generate the updated software application component.

[0089] In this step, the update operation refers to the specific actions of repairing or rolling back the abnormal software application components, including image replacement and configuration updates; the updated software application components refer to component instances that have completed version repair or upgrades and have been reconnected to the service mesh after passing health checks.

[0090] In this embodiment of the invention, firstly, the updated image of the abnormal software application component is loaded on the backup resource node and the runtime environment is reinitialized; secondly, an incremental update strategy is adopted to replace the faulty module of the abnormal component; then, the functional integrity of the updated software application component is verified through an automated testing framework to ensure its dependency compatibility with other components; finally, the repaired component is marked as available.

[0091] Step 106: Reconnect the updated software application components to the dynamic resource pool until each software application component recorded in the software deployment topology map completes its version replacement, thereby completing the software development application update process.

[0092] In this step, the reconnection operation refers to the process of re-registering the repaired components to the service discovery system and gradually restoring their traffic; the version replacement operation refers to the final state process in which all components in the software deployment topology map complete version upgrades in sequence.

[0093] In this embodiment of the invention, the updated software application components are first re-registered with the service discovery system, enabling them to reconnect to the dynamic resource pool; secondly, the traffic of the backup resource nodes is gradually migrated back to the repaired components, while continuously monitoring stability; then, the version replacement operation is repeated until all software application components in the software deployment topology are updated; finally, the temporarily occupied backup resource nodes are released, and an update completion report is generated, recording the version change logs of each component.

[0094] For example, firstly, interface call logs between components are collected, the dependency topology is analyzed, and a weighted software deployment topology map is generated based on call frequency and response time. Secondly, according to the resource demand characteristics in the map, matching virtual machine instances are applied for on the cloud platform to complete memory preloading and network bandwidth reservation, forming a dynamic resource pool. Then, the update process is started according to the component dependency paths in the topology map, the old version instances are isolated and the new version is deployed in sequence, and the service status is monitored. When an abnormality is detected in an order service component, its traffic is immediately switched to the backup resource node and the incremental update of the component is completed on the backup node. Finally, the repaired order service is reconnected to the dynamic resource pool, and the version replacement of the remaining components continues until all components are upgraded, the temporary backup resources are released, and an update report is output.

[0095] This invention ensures that the update order matches the actual coupling strength by dynamically analyzing the component dependency topology and generating a weighted deployment graph; it avoids the full rollback problem of traditional solutions by adopting an abnormal component isolation and backup node rapid repair mechanism; and it realizes highly reliable, low-latency incremental rolling updates under the microservice architecture, improving the automation level of software updates in the cloud environment.

[0096] To address the problem of complex dependencies among microservice components leading to uncertain update order, this step provides a method for generating a software deployment topology map based on interface call characteristics and runtime status parameters. A specific embodiment of this invention is provided: Step 101, analyzing the dependency topology relationships between software application components and generating a software deployment topology map containing component dependency paths, specifically includes the following steps:

[0097] Step 111: Obtain interface call feature information between software application components, wherein the interface call feature information includes call direction markers and call frequency parameters.

[0098] In this step, the interface call characteristic information refers to the dynamic characteristic data of interface calls between software application components; the call frequency parameter refers to the statistical value of the number of interface calls per unit time.

[0099] In this embodiment of the invention, firstly, interface call feature information between software application components is obtained through microservice components and a distributed tracing system; secondly, the collected raw data is cleaned and normalized; and finally, the processed interface call feature information is stored in an analysis database.

[0100] Step 112: Construct an initial dependency graph based on the call direction marker, wherein the nodes of the initial dependency graph represent software application components, and the edges of the initial dependency graph represent component connection paths.

[0101] In this step, the construction operation refers to the process of generating an initial dependency graph using graph theory algorithms based on the call direction markers and component relationship data, including node creation and edge connection; the initial dependency graph refers to a directed graph model with software application components as nodes and call relationships as edges.

[0102] In this embodiment of the invention, firstly, the interface call feature information is parsed to clarify the call relationship between each software application component; secondly, an initial dependency graph is constructed based on the directed graph model in graph theory and verified; finally, the initial dependency graph is converted into the storage format of an adjacency list or adjacency matrix.

[0103] Step 113: Extract the running status feature parameters of the software application components, and assign weights to the component connection paths based on the correlation between the call frequency parameters and the running status feature parameters to generate a weighted dependency graph.

[0104] In this step, the weight assignment operation refers to the calculation process of assigning weight values ​​to the edges in the dependency graph based on the association analysis of the call frequency parameter and the running state characteristic parameter; the weighted dependency graph refers to the weighted directed graph generated by the weight assignment operation on the basis of the initial dependency graph.

[0105] In this embodiment of the invention, the running status characteristic parameters of the software application components are first extracted from the performance monitoring system; then, the call frequency parameters are correlated with the running status characteristic parameters, and a weighted algorithm is used to calculate the comprehensive weight value of each component connection path; then, the edges in the initial dependency graph are weighted according to the weight value to generate a weighted dependency graph that reflects the actual dependency strength; finally, the weighted dependency graph is standardized to eliminate the influence of dimensional differences on the weights.

[0106] Step 114: Traverse the incoming edge weights of each node in the weighted dependency graph, and determine the update priority order of the software application components based on the descending order of the incoming edge weights.

[0107] In this step, the incoming edge weight value refers to the sum of the weights of all edges pointing to a certain node in the weighted dependency graph, which is used to measure the importance of that node's dependency in the system.

[0108] In this embodiment of the invention, firstly, the incoming edge weights of each node in the weighted dependency graph are traversed, and the total incoming edge weights of each node are calculated; secondly, the update priority order of the software application components is determined to ensure that components with high dependency intensity are updated first; then, the update order is dynamically adjusted through a priority queue to adapt to changes in runtime dependencies; finally, an update priority list is generated.

[0109] Step 115: Map the update priority order to the component connection path to generate the component dependency path.

[0110] In this step, the mapping operation refers to the process of associating and matching the update priority order with the component connection path to ensure that the path selection is consistent with the priority.

[0111] In this embodiment of the invention, the update priority order is first matched with the component connection paths in the weighted dependency graph to identify key dependency links; then, high-priority component connection paths are extracted as component dependency paths; subsequently, conflict detection and loop elimination are performed on the component dependency paths to ensure the feasibility and efficiency of the paths; finally, the optimized component dependency paths are stored in the path library.

[0112] Step 116: Generate a software deployment topology graph based on the component dependency paths and the topology of the weighted dependency graph.

[0113] In this step, the topology refers to the connection relationships and layout characteristics of nodes and edges in the weighted dependency graph, which is used to describe the overall architecture and dependency network of the system.

[0114] In this embodiment of the invention, the topology of component dependency paths and weighted dependency graphs is first integrated to identify core components and edge components; then, a graph layout algorithm is used to visualize the topology and generate an intuitive software deployment topology graph; subsequently, the rationality and fault tolerance of the deployment topology are verified by a graph analysis tool; finally, the software deployment topology graph is published to the configuration management system.

[0115] This invention addresses the problem of insufficient accuracy in traditional static dependency analysis by dynamically collecting and analyzing interface call feature information; the software deployment topology map provides a scientific basis for the collaborative updating of microservice architecture in the cloud environment, improving update efficiency and system stability.

[0116] To improve cloud platform resource utilization, this step provides a dynamic resource pool preheating and adjustment method based on historical operating data and real-time resource status. A specific embodiment of this invention is provided: Step 102, based on the resource requirement characteristics of the software application components, preheats the target computing resources on the cloud platform to generate a dynamic resource pool matching the preset software update task, specifically including the following steps:

[0117] Step 201: Obtain the historical running data of the software application component, wherein the historical running data includes resource requirement parameters.

[0118] In this step, resource requirement parameters refer to the specifications of computing resources required for the normal operation of software application components, including the number of CPU cores, memory capacity, storage space, and network bandwidth.

[0119] In this embodiment of the invention, historical operating data of software application components are first collected through a cloud platform monitoring system; then, the historical data is cleaned and denoised to remove outliers and invalid records; subsequently, time series analysis is used to statistically analyze the peak and average resource usage of each component at different times to establish a resource demand model; finally, the processed historical operating data is stored in a resource feature database.

[0120] Step 202: Determine the resource allocation priority of each software application component based on the matching degree between the resource requirement parameters and the current cloud platform resource status.

[0121] In this step, the current cloud platform resource status refers to the available resources of the cloud platform at a specific point in time; the resource allocation priority refers to the priority order for resource acquisition determined for each software application component based on the degree of matching between resource demand and platform status, which is used to guide resource scheduling decisions.

[0122] In this embodiment of the invention, the current cloud platform resource status is first obtained from the cloud platform resource management interface; then, the resource requirement parameters are matched with the current resource status in a multi-dimensional way, and a weighted algorithm is used to evaluate the degree to which the resource requirements of each component are met; then, the software application components are sorted according to the matching score to determine the resource allocation priority; finally, a resource requirement list with priority is generated.

[0123] Step 203: Generate a resource allocation strategy based on the resource allocation priority and the component dependency paths in the software deployment topology map.

[0124] In this step, the resource allocation strategy refers to the resource allocation scheme formulated after comprehensively considering component priorities and dependencies, which includes specific component resource mapping rules and scheduling timing arrangements.

[0125] In this embodiment of the invention, firstly, the component dependency paths in the software deployment topology map are parsed to identify the core components on the critical path; secondly, resource pre-allocation simulation is performed by combining the resource allocation priority list; then, the allocation scheme is optimized by considering dependency path constraints and resource competition relationships; finally, a resource allocation strategy is generated to ensure that high-priority components and critical path components obtain resources first.

[0126] Step 204: Create a virtual resource container in the cloud platform that corresponds to the resource allocation strategy, and load the virtual resource container into the runtime environment according to the preset warm-up parameters to generate a set of virtual resource containers in a ready state.

[0127] In this step, a virtual resource container refers to an isolated runtime environment instance created on a cloud platform; the loading operation refers to the entire process of deploying the runtime environment in a virtual resource container, including system image initialization, dependent software installation, and configuration parameter settings; and the virtual resource container set refers to a group of virtual resource containers created according to resource allocation strategies, which are in a ready state and waiting to be activated for use.

[0128] In this embodiment of the invention, a creation request is first sent to the cloud platform resource scheduler; then, the specifications of the virtual resource container are configured according to the policy requirements; subsequently, the runtime environment is loaded; and finally, a health check is performed on the set of virtual resource containers in the preparatory state to ensure that each container meets the availability standard.

[0129] Step 205: Monitor the resource loading progress of the virtual resource container set in the preparatory state in real time. When it is detected that the predecessor dependency component of the first software application component to be updated in the component dependency path has been updated and the virtual resource container corresponding to the component dependency path has reached the resource ready state, activate the virtual resource container set in the preparatory state to generate a dynamic resource pool.

[0130] In this step, the resource loading progress refers to the completion status of various resource configuration tasks during the initialization of the virtual resource container; the activation operation refers to the process of transferring the virtual resource container from the preparatory state to the running state, so that it can officially take over the business load.

[0131] In this embodiment of the invention, a monitoring agent is first deployed to collect resource loading progress data of the virtual resource container set in real time; second, a resource readiness status judgment rule is established; then, update events on the component dependency path are listened to, and a check is triggered when the current dependent component is updated; finally, when the dependency conditions and resource conditions are met, an activation operation is performed to switch the prepared container to the running state, forming a dynamic resource pool.

[0132] Step 206: Based on the execution status of the update process of the software application component, adjust the resource configuration ratio of the virtual resource container in the dynamic resource pool to generate a dynamic resource pool that matches the preset software update task.

[0133] In this step, the execution status of the update process refers to the real-time status information of the component during the update process; the resource allocation ratio refers to the allocation ratio of various resources in the dynamic resource pool.

[0134] In this embodiment of the invention, the execution status information of the software application component update process is first obtained; then, the deviation between the current resource usage and the expected demand is analyzed to identify resource bottlenecks; subsequently, an elastic scaling algorithm is used to dynamically adjust the resource configuration ratio of the virtual resource container; finally, the composition structure of the dynamic resource pool is optimized based on the adjustment results to ensure that it always matches the needs of the software update task.

[0135] This invention optimizes resource utilization efficiency through a resource allocation strategy based on priority and dependency paths; the dynamic adjustment function ensures that the resource pool is always synchronized with actual needs, solving the problems of resource contention and performance fluctuations during software updates in a cloud environment, and improving the stability and efficiency of the update process.

[0136] To address dependency conflicts and blocking issues during component updates in distributed systems, this step provides an atomic version replacement method based on a combination of linear sequences and parallel branches. A specific embodiment of this invention is provided: Step 103, based on the component dependency path, starts a software application component update process in the dynamic resource pool, wherein the software application component update process performs an application version replacement operation according to the component dependency path, specifically including the following steps:

[0137] Step 301: Parse the component dependency path to generate a set of direct predecessor components for each software application component.

[0138] In this step, the parsing operation refers to the process of performing structured analysis on the component dependency path, including dependency extraction, topology sorting, and data structure transformation; the direct predecessor component set refers to the set of all upstream components that directly call the current component in the component dependency path.

[0139] In this embodiment of the invention, the upstream dependencies of each software application component are first identified by parsing the component dependency paths using a topology graph traversal algorithm; then, a depth-first search method is used to collect all directly called predecessor components of each component to form a set of direct predecessor components; subsequently, the components in the set are deduplicated and topologically sorted; finally, the parsing results are stored in a dependency database.

[0140] Step 302: Generate a linear update sequence based on the update completion status of the direct predecessor component set.

[0141] In this step, the update completion status refers to the result identifier of the software application component version replacement operation; the linear update sequence refers to the list of version replacement execution order determined according to component dependencies and predecessor status, ensuring that each component is processed only after all its predecessor components have been updated.

[0142] In this embodiment of the invention, firstly, the update completion status markers of each component in the direct predecessor component set are obtained from the version management system; secondly, the predecessor components that have completed the update are selected, and a dependency constraint relationship matrix is ​​established; then, combined with the dependency constraint conditions, a linear update sequence that satisfies all predecessor conditions is generated; finally, conflict detection and optimization are performed on the sequence to ensure the rationality and efficiency of the update order.

[0143] Step 303: Allocate resource instances for the linear update sequence in the dynamic resource pool to generate a set of allocated resource instances that match the resource allocation strategy in the software deployment topology graph.

[0144] In this step, the resource instance allocation operation refers to the process of binding computing resources in the dynamic resource pool with specific software application components, including resource specification matching, instance allocation, and binding relationship registration; the allocated resource instance set refers to the combination of resource instances that have completed component binding according to the resource allocation strategy.

[0145] In this embodiment of the invention, the resource requirement specifications of each software application component in the linear update sequence are first parsed; then, the available resource list of the dynamic resource pool is queried to match resource instances that meet the specification requirements; subsequently, the resource instance allocation operation is performed according to the resource allocation strategy to establish the binding relationship between the component and the resource instance; finally, the health status of the allocated resource instance set is verified.

[0146] Step 304: Perform atomic version replacement operations on the set of allocated resource instances in the order of the linear update sequence.

[0147] In this step, atomic version replacement operation refers to an indivisible complete update transaction, or a complete successful deployment of the new version or a complete rollback to keep the old version running, ensuring the consistency of the system state.

[0148] In this embodiment of the invention, firstly, target components are selected one by one from the beginning of the linear update sequence; secondly, the resource instance corresponding to the component is located in the set of allocated resource instances, and an environment isolation operation is performed; then, an atomic transaction mechanism is used to complete the version replacement operation; finally, the version replacement result is verified to ensure that the operation is completely successful or completely rolled back, and to maintain system consistency.

[0149] Step 305: Monitor the execution status of the atomic version replacement operation in real time. When a blocking signal is detected that the version replacement operation of the current software application component triggers, pause the update process of all subsequent software application components in the linear update sequence that depend on the current software application component.

[0150] In this step, the blocking signal refers to the abnormal event identifier detected during the version replacement process that hinders the normal execution of the operation; the subsequent software application component update process refers to the version replacement process of all components that are ranked after the current component in the linear update sequence and depend on the current component.

[0151] In this embodiment of the invention, firstly, distributed monitoring probes are deployed to collect execution status data of atomic version replacement operations; secondly, blocking signal detection rules are established to trigger signals when abnormal situations occur; then, the dependency impact range of the current software application components is analyzed to determine the list of subsequent software application components that need to be paused; finally, a pause command is sent to the update coordinator to freeze the update process of the relevant components.

[0152] Step 306: Based on the blocking signal and the component dependency path, recalculate the linear update sequence to generate an update execution instruction set.

[0153] In this step, the recalculation operation refers to the dependency reconstruction process performed on the remaining update tasks after a blocking signal occurs, including dependency subgraph extraction, new sequence generation, and resource reallocation; the update execution instruction set refers to the set of operation commands generated after recalculation.

[0154] In this embodiment of the invention, the causes and scope of the blocking signal are first analyzed, and key parameters are extracted; second, the component dependency path data is reloaded, and the component nodes that have been successfully updated are marked; then, the remaining components are recalculated to generate a new dependency subgraph; finally, an update execution instruction set is constructed based on the subgraph structure to clarify the execution order and resource requirements of subsequent updates.

[0155] Step 307: Load the update execution instruction set into an unused resource instance in the dynamic resource pool, generate an update process branch path that runs parallel to the linear update sequence, until all software application components have completed version replacement, thereby completing the software application component update process.

[0156] In this step, unenabled resource instances refer to available computing resources that have been created in the dynamic resource pool but have not yet been allocated to any component; update process branch paths refer to parallel update execution routes created to resolve blocking issues, working in conjunction with the main update sequence.

[0157] In this embodiment of the invention, firstly, idle resource instances in the dynamic resource pool are screened and their specifications are verified; secondly, the update execution instruction set is decomposed into parallel executable task units, and a task resource mapping relationship is established; then, the update process branch path is started on the standby resource instance and the version replacement operation is executed in parallel until all software application components have completed the version replacement.

[0158] This invention generates an optimized update sequence by accurately parsing component dependencies, ensuring that the update order conforms to system architecture constraints; dynamic resource allocation and branch path mechanisms solve the dependency management problem in the update of complex distributed systems, and realize a highly efficient automated update process.

[0159] To mitigate the risk of service interruption during version updates, this step provides a method for rapid switching of abnormal components based on real-time monitoring and traffic redirection. A specific embodiment of this invention is provided: Step 104, when a service anomaly is triggered by the application version replacement operation, the service traffic of the abnormal software application component is switched to a backup resource node, specifically including the following steps:

[0160] Step 401: Monitor the execution status of the application version replacement operation in real time. When the service response latency of the software application component exceeds a preset threshold or the error rate exceeds a critical value, mark the software application component as an abnormal software application component.

[0161] In this step, service response latency refers to the time interval from when the client sends a request to when it receives a response.

[0162] In this embodiment of the invention, firstly, the performance index data of the software application components are collected in real time through a distributed monitoring system; secondly, the collected data is compared and analyzed with preset thresholds. When the latency exceeds 300ms or the error rate exceeds 5%, an anomaly judgment mechanism is triggered; then, the abnormal components are marked, and the time of occurrence and specific characteristics of the anomaly are recorded; finally, the anomaly information is pushed to the alarm center.

[0163] Step 402: Determine the backup resource node corresponding to the abnormal software application component based on the component dependency path and the pre-warmed resource instances in the dynamic resource pool.

[0164] In this step, a pre-warmed resource instance refers to a computing resource unit that has completed environment initialization and loaded the necessary runtime resources in advance.

[0165] In this embodiment of the invention, the component dependency path database is first queried to obtain the upstream and downstream dependencies of the abnormal software application components; then, the list of pre-warmed resource instances in the dynamic resource pool is scanned to filter candidate nodes that meet the specifications; then, the optimal backup resource node is selected based on the proximity principle and resource load; finally, a backup plan is generated and submitted to the resource scheduling system.

[0166] Step 403: Send a preset traffic switching instruction to the traffic distribution unit associated with the abnormal software application component to generate traffic redirection configuration information.

[0167] In this step, the traffic distribution unit refers to the network component responsible for request routing and load balancing; the traffic redirection configuration information refers to the set of policies that control the request flow path.

[0168] In this embodiment of the invention, the traffic distribution unit information associated with the abnormal software application component is first obtained from the service registry; then a traffic switching instruction is constructed and a configuration update request is sent to the traffic distribution unit; finally, the traffic redirection configuration information returned by the traffic distribution unit is received and verified.

[0169] Step 404: Based on the traffic redirection configuration information, isolate the communication link between the abnormal software application component and the currently running resource instance in the dynamic resource pool, and generate a component isolation status identifier.

[0170] In this step, the communication link refers to the network connection channel established between service components.

[0171] In this embodiment of the invention, firstly, the traffic redirection configuration information is parsed to extract a list of communication links that need to be isolated; secondly, the network control plane interface is called to set firewall rules and routing policies; then, the isolation effect of the communication links is verified to ensure that abnormal components no longer receive new requests; finally, a component isolation status identifier is generated and updated to the configuration management system.

[0172] Step 405: Based on the component isolation status identifier and the traffic redirection configuration information, trigger the backup resource node to load the target version of the software application component and generate a backup component instance running on the backup resource node.

[0173] In this step, the loading operation refers to the entire process of deploying and starting software components on computing resources, including steps such as environment preparation, binary deployment, and service registration; the backup component instance refers to the alternative service instance created on the backup resource node to take over the business traffic of the abnormal component.

[0174] In this embodiment of the invention, the storage location of the target version software package is first obtained; then, an environment initialization operation is performed on the backup resource node; subsequently, the target version image is loaded to start the service process and complete the creation of the backup component instance; finally, a health check is performed on the new instance to confirm that it meets the service standards.

[0175] Step 406: Connect the backup component instance to the dynamic resource pool, and synchronously update the component dependency paths in the software deployment topology map according to the traffic redirection configuration information until all service traffic is switched to the backup component instance, so as to complete the switch of the service traffic of the abnormal software application component that has an anomaly to the backup resource node.

[0176] In this step, the synchronous update operation refers to the process of maintaining the consistency of configuration information among components in a distributed system.

[0177] In this embodiment of the invention, the backup component instance is first registered to the service discovery system to complete the access to the dynamic resource pool; then, the load balancing strategy is updated according to the traffic redirection configuration information to gradually switch traffic; then, the component dependency path information in the software deployment topology is modified synchronously; finally, the traffic switching progress is monitored, and when all traffic migration is completed, the residual resources of the abnormal components are cleaned up.

[0178] This invention enables rapid discovery and precise location of abnormal components through real-time monitoring and intelligent analysis; ensures timely failover through a pre-warmed backup resource mechanism; minimizes the impact of service interruptions through fine-grained traffic control technology; and significantly improves system availability through automated isolation and recovery processes. It constructs a highly reliable cloud-native application update guarantee system and solves the fault problems in traditional solutions.

[0179] To improve the success rate of updating abnormal components, this step provides a backup node version update method that includes environment verification and operational metric monitoring. This invention provides a specific embodiment where step 105 involves updating the abnormal software application component on the backup resource node to generate the updated software application component, specifically including the following steps:

[0180] Step 501: Obtain the target version update package corresponding to the abnormal software application component.

[0181] In this step, the target version update package refers to an archive package containing all deployment files for a specific version of the software components, including executables, configuration templates, and dependency declarations, generated through a version control system.

[0182] In this embodiment of the invention, the target version information of the abnormal software application component is first queried from the version management system; then, the corresponding target version update package is downloaded from the artifact repository according to the version identifier; subsequently, the integrity of the update package is verified, and the digital signature and hash value are verified; finally, the verified update package is temporarily stored in the local cache to prepare for subsequent deployment.

[0183] Step 502: Based on the resource allocation strategy in the dynamic resource pool, create a runtime environment on the backup resource node and generate environment verification results.

[0184] In this step, the creation operation refers to the entire process of initializing the runtime environment on the compute node; the environment verification result refers to the output report of the functional verification of the newly created environment.

[0185] In this embodiment of the invention, the resource allocation strategy is first parsed to obtain the specification requirements of the backup resource node; secondly, an isolated runtime environment is created on the backup resource node, basic dependent components are installed, and environment variables and permission settings are verified; finally, an environment health check is performed to generate environment verification results.

[0186] Step 503: Based on the environment verification results, load the target version update package into the storage area of ​​the backup resource node and generate a version update ready flag.

[0187] In this step, the loading operation refers to the complete process of deploying the software package to the target environment, including file transfer, decompression, and permission configuration, to ensure that the deployment result is consistent with expectations.

[0188] In this embodiment of the invention, the mount point and available space of the storage area are first determined based on the environment verification results; then the target version update package is decompressed to the specified directory of the backup resource node, retaining the original file permissions; then runtime configuration parameters are injected to adapt to the current environment characteristics; finally, after all files are in place, a version update ready marker file is created to record the deployment timestamp and version fingerprint.

[0189] Step 504: Based on the version update ready flag, perform the operation of terminating the old version process and starting the new version process on the backup resource node, and generate a replacement operation completion status.

[0190] In this step, a report detailing the results of the version switching process is generated to indicate the completion status of the replacement operation.

[0191] In this embodiment of the invention, the resource usage of the old version process is first queried; then a termination signal is sent and the old version process is waited for to complete the current request processing; then the new version process is started from the path indicated by the version update ready flag, the process startup log is monitored and a replacement operation completion status report is generated.

[0192] Step 505: Monitor the running indicators in the completion status of the replacement operation in real time. When the resource utilization rate and interface response latency of the running indicators meet the preset conditions, generate an update completion confirmation signal.

[0193] In this step, resource utilization rate refers to the proportion of computing resources consumed by the service instance during runtime; interface response latency refers to the processing time of the service's external API from receiving a request to returning a response.

[0194] In this embodiment of the invention, a performance acquisition agent is first deployed to monitor the resource utilization and interface response latency of the new version process; then a sliding time window is established to calculate the moving average of key indicators; subsequently, the calculation results are compared with preset conditions, including CPU utilization not exceeding 70% and P99 latency less than 200ms; finally, when all indicators meet the standards for more than 5 minutes, an update completion confirmation signal is triggered.

[0195] Step 506: Based on the update completion confirmation signal, mark the software application components running in the backup resource node as the updated software application components.

[0196] In this step, the tagging operation refers to the metadata update action in the management system, which is used to identify changes in component state.

[0197] In this embodiment of the invention, firstly, the version information and performance data in the update completion confirmation signal are parsed; secondly, the component status in the backup resource node is updated to healthy in the service registry; then, the component is marked as the updated software application component in the configuration management system, and the update time is recorded; finally, the alarm rules of the monitoring system are updated synchronously to adapt to the new version features.

[0198] This invention ensures the accuracy of version deployment through standardized update package management and environment verification processes; automated status marking and synchronous updates improve operational efficiency, and builds a secure and reliable cloud-native application update system, solving problems such as version inconsistency and difficulty in rollback in traditional update methods.

[0199] To ensure a smooth integration of updated components and overall system consistency, this step provides a version replacement completion confirmation method based on status monitoring and iterative execution. A specific embodiment of this invention is provided: Step 106, the updated software application components are reconnected to the dynamic resource pool until all software application components recorded in the software deployment topology map have completed version replacement, thereby completing the software development application update process. This specifically includes the following steps:

[0200] Step 601: Obtain the running status parameters of the updated software application component to generate a component access ready signal.

[0201] In this step, the running status parameters refer to the set of indicators that reflect the real-time running performance of the software components; the component access ready signal refers to the digital notification that confirms that the component has met the access standards.

[0202] In this embodiment of the invention, the updated operating status parameters of the software application components are first collected and normalized to calculate a comprehensive health score; then the score is compared with a preset threshold, and a component access ready signal is generated when all key indicators continuously meet the standards for a period of time; finally, the signal is pushed to the resource scheduling center to trigger the subsequent access process.

[0203] Step 602: Based on the component access ready signal and the component dependency path, send a component access instruction to the corresponding resource instance in the dynamic resource pool to generate resource instance binding information.

[0204] In this step, the component access command refers to the operation command that controls the component to be added to the resource pool; the resource instance binding information refers to the metadata that records the association between the component and the specific resource instance.

[0205] In this embodiment of the invention, the component access ready signal is first parsed to determine the position of the component in the dynamic resource pool, and a component access instruction is sent to the resource management service; then, the binding confirmation of the resource instance is received, resource instance binding information is generated, and the service registry is updated.

[0206] Step 603: Based on the resource instance binding information, switch the service traffic of the updated software application component from the backup resource node to the target resource instance in the dynamic resource pool, and generate a traffic switching completion marker.

[0207] In this step, the target resource instance refers to a computing resource unit in the dynamic resource pool that is specifically allocated for a particular component; the traffic switching completion flag is a status indicator that marks the end of the service traffic migration process.

[0208] In this embodiment of the invention, the forwarding rules of the load balancer are first configured according to the resource instance binding information; then, traffic is gradually migrated from the backup resource node to the target resource instance; subsequently, the request processing status of each traffic shard is verified to generate a traffic switching completion marker and trigger the monitoring policy update.

[0209] Step 604: Monitor the resource utilization fluctuation range and interface call success rate of the target resource instance in real time. When the resource utilization fluctuation range is within the preset tolerance range and the interface call success rate meets the standard, generate a version replacement confirmation signal.

[0210] In this step, the resource utilization fluctuation range refers to the change in the amount of computing resources used within the observation window, reflecting the stability of the load; the interface call success rate refers to the proportion of requests that the service interface correctly processes.

[0211] In this embodiment of the invention, firstly, CPU and memory usage data of the target resource instance are collected, and the fluctuation range within a 5-minute sliding window is calculated; secondly, the success rate of interface calls is collected, and the distribution of HTTP status codes is statistically analyzed; then, the fluctuation range is compared with the preset tolerance range to verify whether the success rate reaches 99.9%; finally, when all monitoring indicators continue to meet the standards stably, a version replacement confirmation signal is generated.

[0212] Step 605: Update the version status identifier of the software application component according to the version replacement confirmation signal, and generate a component status update record.

[0213] In this step, the update operation refers to the management action of changing and maintaining the component version status; the component status update record refers to the audit log that describes the version change process in detail.

[0214] In this embodiment of the invention, the verification results and performance data in the version replacement confirmation signal are first parsed; then, the version status identifier of the software application component is updated in the version management system, and the new version number, deployment time and performance baseline are recorded; then, a component status update record is generated and stored in the audit log; finally, the update event is notified to the relevant dependent components to trigger their configuration hot update.

[0215] Step 606: Traverse the version status identifiers of the software application components. When there are software application components whose version replacement has not been completed, trigger the software application component update process according to the component status update record and component dependency path and perform iterative execution until all the version status identifiers are marked as completed, so as to complete the software development application update process.

[0216] In this step, the version status identifier refers to the metadata tag that marks the current version and deployment status of the component. It adopts a standardized encoding format and supports fast querying and batch processing.

[0217] In this embodiment of the invention, the following steps are taken: first, a list of components that have not yet been replaced is filtered; second, the changes in the dependencies of completed components are analyzed based on the component status update records; then, the next batch of components to be updated and their priorities are determined according to the component dependency paths; finally, the update process is iteratively executed until the version status identifiers of all components in the version management system are marked as completed, and a global update completion report is generated.

[0218] The embodiments of this invention ensure the reliability of component access through multi-dimensional operational status evaluation; the iterative execution mechanism ensures overall consistency in complex dependency scenarios, constructs an efficient cloud-native application update system, and solves the coordination problem in large-scale distributed system upgrades.

[0219] Figure 2 This invention provides a schematic diagram of the structure of a cloud computing-based software development application update processing system, as shown in the embodiment of the invention. Figure 2 As shown, the system includes:

[0220] Analysis module 21 is used to analyze the dependency topology relationships between software application components and generate a software deployment topology map containing component dependency paths;

[0221] The preheating module 22 is used to preheat the target computing resources on the cloud platform according to the resource requirement characteristics of the software application components, and generate a dynamic resource pool that matches the preset software update task.

[0222] The startup module 23 is used to start a software application component update process in the dynamic resource pool based on the component dependency path, wherein the software application component update process performs an application version replacement operation according to the component dependency path.

[0223] The switching module 24 is used to switch the service traffic of the abnormal software application component to the backup resource node when the application version replacement operation triggers a service abnormality.

[0224] Update module 25 is used to update the abnormal software application component on the backup resource node and generate the updated software application component.

[0225] Access module 26 is used to reconnect the updated software application components to the dynamic resource pool until each software application component recorded in the software deployment topology map completes the version replacement, so as to complete the software development application update process.

[0226] Figure 2 The aforementioned cloud-based software development application update processing system can execute... Figure 1 The implementation principle and technical effects of the cloud computing-based software development application update processing method described in the illustrated embodiment will not be repeated here. The specific methods by which each module and unit of the cloud computing-based software development application update processing system in the above embodiments perform operations have been described in detail in the embodiments related to this method, and will not be elaborated upon here.

[0227] In one possible design, Figure 2 The cloud-based software development application update processing system shown in the embodiment can be implemented as a computing device, such as... Figure 3 As shown, the computing device may include a storage component 31 and a processing component 32;

[0228] The storage component 31 stores one or more computer instructions, wherein the one or more computer instructions are invoked and executed by the processing component 32.

[0229] The processing component 32 is used to: analyze the dependency topology relationships between software application components and generate a software deployment topology map containing component dependency paths; preheat target computing resources on the cloud platform according to the resource requirement characteristics of the software application components to generate a dynamic resource pool that matches the preset software update task; start a software application component update process in the dynamic resource pool based on the component dependency paths, wherein the software application component update process performs an application version replacement operation according to the component dependency paths; when the application version replacement operation triggers a service anomaly, switch the service traffic of the abnormal software application component to a backup resource node; update the abnormal software application component on the backup resource node to generate an updated software application component; and reconnect the updated software application component to the dynamic resource pool until all software application components recorded in the software deployment topology map have completed version replacement, thereby completing the software development application update processing.

[0230] The processing component 32 may include one or more processors to execute computer instructions to complete all or part of the steps in the above-described method. Alternatively, the processing component may be implemented as one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field-programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic components to perform the above-described method.

[0231] Storage component 31 is configured to store various types of data to support operations at the terminal. The storage component can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

[0232] Of course, computing devices may also include other components, such as input / output interfaces, display components, communication components, etc.

[0233] Input / output interfaces provide interfaces between processing components and peripheral interface modules, which can be output devices, input devices, etc.

[0234] The communication components are configured to facilitate wired or wireless communication between computing devices and other devices.

[0235] The computing device can be a physical device or an elastic computing host provided by a cloud computing platform. In this case, the computing device can refer to a cloud server, and the aforementioned processing components, storage components, etc., can be basic server resources rented or purchased from the cloud computing platform.

[0236] This invention also provides a computer storage medium storing a computer program, which, when executed by a computer, can perform the above-described functions. Figure 1 The illustrated embodiment is a cloud computing-based software development application update processing method.

[0237] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0238] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0239] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0240] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for updating software development applications based on cloud computing, characterized in that, include: Analyze the dependency topology relationships between software application components and generate a software deployment topology map containing component dependency paths; Based on the resource requirement characteristics of the software application components, the target computing resources are preheated on the cloud platform to generate a dynamic resource pool that matches the preset software update task. Based on the component dependency path, a software application component update process is started in the dynamic resource pool, wherein the software application component update process performs an application version replacement operation according to the component dependency path; When the application version replacement operation triggers a service exception, the service traffic of the abnormal software application component that caused the exception will be switched to the backup resource node. The abnormal software application component is updated on the backup resource node to generate the updated software application component; The updated software application components are reconnected to the dynamic resource pool until each software application component recorded in the software deployment topology map completes its version replacement, thereby completing the software development application update process.

2. The method according to claim 1, characterized in that, Analyze the dependency topology relationships between software application components to generate a software deployment topology map containing component dependency paths, including: Obtain interface call feature information between software application components, wherein the interface call feature information includes call direction markers and call frequency parameters; An initial dependency graph is constructed based on the invocation direction marker, wherein the nodes of the initial dependency graph represent software application components, and the edges of the initial dependency graph represent component connection paths; Extract the runtime status feature parameters of the software application components, and assign weights to the component connection paths based on the correlation between the call frequency parameters and the runtime status feature parameters to generate a weighted dependency graph. Traverse the incoming edge weights of each node in the weighted dependency graph, and determine the update priority order of the software application components based on the descending order of the incoming edge weights. Map the update priority order to the component connection path to generate the component dependency path; A software deployment topology graph is generated based on the component dependency paths and the topology of the weighted dependency graph.

3. The method according to claim 1, characterized in that, Based on the resource requirement characteristics of the software application components, the target computing resources are preheated on the cloud platform to generate a dynamic resource pool that matches the preset software update task, including: Obtain historical operating data of the software application component, wherein the historical operating data includes resource requirement parameters; Based on the matching degree between the resource requirement parameters and the current cloud platform resource status, the resource allocation priority of each software application component is determined; Based on the resource allocation priority and the component dependency paths in the software deployment topology, a resource allocation strategy is generated. A virtual resource container corresponding to the resource allocation strategy is created in the cloud platform, and the virtual resource container is loaded into the runtime environment according to preset warm-up parameters to generate a set of virtual resource containers in a ready state. The resource loading progress of the virtual resource container set in the preparatory state is monitored in real time. When it is detected that the predecessor dependency component of the first software application component to be updated in the component dependency path has been updated and the virtual resource container corresponding to the component dependency path has reached the resource ready state, the virtual resource container set in the preparatory state is activated to generate a dynamic resource pool. Based on the execution status of the software application component's update process, the resource configuration ratio of the virtual resource containers in the dynamic resource pool is adjusted to generate a dynamic resource pool that matches the preset software update task.

4. The method according to claim 1, characterized in that, Based on the component dependency path, a software application component update process is started in the dynamic resource pool, wherein the software application component update process performs an application version replacement operation according to the component dependency path, including: Parse the component dependency paths to generate a set of direct predecessor components for each software application component; A linear update sequence is generated based on the update completion status of the direct predecessor component set; In the dynamic resource pool, resource instances are allocated for the linear update sequence to generate a set of allocated resource instances that match the resource allocation strategy in the software deployment topology graph; Atomic version replacement operations are performed on the set of allocated resource instances in the order of the linear update sequence. The execution status of the atomic version replacement operation is monitored in real time. When a blocking signal is triggered by the version replacement operation of the current software application component, the update process of all subsequent software application components that depend on the current software application component in the linear update sequence is paused. Based on the blocking signal and the component dependency path, the linear update sequence is recalculated to generate an update execution instruction set; The update execution instruction set is loaded into an unused resource instance in the dynamic resource pool, generating an update process branch path that runs parallel to the linear update sequence, until all software application components have completed version replacement, thereby completing the software application component update process.

5. The method according to claim 1, characterized in that, When a service exception is triggered by the application version replacement operation, the service traffic of the exception software application component will be switched to the backup resource node, including: The execution status of the application version replacement operation is monitored in real time. When the service response latency of the software application component exceeds a preset threshold or the error rate exceeds a critical value, the software application component is marked as an abnormal software application component. Based on the component dependency path and the pre-warmed resource instances in the dynamic resource pool, determine the backup resource node corresponding to the abnormal software application component; Send a preset traffic switching instruction to the traffic distribution unit associated with the abnormal software application component to generate traffic redirection configuration information; Based on the traffic redirection configuration information, the communication link between the abnormal software application component and the currently running resource instance in the dynamic resource pool is isolated, and a component isolation status identifier is generated; Based on the component isolation status identifier and the traffic redirection configuration information, the backup resource node is triggered to load the target version of the software application component and generate a backup component instance running on the backup resource node. The backup component instance is connected to the dynamic resource pool, and the component dependency paths in the software deployment topology are synchronously updated according to the traffic redirection configuration information until all service traffic is switched to the backup component instance, so as to complete the switch of the service traffic of the abnormal software application component that has an anomaly to the backup resource node.

6. The method according to claim 1, characterized in that, The backup resource node updates the abnormal software application component to generate an updated software application component, including: Obtain the target version update package corresponding to the abnormal software application component; Based on the resource allocation strategy in the dynamic resource pool, a runtime environment is created on the backup resource node, and an environment verification result is generated. Based on the environmental verification results, the target version update package is loaded into the storage area of ​​the backup resource node, and a version update ready flag is generated; Based on the version update ready flag, the backup resource node performs a replacement operation to terminate the old version process and start the new version process, generating a replacement operation completion status. The system monitors the operational metrics in the completion status of the replacement operation in real time. When the resource utilization rate and interface response latency of the operational metrics meet the preset conditions, an update completion confirmation signal is generated. Based on the update completion confirmation signal, the software application components running in the backup resource node are marked as the updated software application components.

7. The method according to claim 1, characterized in that, The updated software application components are reconnected to the dynamic resource pool until all software application components recorded in the software deployment topology map have completed version replacement, thereby completing the software development application update process, including: Obtain the updated running status parameters of the software application components to generate a component access ready signal; Based on the component access ready signal and the component dependency path, a component access instruction is sent to the corresponding resource instance in the dynamic resource pool to generate resource instance binding information; Based on the resource instance binding information, the service traffic of the updated software application component is switched from the backup resource node to the target resource instance in the dynamic resource pool, and a traffic switching completion marker is generated. Real-time monitoring of the resource utilization fluctuation range and interface call success rate of the target resource instance; when the resource utilization fluctuation range is within the preset tolerance range and the interface call success rate meets the standard, a version replacement confirmation signal is generated. The version status identifier of the software application component is updated according to the version replacement confirmation signal, and a component status update record is generated. The version status identifiers of the software application components are traversed. When there are software application components whose version replacement has not been completed, the software application component update process is triggered according to the component status update record and component dependency path and iteratively executed until all version status identifiers are marked as complete, so as to complete the software development application update process.

8. A cloud computing-based software development application update processing system, characterized in that, include: The analysis module is used to analyze the dependency topology between software application components and generate a software deployment topology map containing component dependency paths. The preheating module is used to preheat the target computing resources on the cloud platform according to the resource requirement characteristics of the software application components, and generate a dynamic resource pool that matches the preset software update task. A startup module is used to start a software application component update process in the dynamic resource pool based on the component dependency path, wherein the software application component update process performs an application version replacement operation according to the component dependency path. The switching module is used to switch the service traffic of the abnormal software application component to the backup resource node when the application version replacement operation triggers a service exception. The update module is used to update the abnormal software application component on the backup resource node and generate the updated software application component. The access module is used to reconnect the updated software application components to the dynamic resource pool until each software application component recorded in the software deployment topology map completes its version replacement, thereby completing the software development application update process.

9. A computing device, characterized in that, It includes a processing component and a storage component; the storage component stores one or more computer instructions; the one or more computer instructions are invoked and executed by the processing component to implement a cloud computing-based software development application update processing method as described in any one of claims 1 to 7.

10. A computer storage medium, characterized in that, The system contains a computer program that, when executed by a computer, implements a cloud computing-based software development application update processing method as described in any one of claims 1 to 7.

Images