Intelligent scheduling method and system for load balancing of server cluster

Abstract

The invention relates to the technical field of computers, discloses an intelligent scheduling method and system for server cluster load balancing, and aims to solve the defects of the existing server cluster load balancing technology in response lag, non-uniform resource utilization rate, service quality guarantee, global optimization capability, fine-grained state perception and scheduling decision. The method comprises the following steps: collecting server state and request feature data, constructing a cluster state and service capability model, and predicting a load trend; and generating an optimal routing strategy by using deep reinforcement learning and multi-objective optimization, and issuing adjustment request distribution. The system comprises a data acquisition module, an application request feature acquisition module, a state sensing and modeling module, a load prediction module, an intelligent scheduling decision module and an instruction execution module. By adopting the technical scheme, the resource utilization rate can be improved, the response time can be reduced, the throughput can be improved, the system stability and elasticity can be enhanced, and the operation cost and energy consumption can be reduced.

Description

Technical Field

[0001] This invention belongs to the field of computer technology, specifically relating to an intelligent scheduling method and system for server cluster load balancing. Background Technology

[0002] With the rapid development of information technology and the increasing popularity of internet applications, server clusters and distributed systems have become the core infrastructure supporting various large-scale online services and high-concurrency applications. In these systems, efficiently and stably managing and distributing the ever-increasing service requests to ensure high availability, scalability, and responsiveness is a crucial challenge. Load balancing technology, as a key means of addressing this challenge, aims to rationally distribute client requests across multiple servers in a cluster, avoiding single points of overload and improving overall processing capacity.

[0003] Load balancing scheduling of server clusters is one of the hot topics and challenges in the current technology field. Its core lies in dynamically or statically distributing arriving requests to available servers within the cluster based on specific strategies and algorithms, aiming to optimize resource utilization, minimize response time, maximize throughput, and ensure service quality. Traditional load balancing methods often employ rules based on network topology, server connection count, or simple weight allocation, striving to achieve a certain degree of uniform request distribution.

[0004] However, existing load balancing methods generally have many shortcomings. For example, common static or semi-static scheduling algorithms, such as round-robin, random, or IP hash-based strategies, cannot perceive dynamic factors such as real-time server load, resource utilization (e.g., CPU, memory, I / O), and network latency. While some simple dynamic algorithms based on connection count or response time consider some real-time information, they often fail to fully account for differences in server hardware configurations, service type complexity, and future load trend predictions. These limitations lead to problems such as some servers being overloaded while others are idle, uneven resource utilization, increased request processing latency, and even service quality degradation due to server failures when facing instantaneous high-concurrency traffic, heterogeneous server environments, or long-tail requests.

[0005] Therefore, how to construct a load balancing scheduling method that can comprehensively consider multi-dimensional real-time information and has adaptive and intelligent predictive capabilities to significantly improve the overall performance and stability of server clusters has become an urgent technical challenge. Summary of the Invention

[0006] This invention discloses an intelligent scheduling method and system for server cluster load balancing, aiming to solve the fundamental technical contradictions of existing server cluster load balancing technologies in dealing with complex, dynamic, and heterogeneous request flows, such as response lag, uneven resource utilization, difficulty in guaranteeing service quality, and lack of global optimization capabilities.

[0007] Existing server cluster load balancing technologies, such as round-robin, least connections, source IP hashing, or weighted allocation strategies, while achieving request distribution to some extent, generally have limitations. Specifically, traditional scheduling strategies are mostly static or based on simple dynamic rules. They typically cannot deeply perceive the real-time, fine-grained state of servers, such as CPU core utilization, memory page swapping frequency, disk I / O queue depth, network interface packet loss rate, and the waiting time of specific application processes. Furthermore, existing technologies fail to fully consider the heterogeneity of resource requirements when handling different types of service requests, such as compute-intensive, memory-intensive, or network I / O-intensive requests. This leads to a mismatch between scheduling decisions and the actual cluster state and request characteristics, resulting in uneven resource allocation where some servers are overloaded while others are idle. Simultaneously, these strategies have relatively long decision-making cycles and cannot effectively cope with sudden surges or drops in traffic, leading to increased response latency or decreased service quality. Moreover, existing technologies lack the ability to predict future load trends, making them essentially passive response mechanisms, unable to perform proactive scheduling to avoid potential performance bottlenecks. Ultimately, existing technologies struggle to simultaneously optimize multiple objectives at the server cluster level, such as maximizing throughput, minimizing response time, balancing resource utilization, and reducing overall energy consumption, thus limiting the operational efficiency and cost-effectiveness of server clusters.

[0008] This invention aims to address specific problems in existing server cluster load balancing technologies, namely, a lack of deep awareness of the fine-grained real-time status of servers, insufficient consideration of request type heterogeneity, lagging scheduling decisions, lack of load trend prediction capabilities, and difficulty in achieving multi-objective collaborative optimization. This invention achieves intelligent, proactive, and adaptive scheduling of server cluster load by introducing multimodal data fusion, deep time-series prediction, and deep reinforcement learning decision-making mechanisms.

[0009] According to one aspect of the present invention, an intelligent scheduling method for server cluster load balancing is provided, comprising: real-time acquisition of multi-dimensional operational status data of the server cluster through a data acquisition module, the multi-dimensional operational status data including CPU utilization, memory utilization, disk I / O operation rate, network throughput, network latency, concurrent connections, process queue length, and service response time of each server; real-time acquisition of multi-dimensional feature data of incoming application requests through an application request feature acquisition module, the multi-dimensional feature data including request type, request size, request priority, expected resource consumption type, and historical processing latency; and inputting the multi-dimensional operational status data and the multi-dimensional feature data into a state perception and modeling module, the state perception and modeling module being based on the multi-dimensional operational status data and the multi-dimensional feature data... A real-time status representation of the server cluster and a service capability model for each server are constructed. The real-time status representation, the service capability model, and historical scheduling data are input into a load prediction module. Based on the real-time status representation, the service capability model, and the historical scheduling data, the load prediction module predicts the overall cluster load trend and the expected load state of each server within a future time window. The real-time status representation, the service capability model, and the predicted overall cluster load trend and the expected load state of each server within the future time window are input into an intelligent scheduling decision module. Based on a preset multi-objective optimization function and combined with a deep reinforcement learning model, the intelligent scheduling decision module generates an optimal request routing strategy. The optimal request routing strategy is then distributed to the load balancer through an instruction execution module to adjust the distribution of incoming application requests in real time.

[0010] In one embodiment of the present invention, the data acquisition module includes a lightweight agent program deployed on each server. The lightweight agent program obtains the CPU utilization, memory usage, disk I / O operation rate, network throughput, network latency, concurrent connections, and process queue length through an operating system interface. The lightweight agent program obtains the service response time through an application programming interface. The lightweight agent program collects the multi-dimensional operational status data at a preset sampling frequency (e.g., once per second) and transmits the data to a central data aggregation service via a message queue mechanism.

[0011] In one embodiment of the present invention, the application request feature acquisition module is deployed at the cluster entry point to intercept and parse each incoming application request, extracting the request type, request size, request priority, and expected resource consumption type. The application request feature acquisition module associates the extracted multi-dimensional feature data with the request and transmits it to the central data aggregation service.

[0012] In one embodiment of the present invention, the state awareness and modeling module includes a data preprocessing unit and a state model construction unit. The data preprocessing unit performs timestamp synchronization, missing value imputation, outlier filtering, and data normalization on the received multi-dimensional operational state data and multi-dimensional feature data. The state model construction unit dynamically models the operational state of each server using a Gaussian mixture model or a hidden Markov model to identify the server's health, overload risk, and resource bottlenecks. The state model construction unit employs a multi-dimensional feature vector clustering analysis method to establish resource requirement fingerprints for different types of application requests and to establish a service capability scoring model for each server based on its hardware configuration and software environment.

[0013] In one embodiment of the present invention, the load prediction module employs a temporal convolutional network or a long short-term memory network to train on historical cluster state data, historical request traffic data, and periodic features to learn complex temporal dependencies. The load prediction module outputs the predicted average utilization of CPU, memory, disk, and network resources for each server, as well as the predicted total request throughput of the cluster, within a time window of five to fifteen minutes.

[0014] In one embodiment of the present invention, the intelligent scheduling decision module includes a state encoder, an action generator, and a reward calculator. The state encoder encodes the real-time state representation, the service capability model, and the predicted future load information into a state vector recognizable by a deep reinforcement learning model. The action generator, based on the deep reinforcement learning model, such as a near-end policy optimization algorithm, outputs an action vector representing a decision to adjust the request distribution weights for each active server in the cluster, route specific types of requests to designated servers, or trigger cluster elastic scaling operations. The reward calculator evaluates the cluster performance in real time after the action is executed according to a multi-objective optimization function that comprehensively considers service response time, throughput, CPU utilization, memory utilization, energy consumption, and failure rate. The intelligent scheduling decision module iteratively optimizes the scheduling strategy by continuously interacting with the environment and maximizing accumulated rewards. The multi-objective optimization function is expressed as a weighted sum of the various objectives, for example: reward value = w1 * (average throughput) - w2 * (average response time) - w3 * (response time standard deviation) - w4 * (energy consumption) + w5 * (resource utilization balance) - w6 * (overload penalty), where w1 to w6 are preset weight coefficients.

[0015] In one embodiment of the present invention, the instruction execution module communicates with the underlying load balancer (e.g., software-defined network controller or cloud platform load balancing service) through an application programming interface or configuration management interface to update request routing rules, server weights, or trigger dynamic adjustments to server resources in real time.

[0016] Furthermore, the method also includes a strategy optimization module for continuously learning and optimizing the deep reinforcement learning model of the intelligent scheduling decision module, either offline or online. The strategy optimization module utilizes historical scheduling data, actual cluster performance data, and environmental feedback data to periodically (e.g., daily or weekly) retrain and fine-tune the deep reinforcement learning model to adapt to changes in the cluster environment and workload.

[0017] According to another aspect of the present invention, an intelligent scheduling system for server cluster load balancing is provided, comprising: a data acquisition module for real-time acquisition of multi-dimensional operational status data of the server cluster, the multi-dimensional operational status data including CPU utilization, memory utilization, disk I / O operation rate, network throughput, network latency, concurrent connections, process queue length, and service response time of each server; an application request feature acquisition module for real-time acquisition of multi-dimensional feature data of incoming application requests, the multi-dimensional feature data including request type, request size, request priority, expected resource consumption type, and historical processing latency; a state awareness and modeling module for constructing a real-time state representation of the server cluster and a service capability model of each server based on the multi-dimensional operational status data and the multi-dimensional feature data; a load prediction module for predicting the overall load trend of the cluster and the expected load state of each server within a future time window based on the real-time state representation, the service capability model, and historical scheduling data; an intelligent scheduling decision module for generating an optimal request routing strategy based on a preset multi-objective optimization function and a deep reinforcement learning model; and an instruction execution module for distributing the optimal request routing strategy to the load balancer to adjust the allocation of incoming application requests in real time.

[0018] In one embodiment of the present invention, the data acquisition module includes a lightweight agent program deployed on each server. The lightweight agent program is used to obtain the CPU utilization, memory usage, disk I / O operation rate, network throughput, network latency, concurrent connections, and process queue length through an operating system interface. The lightweight agent program is also used to obtain the service response time through an application programming interface (API). The lightweight agent program collects the multi-dimensional operational status data at a preset sampling frequency and transmits the data to a central data aggregation service via a message queue mechanism.

[0019] In one embodiment of the present invention, the application request feature acquisition module is deployed at the cluster entry point to intercept and parse each incoming application request, extracting the request type, request size, request priority, and expected resource consumption type. The application request feature acquisition module associates the extracted multi-dimensional feature data with the request and transmits it to the central data aggregation service.

[0020] In one embodiment of the present invention, the state awareness and modeling module includes a data preprocessing unit and a state model construction unit. The data preprocessing unit performs timestamp synchronization, missing value imputation, outlier filtering, and data normalization on the received multi-dimensional operational state data and multi-dimensional feature data. The state model construction unit dynamically models the operational state of each server using a Gaussian mixture model or a hidden Markov model to identify the server's health, overload risk, and resource bottlenecks. The state model construction unit also uses a multi-dimensional feature vector clustering analysis method to establish resource requirement fingerprints for different types of application requests and to establish a service capability scoring model for each server based on its hardware configuration and software environment.

[0021] In one embodiment of the present invention, the load prediction module employs a temporal convolutional network or a long short-term memory network to train on historical cluster state data, historical request traffic data, and periodic features to learn complex temporal dependencies. The load prediction module outputs the predicted average utilization of CPU, memory, disk, and network resources for each server, as well as the predicted total request throughput of the cluster, within a time window of five to fifteen minutes.

[0022] In one embodiment of the present invention, the intelligent scheduling decision module includes a state encoder, an action generator, and a reward calculator. The state encoder encodes the real-time state representation, the service capability model, and the predicted future load information into a state vector recognizable by the deep reinforcement learning model. The action generator outputs an action vector based on the deep reinforcement learning model. This action vector represents a decision to adjust the request distribution weights for each active server in the cluster, route specific types of requests to designated servers, or trigger cluster elastic scaling operations. The reward calculator evaluates the cluster performance in real time after the action is executed, based on a multi-objective optimization function that comprehensively considers service response time, throughput, CPU utilization, memory utilization, energy consumption, and failure rate. The intelligent scheduling decision module iteratively optimizes the scheduling strategy by continuously interacting with the environment and maximizing accumulated rewards. The multi-objective optimization function is expressed as a weighted sum of the various objectives, for example: reward value = w1 * (average throughput) - w2 * (average response time) - w3 * (response time standard deviation) - w4 * (energy consumption) + w5 * (resource utilization balance) - w6 * (overload penalty), where w1 to w6 are preset weight coefficients.

[0023] In one embodiment of the present invention, the instruction execution module is used to communicate with the underlying load balancer through an application programming interface or a configuration management interface to update request routing rules, server weights, or trigger dynamic adjustments to server resources in real time.

[0024] Furthermore, the system also includes a strategy optimization module, used for continuous offline or online learning and optimization of the deep reinforcement learning model of the intelligent scheduling decision module. The strategy optimization module utilizes historical scheduling data, actual cluster performance data, and environmental feedback data to periodically retrain and fine-tune the deep reinforcement learning model to adapt to changes in the cluster environment and business load.

[0025] Compared with existing technologies, the advantages and positive effects of this invention are as follows: This invention, through a lightweight agent program deployed on each server, achieves real-time, high-frequency collection of multi-dimensional, fine-grained operational status data, including server CPU, memory, disk I / O, network throughput, network latency, concurrent connections, process queue length, and service response time. This greatly enhances the perception of the micro-state within the cluster and solves the problem of insufficient server status perception in existing technologies. This invention introduces an application request feature collection module to perform real-time analysis of the type, size, priority, and expected resource consumption type of incoming application requests, constructing a request resource demand fingerprint. This allows scheduling decisions to fully consider the impact of heterogeneity of different requests on resource allocation, avoiding the limitations of traditional methods that treat all requests the same. Through a status perception and modeling module, this invention not only constructs a real-time status representation of the cluster but also dynamically models the server's operating status based on Gaussian mixture models or hidden Markov models. This accurately identifies server health, overload risk, and resource bottlenecks and establishes a service capacity model for each server, providing a foundation for refined scheduling. This invention integrates a load prediction module, utilizing temporal convolutional networks or long short-term memory networks to proactively predict the overall cluster load trend and the expected load state of each server within a five- to fifteen-minute time window. This transforms scheduling decisions from passive response to proactive prediction and avoidance, effectively solving the problem of decision lag in existing technologies and significantly improving the cluster's robustness in the face of sudden traffic changes. The core intelligent scheduling decision module of this invention employs deep reinforcement learning models, such as near-end policy optimization algorithms. By defining a multi-objective optimization function that comprehensively considers service response time, throughput, CPU utilization, memory utilization, energy consumption, and failure rate, it achieves global collaborative optimization of cluster performance in complex and ever-changing environments, overcoming the difficulty of multi-objective trade-offs and optimization in existing technologies. Through seamless integration of the instruction execution module with the underlying load balancer or cloud platform elastic scaling service, this invention translates intelligent decisions into concrete scheduling actions, such as dynamically adjusting request routing weights or triggering resource scaling, achieving closed-loop control from intelligent decision-making to actual execution and ensuring the effective implementation of scheduling strategies. This invention includes a strategy optimization module that, through continuous offline retraining and online fine-tuning, enables the deep reinforcement learning model to adapt to changes in the cluster operating environment, application load patterns, and business needs, maintaining the dynamic optimization and long-term effectiveness of the scheduling strategy. In summary, this invention achieves intelligent, proactive, and adaptive scheduling of server cluster load, significantly improving server cluster resource utilization, reducing service response time, increasing service throughput, enhancing system stability and resilience under high concurrency and dynamic loads, and effectively reducing operational energy consumption and costs. Attached Figure Description

[0026] Figure 1This is a schematic diagram of the overall technical architecture of the intelligent scheduling method and system for server cluster load balancing proposed in this invention. Figure 2 This is a schematic diagram of the core principle framework of the deep reinforcement learning decision-making mechanism in this invention. Detailed Implementation

[0027] Example 1

[0028] In the ever-evolving internet services and cloud computing architectures, server clusters bear an ever-increasing and highly dynamic workload. Traditional server load balancing mechanisms, such as round-robin scheduling, least-connection scheduling, or IP address hashing-based scheduling methods, rely on static algorithms or pre-defined heuristic rules for task allocation. These traditional methods generally exhibit insufficient adaptability when dealing with real-time fluctuations in server performance, changes in network conditions, or differences in task request characteristics, leading to uneven resource utilization, increased task processing latency, and degraded service quality. Specifically, a server node might be incorrectly judged as lightly loaded based on its current number of active connections, when in fact it may be handling a large number of computationally intensive tasks, resulting in a potential performance bottleneck. Furthermore, the complexity of modern application services demands more refined and intelligent resource allocation strategies. These strategies must simultaneously consider multiple optimization objectives, including but not limited to reducing task processing latency, increasing system throughput, and ensuring fair resource allocation, while also guaranteeing system stability and high reliability. While some current intelligent scheduling solutions attempt to incorporate machine learning, they often rely on complex parameter tuning or specific pre-set models, resulting in limited generalization ability and adaptability when facing diverse and rapidly changing operating environments. This invention aims to address the fundamental technical problems of existing intelligent scheduling methods, such as lack of real-time adaptability, singular optimization objectives, and difficulty in effectively coping with complex dynamic environments. It proposes a server cluster load balancing intelligent scheduling method and system based on deep reinforcement learning to achieve dynamic self-optimization of server cluster task allocation, thereby significantly improving the overall operating efficiency, resource utilization, and service response capabilities of the cluster.

[0029] This invention proposes an intelligent scheduling method for server cluster load balancing. The overall technical architecture utilizes an intelligent scheduling controller to uniformly manage the server cluster. This controller continuously monitors the operational status of each node within the server cluster and the influx of task requests from the outside, forming a comprehensive environmental state representation. Based on this state representation, the intelligent scheduling controller uses a pre-trained deep reinforcement learning decision model to generate optimal task scheduling actions in real time and accurately distribute tasks to the most suitable server nodes. After the scheduling action is executed, the intelligent scheduling controller immediately collects the resulting environmental feedback, such as task completion time, server load changes, and resource utilization. This feedback data serves as a reward signal for the deep reinforcement learning model, driving continuous learning and iterative optimization, thereby achieving adaptive evolution of the scheduling strategy. The entire process forms a closed-loop learning and decision-making system, ensuring that the server cluster maintains a highly efficient, stable, and optimized operating state when facing high concurrency, sudden bursts, or heterogeneous task loads.

[0030] As one embodiment of the present invention, the intelligent scheduling method for server cluster load balancing includes the following steps:

[0031] S101: Real-time collection of server cluster operation status data and pending task request data.

[0032] This step is fundamental for the intelligent scheduling system to perceive the current environment of the server cluster. Accurate and real-time multi-dimensional data collection is key to constructing an effective representation of the environment's state. The server cluster operational status data covers various performance indicators of all active server nodes in the cluster, while the task request data to be scheduled contains detailed information on all tasks waiting to be assigned or currently being processed.

[0033] Specifically, the server cluster operational status data collection includes the following sub-steps: First, by deploying a lightweight monitoring agent on each server node, such as a process-level monitoring daemon or the operating system's built-in performance counter interface, the CPU utilization data of that node is periodically acquired. This data is expressed as a percentage, reflecting the CPU's workload in processing computational tasks within a specific time window. The acquisition frequency can be configured to once per second, with a typical range of zero to one hundred. The data is sent to the central data acquisition module via a secure network channel and timestamped. Second, through the network interface card performance statistics module, network input / output bandwidth utilization data of each server node is acquired. This data represents the proportion of data sent and received by the server per unit time to its maximum network bandwidth, reflecting the network traffic load. The acquisition frequency is synchronized with the CPU utilization data to ensure data time consistency. The data is sent through an internal message queue and undergoes preliminary aggregation. Third, through the memory management unit or virtual memory statistics interface, memory usage data of each server node is acquired. This data is expressed as a percentage of used memory to total physical memory, reflecting the consumption of memory resources. High memory usage is often an early warning sign of performance bottlenecks. Maintain a consistent data collection frequency. Fourth, use the disk I / O subsystem statistics tool to collect disk I / O operation rate and I / O queue length data for each server node. I / O operation rate represents the number of read / write operations per second, and I / O queue length represents the number of requests waiting for disk processing. These data reflect the performance bottlenecks of the storage system. Maintain a consistent data collection frequency. Fifth, use the service process management interface to obtain the health status and current concurrent connection count of each key service deployed on each server node. Health status can be a Boolean value or a predefined level, while concurrent connection count directly reflects the real-time request volume carried by the service. This data is crucial for service-characteristic-based scheduling decisions. Sixth, use the cluster internal communication protocol to obtain network latency data between server nodes. This data is obtained by periodically sending heartbeat packets and measuring round-trip time, reflecting the efficiency of inter-node communication.

[0034] Specifically, the data collection for the task to be scheduled includes the following sub-steps: First, when a new task request arrives at the load balancer's entry point, the scheduling controller immediately captures its metadata. This metadata includes the task's unique identifier, request arrival timestamp, estimated computational load, estimated memory requirements, estimated network bandwidth requirements, and the task's priority level. The estimated value can be predicted through historical data analysis or a task type identification model. Second, for long-running tasks, the scheduling controller continuously tracks their current execution status, such as the percentage completed, the amount of resources consumed, and the remaining estimated time. This data is used to dynamically adjust the scheduling strategy to prevent resource starvation or over-occupancy. Third, all collected data undergoes timestamp alignment, missing value imputation, and outlier filtering through a data preprocessing module. Timestamp alignment is performed using linear interpolation or cubic spline interpolation to ensure that data points from all sensors and data sources can be analyzed on a unified timeline. Missing values ​​are imputed using forward imputation or average imputation. Outliers are identified and removed using statistical thresholds or isolated forest algorithms. The processed data is input into the subsequent state construction module in the form of structured data packets, such as key-value pair mappings or tabular data structures.

[0035] S102: Construct a representation of the server cluster environment status based on the collected data.

[0036] This step transforms the raw, heterogeneous real-time data collected by S101 into a unified, dimensional numerical vector that can be directly understood by the deep reinforcement learning model. The quality of the environmental state representation directly affects the learning efficiency and decision-making accuracy of the scheduling model.

[0037] Specifically, the construction of the server cluster environment state representation includes the following sub-steps: First, feature engineering is performed on the running status data of each server node to generate a node-level feature vector. For CPU utilization, network bandwidth utilization, memory utilization, and disk I / O operation rate, standardization is used to map the data to the range of zero to one to eliminate dimensional differences. For I / O queue length, logarithmic transformation can be performed to smooth the data distribution. For the number of concurrent service connections, it is directly used as a feature. These features together constitute a numerical vector describing the current health status and load of a single server node. Second, all scheduled task request data is encoded to generate a task feature vector. The unique identifier of the task and the request arrival timestamp are only used for tracking purposes and are not directly included in the feature vector. Estimated computational load, estimated memory requirements, and estimated network bandwidth requirements are standardized. Task priority levels are converted into multiple binary features through one-hot encoding. Current execution status data, such as the percentage of completion, is also standardized. These features together constitute a numerical vector describing the resource requirements and urgency of a single task. Third, the node-level feature vectors of all active server nodes are aggregated. The aggregation method can be to directly concatenate the feature vectors of all nodes to form a long vector; or to extract the overall load trend of the cluster through global average pooling or max pooling operations, such as the average or maximum CPU utilization of all nodes. Fourth, aggregate the task feature vectors of all tasks to be scheduled. Since the number of tasks to be scheduled is dynamically changing, zero-padding or truncation can be used to unify the task list to a fixed length, or attention mechanisms, graph neural networks, and other methods can be used to dynamically process variable-length sequences. Fifth, concatenate the aggregated server cluster running status feature vector with the aggregated task feature vectors to be scheduled, and add global context information of the current time step, such as the number of hours in a day, the number of days in a week, and other time-series features. These time-series features are represented by one-hot encoding. Finally, a fixed-dimensional numerical vector is generated, which is the representation of the server cluster environment state. This state representation should contain enough information so that the deep reinforcement learning model can fully understand the current running status and scheduling requirements of the cluster.

[0038] For example, if a server cluster contains ten nodes, each with five performance metrics, and the scheduling queue has a maximum of twenty tasks, each with five request characteristics, then the dimension of the state representation will be (ten times five) plus (twenty times five) plus the dimension of global context information, such as the twenty-four hours of a day.

[0039] S103: Define the task scheduling action space.

[0040] This step clarifies the set of all possible actions that the deep reinforcement learning model can execute at each scheduling decision time. A well-designed action space is fundamental to the model's effective learning.

[0041] Specifically, defining the task scheduling action space includes the following sub-steps: First, identify all active server nodes. Each active server node constitutes an independent scheduling target. Second, identify all tasks to be scheduled. Typically, a scheduling decision processes the highest priority task in a waiting queue. Third, define an atomic scheduling action. The atomic scheduling action assigns a specific task to a specific target server node. For example, the action could be "assign task B to server B". Fourth, combine all possible atomic scheduling actions into a discrete action space. If the scheduler needs to process multiple tasks simultaneously or requires batch scheduling, the action space can be a more complex tuple, such as "assign task 1 to server 1, assign task 2 to server 2, and assign task 3 to server 3". In this embodiment, considering the complexity and real-time nature of the decision, the focus is mainly on single-task multi-target scheduling, that is, selecting the highest priority task from the queue of tasks to be scheduled, and then selecting an optimal server node for it. Therefore, the size of the action space is equal to the number of active server nodes. Fifth, assign a unique integer or encoded representation to each server node as an action index output by the deep reinforcement learning model. For example, server one corresponds to action index zero, server two corresponds to action index one, and so on.

[0042] S104: Design a scheduling optimization reward function.

[0043] This step defines the learning objective of the deep reinforcement learning model, and the reward function quantifies the impact of scheduling actions on system performance. The model's objective is to maximize long-term cumulative reward.

[0044] Specifically, the design of the scheduling optimization reward function includes the following sub-steps: First, define the core reward component: task completion delay penalty. After a task is assigned to a server node and completed, calculate its total delay from the request arrival time to the task completion time. The greater the delay, the greater the penalty, i.e., the smaller the reward value. This encourages the model to prioritize assigning tasks to nodes that can process them quickly. Second, define the second secondary reward component: server resource utilization balancing reward. At the end of each scheduling cycle, calculate the standard deviation or Gini coefficient of the CPU utilization, memory utilization, and network bandwidth utilization of all server nodes. The smaller the standard deviation or Gini coefficient, the more balanced the resource utilization, and the positive reward is given. This encourages the model to avoid single-point overload or resource idleness. Third, define the third secondary reward component: system throughput reward. In each scheduling cycle, the more tasks are successfully completed, the higher the positive reward is given. This encourages the model to improve overall task processing efficiency as much as possible. Fourth, define constraint penalties: if a scheduling action causes a server node's critical resources (such as CPU or memory) to exceed a preset safety threshold, or causes a task to wait for a long time due to insufficient resources, a large negative reward is given. This forces the model to learn to avoid unsafe scheduling decisions. Fifth, sum all reward components with weights to form the final instant reward signal. The weights can be adjusted according to specific business needs and optimization goals. For example, if latency is more sensitive, the weight of the task completion delay penalty should be higher. The reward function can be expressed as:

[0045] Rt=-α·Dt+β·Et+γ·Tt-ζ·Pt

[0046] Where Rt represents the immediate reward obtained at time step t; Dt represents the average latency of the tasks completed at time step t, with a weight of α, representing the latency penalty; Et represents the server resource utilization balance index at time step t, for example, represented by a negative standard deviation, with a weight of β, representing the balance reward; Tt represents the number of tasks completed at time step t, with a weight of γ, representing the throughput reward; and Pt represents whether any scheduling constraints were violated at time step t, with a weight of δ, representing the constraint penalty. All weights α, β, γ, and δ are non-negative constants and are carefully allocated according to the actual system operation objectives.

[0047] S105: Training a deep reinforcement learning scheduling decision model.

[0048] This step is the core of the intelligent scheduling in this invention. The deep reinforcement learning model learns a mapping strategy from states to optimal actions through interaction with the server cluster environment.

[0049] Specifically, training the deep reinforcement learning scheduling decision model includes the following sub-steps: First, initializing the deep reinforcement learning model structure. The model can adopt a deep Q-network structure, an actor-commentator structure, or a policy gradient structure, such as the proximal policy optimization algorithm. The model typically contains one or more convolutional neural network layers for processing temporal data features, and multiple fully connected neural network layers for feature fusion and decision output. The input of the model is the server cluster environment state representation constructed in step S102, and the output is the value estimate of each possible scheduling action or the probability distribution of the action. Second, defining an experience replay buffer. During the interaction between the model and the environment, the observed state, the action taken, the reward obtained, and the next state are stored as experience quadruples in this buffer. The experience replay mechanism helps to break the temporal correlation between data and improve the stability and efficiency of training. The capacity of the buffer is usually set to be able to store hundreds of thousands of experiences. Third, performing model pre-training or cold start. Before actual environment interaction, a small amount of initial experience can be generated through a simulator for pre-training, or a random exploration strategy can be used to conduct preliminary exploration in the actual environment to fill the experience replay buffer. Fourth, executing a round-based training loop. In each training round, the scheduling controller first starts from the current environment state and uses the deep reinforcement learning model to select a scheduling action based on its current policy. Action selection can employ an ε-greedy strategy, where an action is randomly selected with a small probability ε for exploration, and the action deemed optimal by the model is selected with a remaining probability (1-ε) for development. Fifth, the selected scheduling action is sent to the task execution module, which is responsible for distributing the task to the target server node. Sixth, the system waits for the scheduling action to complete and collects the immediate reward and new environment state from the environment feedback module. Seventh, the current state, selected action, immediate reward, and next state are stored in the experience replay buffer. Eighth, a batch of experience data is randomly sampled from the experience replay buffer to construct a mini-batch training dataset. Ninth, the network parameters of the deep reinforcement learning model are updated using the mini-batch training data. The update process is based on the loss function of the deep reinforcement learning algorithm; for example, the loss function of a Q-network is the mean squared error between the current Q-value and the target Q-value. The network parameters are adjusted using the backpropagation algorithm and an optimizer such as the Adam optimizer. Tenth, the target network (if a target network is used) is updated periodically. The target network is used to calculate the target Q-value to improve training stability. Its parameters are typically copied from the main network using either soft updates or fixed-period hard updates.

[0050] During training, changes in reward values, the loss function value, and server cluster performance metrics, such as average task latency and throughput, are continuously monitored as indicators of model training progress. Training continues until the model converges or reaches a preset number of training epochs. Convergence is determined when the reward value no longer increases significantly within a certain period.

[0051] S106: Online task scheduling is performed using a trained deep reinforcement learning scheduling decision model.

[0052] This step involves deploying the deep reinforcement learning model, trained offline or online, to the actual operating environment to execute real-time task scheduling decisions.

[0053] Specifically, the online task scheduling using the trained deep reinforcement learning scheduling decision model includes the following sub-steps: First, deploying the deep reinforcement learning model. The trained deep reinforcement learning model is encapsulated into an executable inference service and deployed to the intelligent scheduling controller, or runs as an independent scheduling service module. Second, continuously monitoring task requests. The intelligent scheduling controller continuously receives task request streams from external sources. When a new task arrives, it is added to the queue of tasks to be scheduled. Third, acquiring the real-time environment status. At each scheduling decision point, the intelligent scheduling controller acquires the current server cluster running status representation from the data acquisition module in step S101 and the status representation module in step S102. This status representation is the sole input to the model's decision. Fourth, model inference. The acquired real-time environment status representation is input into the deployed deep reinforcement learning model. Based on its learned policy, the model calculates the value or probability of each possible scheduling action and selects the scheduling action with the highest value or the highest probability as the current optimal decision. In this online inference stage, no further exploration is performed; development is entirely based on the current policy. Fifth, generating scheduling instructions. The action index output by the model is decoded into specific scheduling instructions, such as "assign the task with task identifier 001 to the node with server identifier 5". Sixth, send the scheduling instructions. The generated scheduling instructions are sent to the task execution module via an internal message queue or a remote procedure call protocol.

[0054] S107: Execute scheduling decisions and obtain environmental feedback.

[0055] This step involves the practical implementation of scheduling decisions and the collection of their impact on the server cluster environment. Environmental feedback is a crucial basis for the deep reinforcement learning model to conduct subsequent learning and optimization.

[0056] Specifically, the execution of scheduling decisions and acquisition of environmental feedback includes the following sub-steps: First, receiving scheduling instructions. The task execution module receives specific scheduling instructions from the intelligent scheduling controller. Second, task distribution. According to the scheduling instructions, the task execution module routes or forwards the request data packets of the tasks to be processed to the designated target server node. For example, this is achieved by modifying the destination address of the network data packets or updating the internal routing table. Third, resource allocation and task initiation. After receiving the task, the target server node allocates resources such as CPU time slices, memory space, and network bandwidth to it according to the task's resource requirements, and starts the task execution process. Fourth, monitoring the task execution status. During task execution, the task execution module or its integrated monitoring function continuously tracks the task's lifecycle, including the task's start time, current progress, resource consumption, and final completion time or failure status. Fifth, collecting real-time reward-related data. When the task is completed or the scheduling cycle ends, the task execution module transmits various performance index data related to the reward function design in step S104, such as the actual completion delay of the task, changes in the current server's resource utilization, changes in system throughput, and whether resource overruns have occurred, back to the environmental feedback module in real time. Sixth, updating the environmental status. Task execution and its impact on resources will cause changes in the operating state of the server cluster. The real-time data acquisition module in step S101 will immediately capture these changes and provide them to the environment state representation module in step S102 to construct the environment state for the next time step.

[0057] S108: Deep reinforcement learning scheduling decision model updated based on environmental feedback.

[0058] This step is crucial to the adaptive capability of this invention. By continuously utilizing feedback information generated from real-world scheduling decisions, the deep reinforcement learning model can continuously optimize its strategy to adapt to the dynamically changing needs and environment of the server cluster.

[0059] Specifically, the deep reinforcement learning scheduling decision model updated based on environmental feedback includes the following sub-steps: First, experience data encapsulation. The environmental feedback module encapsulates the current environmental state obtained in step S106, the scheduling action executed in step S107, the immediate reward collected in step S107, and the next environmental state updated in step S107 into a complete experience quadruple. Second, experience storage. The encapsulated experience quadruple is stored in the experience replay buffer defined in step S105. Third, periodic model update. During online scheduling, in addition to making real-time decisions, the intelligent scheduling controller also periodically triggers online updates of the deep reinforcement learning model. The update frequency can be adjusted according to the dynamics of the cluster, the amount of data, and the computing resource capabilities, for example, updating once per second or after processing a certain number of tasks. Fourth, batch data extraction from the experience replay buffer. During each online update, a batch (e.g., sixty-four or one hundred and twenty-eight) of experience data is randomly extracted from the experience replay buffer. Fifth, loss calculation and backpropagation. Using the extracted batch data, the loss function of the deep reinforcement learning model is calculated, and gradient descent is performed using optimization algorithms such as the Adam optimizer, with backpropagation used to update the model network parameters. Sixth, target network synchronization (if used). If the deep reinforcement learning model uses a target network, the latest parameters of the main network are synchronized to the target network according to a preset frequency or soft update mechanism. Seventh, model version management and rollback. A model version management mechanism can be introduced during model updates. If the performance metrics of the new model version, such as average latency and throughput, show a significant decline over a period of time, it can be automatically rolled back to the older, more stable version. Through continuous learning and updating in steps S108, the deep reinforcement learning scheduling decision model can adapt in real time to changes in server cluster load patterns, node failures, new service deployments, and any other dynamic factors, thereby ensuring that the scheduling strategy remains optimal and achieving true intelligent adaptive load balancing.

[0060] As one embodiment of the present invention, the intelligent scheduling system for server cluster load balancing includes: a data acquisition module, a state representation module, a deep reinforcement learning decision-making module, an action execution module, and a feedback collection module. These modules work together to realize the aforementioned intelligent scheduling method.

[0061] The data acquisition module is configured to collect real-time operational status data and task request data from the server cluster. This module typically consists of lightweight agents, a network traffic monitor, and a log parser deployed on each server node. Each agent periodically acquires performance metrics such as CPU utilization, memory usage, disk I / O operation rate, network I / O bandwidth utilization, and concurrent service connections for its assigned server. The network traffic monitor captures metadata for all task requests flowing through the load balancer, including request arrival time, estimated resource requirements, and task priority. The log parser extracts key information such as task completion status and actual execution time from application logs. All collected raw data is aggregated through an internal high-speed communication bus to the core processing unit of the data acquisition module for initial timestamp synchronization, format standardization, and data cleaning, such as removing duplicate data or filling in a few missing values, to ensure data consistency and availability.

[0062] The state representation module is configured to receive preprocessed data from the data acquisition module and construct a state representation of the server cluster environment based on this data. This module contains a series of feature engineering processing units. First, for the operational state data of each server node, mathematical transformations such as standardization, normalization, or logarithmic transformation are applied to generate node-level feature vectors with a uniform scale. For example, CPU utilization and memory usage can be normalized to the range of zero to one. Second, for the task request data to be scheduled, this module performs the same processing on the estimated resource requirements of the tasks, and the task priority is converted into numerical features through one-hot encoding to form task-level feature vectors. Subsequently, these node-level and task-level feature vectors are further aggregated. The aggregation method can be simple concatenation or more complex attention mechanisms or graph neural network layers to capture deep correlations between nodes or tasks. Finally, all aggregated features, along with contextual information related to the current timestamp, such as the specific time of day, are fused into a fixed-dimensional numerical vector through a concatenation operation, which is the final state representation of the server cluster environment. This status indicator is designed to comprehensively and without redundancy reflect the overall load status of the current server cluster, the health status of each node, and the characteristics of the tasks to be processed.

[0063] The deep reinforcement learning decision module is configured to receive the server cluster environment state representation from the state representation module and output task scheduling actions using a pre-trained deep reinforcement learning model. This module is the "brain" of the entire intelligent scheduling system. Its core is a deep neural network, which may consist of multiple convolutional layers, fully connected layers, and activation functions to capture complex nonlinear patterns in the state representation. During the training phase, this module learns a mapping strategy from input states to optimal actions through interaction with a simulated or real-world environment and adjusts network parameters based on reward feedback. The trained model is then embedded and deployed to this module for online inference. Upon receiving the environment state representation, the model quickly calculates the value assessment or probability distribution for assigning the task to be scheduled to each available server node based on its internal weights and biases. The decision module then selects the scheduling action with the highest value or probability and converts it into a specific scheduling instruction. To ensure low-latency response in high-concurrency scenarios, this module typically employs a high-performance inference engine and supports parallel computing to complete decisions within milliseconds.

[0064] The action execution module is configured to receive scheduling instructions from the deep reinforcement learning decision module and distribute tasks to be scheduled to target server nodes. This module, as the executor of the scheduling strategy, interacts directly with the network infrastructure and service management interface of the server cluster. When it receives the instruction to "assign task A to server B," the action execution module first retrieves the complete request data packet of task A from the queue of tasks to be scheduled. Then, based on the address information of target server B specified in the instruction, such as the Internet Protocol address and port number, it precisely redirects or forwards the task request traffic to server B through the internal routing mechanism of the load balancer or the traffic management function of the service mesh. To ensure the reliability of task distribution, this module has a built-in retry mechanism and error handling logic. For example, if the target server fails to respond within a specified time or reports resource unavailability, the action execution module can notify the deep reinforcement learning decision module to regenerate the scheduling decision or temporarily place the task back into the queue of tasks to be scheduled.

[0065] The feedback collection module is configured to monitor changes in the server cluster status and task execution results after scheduling actions are executed, and to generate environmental feedback data. This module works closely with the action execution module and the data acquisition module. Its main responsibility is to track the complete lifecycle of each task from scheduling to completion and to measure various performance indicators related to the reward function design. For example, for a scheduled task, the feedback collection module records its actual start time, end time, total execution time on the target server, and the actual consumption of resources such as CPU, memory, and network during execution. Simultaneously, it continuously monitors the real-time load changes of the target server and even the entire cluster, the balance of resource utilization, and the overall system throughput. All these measurements are structured and, according to the reward function defined in step S104, calculate the immediate reward value. Furthermore, any abnormal situations caused by scheduling actions, such as resource overruns, task failures, or timeouts, are also accurately recorded. This environmental feedback data is then encapsulated into empirical quadruplets and transmitted to the deep reinforcement learning decision module for continuous model learning and updates, thus forming a complete intelligent scheduling closed loop.

Claims

1. An intelligent scheduling method for server cluster load balancing, characterized in that, include: By deploying a lightweight agent program on each server in the server cluster, multi-dimensional operational status data of the server is collected in real time. The multi-dimensional operational status data includes CPU utilization, memory usage, disk I / O operation rate, network throughput, network latency, number of concurrent connections, process queue length, and service response time. By deploying an application request feature acquisition module at the server cluster entry point, multi-dimensional feature data of incoming application requests is collected in real time. This multi-dimensional feature data includes request type, request size, request priority, expected resource consumption type, and historical processing latency. After performing timestamp synchronization, missing value imputation, outlier filtering, and data normalization on the multi-dimensional runtime status data and the multi-dimensional feature data, a real-time status representation of the server cluster and a service capability model for each server are constructed. The service capability model is established based on the server's hardware configuration and software environment. Based on the real-time status representation, the service capability model, and historical scheduling data, a temporal convolutional network or a long short-term memory network is used to predict the overall cluster load trend and the expected load status of each server within a future time window. The expected load status includes the expected average utilization of each server's CPU, memory, disk, and network resources, as well as the total request throughput of the cluster. Based on the real-time state representation, the service capability model, the predicted overall cluster load trend within the future time window, and the expected load state of each server, an optimal request routing strategy is generated through a deep reinforcement learning model combined with a preset multi-objective optimization function. The deep reinforcement learning model encodes information into state vectors through a state encoder, and the action generator outputs action vectors to adjust request distribution weights or make decisions on routing specific types of requests to designated servers. The reward calculator evaluates cluster performance and optimizes the scheduling strategy based on the multi-objective optimization function. The optimal request routing strategy is then distributed to the load balancer to adjust the allocation of incoming application requests in real time.

2. The intelligent scheduling method for server cluster load balancing according to claim 1, characterized in that, The real-time acquisition of multi-dimensional operational status data of the servers and multi-dimensional feature data of incoming application requests includes: periodically acquiring CPU utilization data, network I / O bandwidth utilization data, memory usage data, disk I / O operation rate, and I / O queue length data of the server nodes, as well as the health status of service processes and the current number of concurrent connections, at a preset sampling frequency through a lightweight monitoring agent program deployed on each server in the server cluster; acquiring network latency data between server nodes by periodically sending heartbeat packets and measuring round-trip time; and intercepting and parsing each incoming application request through an application request feature acquisition module deployed at the cluster entry point, extracting the request type, request size, request priority, expected resource consumption type, and historical processing latency, and associating the multi-dimensional feature data with the request.

3. The intelligent scheduling method for server cluster load balancing according to claim 2, characterized in that, After performing timestamp synchronization, missing value imputation, outlier filtering, and data normalization on the multi-dimensional operational status data and the multi-dimensional feature data, a real-time status representation of the server cluster and a service capability model of each server are constructed. This includes: performing timestamp alignment, missing value imputation, and outlier filtering on the received multi-dimensional operational status data and the multi-dimensional feature data, wherein timestamp alignment is completed through linear interpolation or cubic spline interpolation, missing values ​​are filled using forward imputation or average imputation, and outliers are identified and removed using statistical thresholds or isolated forest algorithms; and processing the operational status data of each server node... The system performs feature engineering to generate node-level feature vectors. This feature engineering includes standardization to map the data to a range of zero to one. All task request data to be scheduled is encoded to generate task feature vectors. This encoding includes standardization of estimated computational load, estimated memory requirements, and estimated network bandwidth requirements, as well as one-hot encoding to convert task priority levels into multiple binary features. The aggregated server cluster running status feature vector is concatenated with the aggregated task feature vectors to be scheduled, and global context information of the current time step is added to generate a fixed-dimensional representation of the server cluster environment state.

4. The intelligent scheduling method for server cluster load balancing according to claim 3, characterized in that, The process of predicting the overall cluster load trend and the expected load status of each server within a future time window, based on the real-time state representation, the service capability model, and historical scheduling data, using a temporal convolutional network or a long short-term memory network, includes: training on historical cluster state data, historical request traffic data, and periodic features to learn complex temporal dependencies; outputting the predicted average utilization of CPU, memory, disk, and network resources of each server within a future five- to fifteen-minute time window; and outputting the predicted total request throughput of the cluster within a future five- to fifteen-minute time window.

5. The intelligent scheduling method for server cluster load balancing according to claim 4, characterized in that, The process of generating an optimal request routing strategy using a deep reinforcement learning model combined with a preset multi-objective optimization function includes: encoding the real-time state representation, the service capability model, and the predicted future load information into a state vector recognizable by the deep reinforcement learning model using a state encoder; outputting an action vector based on the deep reinforcement learning model using an action generator, where the action vector represents a decision to adjust the request distribution weight for each active server in the cluster, route a specific type of request to a designated server, or trigger an instruction for cluster elastic scaling; and evaluating the cluster performance in real time after the action is executed using a reward calculator, based on the multi-objective optimization function, which comprehensively considers service response time, throughput, CPU utilization, memory utilization, energy consumption, and failure rate.

6. The intelligent scheduling method for server cluster load balancing according to claim 5, characterized in that, The multi-objective optimization function includes: defining a task completion delay penalty, which is determined by the total delay from the time the request arrives to the time the task is completed; the greater the delay, the greater the penalty. Defining a server resource utilization balancing reward, which is determined by the standard deviation or Gini coefficient of the CPU utilization, memory utilization, and network bandwidth utilization of all server nodes after the scheduling cycle ends; the smaller the standard deviation or Gini coefficient, the greater the reward. Defining a system throughput reward, which is determined by the number of tasks successfully completed within the scheduling cycle; the greater the number, the higher the reward. Defining a constraint penalty, which is determined by whether the scheduling action causes a server node's critical resources to exceed a preset safety threshold, or causes tasks to wait for a long time due to insufficient resources; violating the constraint results in a larger negative reward. The task completion delay penalty, the server resource utilization balancing reward, the system throughput reward, and the constraint penalty are weighted and summed to form a final immediate reward signal to drive the deep reinforcement learning model to continuously learn and iteratively optimize.

7. The intelligent scheduling method for server cluster load balancing according to claim 6, characterized in that, The deep reinforcement learning model is trained as follows: The deep reinforcement learning model structure is initialized, employing a deep Q-network structure, an actor-critic structure, or a policy gradient structure; an experience replay buffer is established to store the observed states, actions taken, rewards obtained, and the next state as experience quadruples during the model's interaction with the environment; a round-based training loop is performed, in which actions are selected and scheduled based on the current environment state and an ε-greedy policy in each training round, and the immediate reward and new environment state after the action are executed are stored in the experience replay buffer; a batch of experience data is randomly sampled from the experience replay buffer, and the network parameters of the deep reinforcement learning model are updated using this data, with the update process adjusted according to the loss function of the deep reinforcement learning algorithm.

8. The intelligent scheduling method for server cluster load balancing according to claim 7, characterized in that, The process of generating the optimal request routing strategy and then adjusting the allocation of incoming application requests in real time includes: deploying the trained deep reinforcement learning model as an executable inference service; continuously monitoring task requests and adding new tasks to the queue of tasks to be scheduled; at each scheduling decision point, obtaining the current server cluster running status representation and inputting it into the deep reinforcement learning model, selecting the scheduling action with the highest value or probability as the optimal decision; generating and sending scheduling instructions to the task execution module to route or forward the task to the specified target server node; monitoring the changes in server cluster status and task execution results after the scheduling action is executed, collecting performance indicators such as the actual completion delay of the task, changes in server resource utilization, changes in system throughput, and whether resource overruns have occurred, calculating the instant reward value, and encapsulating it into an experience quadruple and storing it in the experience replay buffer for periodic online updates by the deep reinforcement learning model.

9. An intelligent scheduling system for server cluster load balancing, characterized in that, include: The data acquisition module is used to collect multi-dimensional operational status data from the server cluster in real time. This multi-dimensional operational status data includes the CPU utilization, memory usage, disk I / O operation rate, network throughput, network latency, concurrent connections, process queue length, and service response time for each server. The request feature acquisition module is used to collect multi-dimensional feature data of incoming application requests in real time. The multi-dimensional feature data includes request type, request size, request priority, expected resource consumption type, and historical processing latency. The state awareness and modeling module is used to construct a real-time state representation of the server cluster and a service capability model of each server based on the multi-dimensional running state data and the multi-dimensional feature data. The load prediction module is used to predict the overall cluster load trend and the expected load status of each server within a future time window based on the real-time status representation, the service capability model, and historical scheduling data. The intelligent scheduling decision module is used to generate the optimal request routing strategy based on a preset multi-objective optimization function and a deep reinforcement learning model. The instruction execution module is used to send the optimal request routing strategy to the load balancer to adjust the distribution of incoming application requests in real time.

10. The intelligent scheduling system for server cluster load balancing according to claim 9, characterized in that, The data acquisition module includes: a lightweight agent program deployed on each server, used to periodically acquire the CPU utilization, memory usage, disk I / O operation rate, network I / O bandwidth utilization, and concurrent service connections of the server, and to acquire the service response time through an application programming interface; a network traffic monitor, used to capture metadata of all task requests flowing through the load balancer, the metadata including request arrival time, estimated resource requirements, and task priority; and a log parser, used to extract task completion status and actual execution time from application logs.

Images