A development method of a low-code microservice architecture client unrestricted expansion system

Abstract

The application provides a development method of a low-code micro-service architecture client unlimited expansion system, and belongs to the technical field of micro-service. The application collects real-time performance monitoring data of micro-service instances by constructing a distributed service registration center, constructs an explosive sparse matrix based on a delay perception vector to reduce and compress the data, calculates the performance index change sensitivity by using a jump detection matrix and dynamically adjusts the balanced load matrix weight, generates a super dense flow matrix and a super clustering service vector by principal component analysis of a super sparse matrix to realize multi-level mapping, inputs the processing result into an adaptive resource prediction model to predict future resource demand and further adjust the load weight, and solves the technical problem that the load balancing under the micro-service architecture in the prior art cannot be dynamically and adaptively adjusted according to real-time performance monitoring data.

Description

Technical Field

[0001] This invention belongs to the field of microservice technology, and more specifically, relates to a development method for a low-code microservice architecture client-side unlimited scalability system. Background Technology

[0002] In the field of microservice architecture, traditional load balancing methods primarily rely on static weight allocation strategies and basic round-robin algorithms to distribute service requests. Client requests are assigned to different microservice instances based on pre-defined load balancer rules. These traditional methods are widely used in scenarios such as containerized deployment, distributed system management, and service meshes, forming a load balancing technology system represented by Nginx, HAProxy, and Kubernetes Service. However, traditional static load balancing methods have significant technical shortcomings. They cannot dynamically adjust based on the actual operating status of microservice instances, easily leading to uneven load distribution when faced with sudden traffic spikes or service performance fluctuations. In today's increasingly complex microservice architecture environment, due to the large number of service instances and their varying processing capabilities, traditional load balancing methods struggle to achieve adaptive weight adjustments based on real-time performance monitoring data, failing to effectively cope with dynamic changes during microservice operation. In other words, existing technologies suffer from the technical problem of load balancing in microservice architectures being unable to dynamically and adaptively adjust based on real-time performance monitoring data. Summary of the Invention

[0003] In view of this, the present invention provides a development method for a low-code microservice architecture client-side unlimited scalability system, which can solve the technical problem in the prior art that load balancing under microservice architecture cannot be dynamically and adaptively adjusted based on real-time performance monitoring data.

[0004] This invention is implemented as follows: It provides a development method for a low-code microservice architecture client-side unlimited scalability system. This method constructs a distributed service registry and initializes a load balancing matrix. A real-time performance monitoring dataset is established by collecting CPU utilization, memory usage, and network bandwidth usage of microservice instances. Based on this dataset, a latency-aware vector is constructed, multi-level service discovery proxy nodes are deployed, and the network latency weights between each proxy node and the target service are calculated. An exploding sparse matrix is ​​constructed using the latency-aware vector to reduce the dimensionality of the real-time performance monitoring dataset, and a time-series data compression storage strategy is employed. A jump detection mechanism is then constructed based on the exploding sparse matrix. The algorithm measures the sensitivity of the eigenvalues ​​of the jump detection matrix to changes in service load parameters, and adjusts the weight distribution in the load balancing matrix. It then uses principal component analysis (PCA) to generate an ultra-sparse matrix from the jump detection matrix and selects the principal eigenvectors to construct a dimensionality reduction mapping framework. Based on the ultra-sparse matrix, an ultra-dense traffic matrix is ​​established, and K-means clustering is used to generate super-clustered service vectors from the ultra-dense traffic matrix, achieving a step-by-step mapping from microservice-level to cluster-level scales. Finally, the ultra-dense traffic matrix and super-clustered service vectors are input into an adaptive resource prediction model to predict future resource demands. Based on the prediction results, the load balancing matrix is ​​further adjusted to achieve dynamic load balancing.

[0005] The load balancing matrix is ​​an n×m dimensional matrix, where n represents the number of microservice instances, m represents the number of load types, and the matrix elements are... This represents the weight of the i-th instance's processing capacity for the j-th load type, with a weight value range of... ∈[0,1], is calculated by weighting CPU utilization, memory usage and network bandwidth usage.

[0006] Here, the delay-aware vector is a k-dimensional vector, where k equals the total number of network nodes, and the vector elements are... This represents the average response latency from the current node to the i-th network node, with a latency range of... The latency values ​​are ∈[10, 1000] ms, obtained through statistical analysis of network latency data in the real-time performance monitoring dataset.

[0007] The explosive sparse matrix is ​​stored in a compressed sparse row format with a matrix dimension of p×q, where p is the number of time windows and q is the number of monitoring indicator types. The proportion of non-zero elements in the matrix is ​​controlled to be below 5%, and the element value range is matrix element ∈ [0, 100]. It is constructed by detecting and marking delay mutation points in the delay-aware vector.

[0008] The transition detection matrix is ​​an r×r square matrix, where r equals the number of key performance indicators, and the matrix elements are... This represents the sensitivity coefficient of the i-th indicator to changes in the j-th indicator, and the sensitivity coefficient ranges from... ∈[0,2], is obtained by analyzing the temporal changes of non-zero elements in the exploded sparse matrix.

[0009] The ultra-sparse matrix has a dimension of 64×8. It is constructed by processing the transition detection matrix with principal component analysis algorithm, retaining the main eigenvectors with a cumulative variance contribution rate of more than 95%, and setting the absolute value of matrix elements less than 0.01 to zero.

[0010] The ultra-dense traffic matrix is ​​a time series matrix, with rows representing time windows and columns representing service interfaces. The matrix element density reaches over 90%. It is constructed through the inverse mapping of ultra-sparse matrices and data filling algorithms to record the request traffic data of each service interface within each time window. The traffic data range is request traffic ∈ [0, 10000] times / second.

[0011] The dimension of the super-cluster service vector is equal to the number of service categories. The vector elements represent the central feature values ​​of each service category. The range of central feature values ​​is [0, 10]. When the Euclidean distance between a new service and an existing cluster center is less than the threshold of 2.5, it is assigned to the corresponding category.

[0012] The adaptive resource prediction model is structured as a multilayer perceptron architecture, consisting of an input layer, three hidden layers, and an output layer. The input layer has 72 neurons, the first hidden layer has 128 neurons, the second hidden layer has 64 neurons, and the third hidden layer has 32 neurons. The number of neurons in the output layer is equal to the dimension n×m of the load balancing matrix. The ReLU function is used as the activation function, and the Adam algorithm is used as the optimizer.

[0013] Among them, when the network latency weight exceeds 500ms, the local caching mechanism is activated. The local caching mechanism is a distributed caching system that caches the access results of the target service to the local storage node. The cache validity period is set to 300 seconds, and the cache hit rate is maintained above 80%.

[0014] The steps for establishing the training dataset for the adaptive resource prediction model include collecting more than 6 months of historical microservice operation data, slicing the data into 10-minute time windows, using the ultra-dense traffic matrix and ultra-clustered service vector as input features, and using the actual resource demand within 30 minutes after the corresponding time window as the label, resulting in a total dataset of 1 million samples.

[0015] The adaptive resource prediction model training process employs a batch gradient descent algorithm with a batch size of 256 and 1000 training rounds. The model performance is evaluated on the validation set every 100 rounds, and training is stopped early when the validation set loss does not decrease significantly for 20 consecutive rounds.

[0016] The time series data compression and storage strategy is based on a wavelet transform-based data compression algorithm. It decomposes the time series data in the real-time performance monitoring dataset into wavelet coefficients, retains low-frequency coefficients and discards high-frequency noise coefficients, and controls the compression ratio within the range of 15% to 20%.

[0017] The dimensionality reduction mapping framework uses principal component analysis to map from the original 1024-dimensional feature space to a 64-dimensional feature space. The mapping process maintains an information loss of less than 5%, and the mapping matrix is ​​1024×64-dimensional.

[0018] The hierarchical mapping process includes three levels: microservice-level mapping, node-level mapping, and cluster-level mapping. Microservice-level mapping handles resource allocation for a single service instance, node-level mapping handles resource scheduling for a single physical node, and cluster-level mapping handles load balancing for the entire cluster.

[0019] The weight allocation adjustment includes two stages: initial adjustment and dynamic adjustment. The initial adjustment is performed when the sensitivity coefficient is greater than 0.8. The dynamic adjustment is performed based on the prediction results of the adaptive resource prediction model. The adjustment range is controlled within ±20% of the original weight value, and the adjustment frequency is once every 10 minutes.

[0020] This invention constructs a distributed service registry and establishes a real-time performance monitoring dataset based on CPU utilization, memory usage, and network bandwidth usage. It employs latency-aware vector and exploding sparse matrix techniques to reduce the dimensionality of the monitoring data. By using a jump detection matrix to calculate the sensitivity of service load parameter changes, it dynamically adjusts the weight allocation of the load balancing matrix, overcoming the technical deficiency of traditional static load balancing methods that cannot dynamically adjust based on real-time performance status. Through principal component analysis of ultra-sparse matrices and cluster analysis of ultra-dense traffic matrices, it achieves hierarchical mapping from the microservice level to the cluster level, enabling fine-grained adjustment of load balancing based on resource status at different levels, effectively improving the accuracy and response speed of load allocation. This invention utilizes an adaptive resource prediction model to predict future resource demands and adjust load weights accordingly, realizing a dynamic adaptive load balancing mechanism based on real-time performance monitoring data. This solves the technical problem in existing technologies where load balancing in microservice architectures cannot dynamically and adaptively adjust based on real-time performance monitoring data. Attached Figure Description

[0021] Figure 1 This is a flowchart of the method of the present invention.

[0022] Figure 2 This is a diagram illustrating the dynamic adjustment process of microservice load weights in Example 2.

[0023] Figure 3 This is the delay-sensing vector analysis diagram in Example 2.

[0024] Figure 4 This is a time distribution diagram of the ultra-dense flow matrix in Example 2. Detailed Implementation

[0025] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings.

[0026] like Figure 1 The diagram shown is a flowchart of a development method for a low-code microservice architecture client-side unlimited scalability system provided by this invention. This method includes the following steps:

[0027] S01. Build a distributed service registry and initialize a load balancing matrix. Establish a real-time performance monitoring dataset by collecting CPU utilization, memory usage, and network bandwidth usage of microservice instances.

[0028] S02. Construct a latency-aware vector based on the real-time performance monitoring dataset, deploy multi-level service discovery proxy nodes, calculate the network latency weight between each proxy node and the target service, and start the local caching mechanism when the network latency weight exceeds 500ms.

[0029] S03. Construct an exploding sparse matrix using the delay-aware vector, perform dimensionality reduction on the real-time performance monitoring dataset, and use a time-series data compression storage strategy to compress the original data to 15% to 20% of its original volume.

[0030] S04. Construct a jump detection matrix based on the exploded sparse matrix, calculate the sensitivity of the eigenvalues ​​of the jump detection matrix to changes in service load parameters, and adjust the weight distribution in the balanced load matrix when the sensitivity coefficient is greater than 0.8.

[0031] S05. Using the jump detection matrix, generate an ultra-sparse matrix through principal component analysis algorithm, and select the first 8 principal eigenvectors to construct a dimensionality reduction mapping framework from 1024 dimensions to 64 dimensions.

[0032] S06. Based on the ultra-sparse matrix, an ultra-dense traffic matrix is ​​established, and a super-clustered service vector is generated from the ultra-dense traffic matrix using the K-means clustering algorithm to achieve a step-by-step mapping process from the microservice level to the cluster level.

[0033] S07. Input the ultra-dense traffic matrix and the ultra-clustered service vector into the adaptive resource prediction model to predict the resource demand in the next 30 minutes, and further adjust the load balancing matrix according to the prediction results to achieve dynamic load balancing.

[0034] The load balancing matrix is ​​an n×m dimensional matrix, where n represents the number of microservice instances, m represents the number of load types, and the matrix elements are... This represents the weight of the i-th instance's processing capacity for the j-th load type, with a weight value range of... The value ∈ [0, 1] is obtained by weighting the CPU utilization, memory usage, and network bandwidth usage, and the calculation formula is as follows: =0.4×CPU utilization + 0.3×memory usage + 0.3×network bandwidth usage.

[0035] The delay-aware vector is a k-dimensional vector, where k equals the total number of network nodes, and the vector elements are... This represents the average response latency from the current node to the i-th network node, with a latency range of... The range ∈ [10ms, 1000ms] is obtained by statistical analysis of network latency data in the real-time performance monitoring dataset.

[0036] The explosive sparse matrix is ​​stored in a compressed sparse row format with a matrix dimension of p×q, where p is the number of time windows and q is the number of monitoring indicator types. The proportion of non-zero elements in the matrix is ​​controlled to be below 5%, and the element value range is matrix element ∈ [0, 100]. It is constructed by detecting and marking delay mutation points in the delay sensing vector.

[0037] The jump detection matrix is ​​an r×r square matrix, where r equals the number of key performance indicators and the matrix elements are... This represents the sensitivity coefficient of the i-th indicator to changes in the j-th indicator, and the sensitivity coefficient ranges from... ∈[0, 2], is calculated through temporal variation analysis of the non-zero elements in the exploded sparse matrix.

[0038] The ultra-sparse matrix has a dimension of 64×8. It is constructed by processing the transition detection matrix with principal component analysis algorithm, retaining the main feature vectors with a cumulative variance contribution rate of more than 95%, and setting the absolute value of matrix elements less than 0.01 to zero.

[0039] The ultra-dense traffic matrix is ​​a time series matrix, with rows representing time windows and columns representing service interfaces. The matrix element density reaches over 90%. It is constructed through the inverse mapping of the ultra-sparse matrix and data filling algorithm to record the request traffic data of each service interface within each time window. The traffic data range is request traffic ∈ [0, 10000] times / second.

[0040] Wherein, the dimension of the super-clustering service vector is equal to the number of service categories, and the vector elements represent the central feature values ​​of each service category. The range of the central feature values ​​is feature values ​​∈ [0, 10]. When the Euclidean distance between a new service and the existing cluster center is less than the threshold of 2.5, it is assigned to the corresponding category.

[0041] The adaptive resource prediction model is structured as a multilayer perceptron architecture, comprising an input layer, three hidden layers, and an output layer. The input layer has 72 neurons, corresponding to the concatenation of the 64-dimensional feature vector of the ultra-dense traffic matrix and the 8-dimensional service vector of the super-clustering. The first hidden layer has 128 neurons, the second hidden layer has 64 neurons, and the third hidden layer has 32 neurons. The number of neurons in the output layer is the same as the dimension n×m of the balanced load matrix. The activation function is ReLU, the optimizer is Adam's algorithm, and the initial learning rate is 0.001.

[0042] The steps for establishing the training dataset for the adaptive resource prediction model specifically include collecting more than 6 months of historical microservice operation data, including key indicator data such as service request volume, response time, CPU utilization, memory usage, and network bandwidth usage. The data is sliced ​​according to a time window of 10 minutes. The ultra-dense traffic matrix and the ultra-clustered service vector are used as input features, and the actual resource demand within 30 minutes after the corresponding time window is used as the label. The total dataset reaches 1 million samples, which are divided into training set, validation set and test set in a ratio of 7:2:1.

[0043] The training steps of the adaptive resource prediction model specifically include using a batch gradient descent algorithm with a batch size of 256 and 1000 training rounds. The model performance is evaluated on the validation set every 100 rounds. Training is stopped early when the validation set loss does not decrease significantly for 20 consecutive rounds. Finally, the prediction accuracy of the model on the test set reaches more than 85%, and the root mean square error of the prediction error is controlled within 10%.

[0044] The time series data compression and storage strategy is a wavelet transform-based data compression algorithm. The time series data in the real-time performance monitoring dataset is decomposed by wavelet, retaining low-frequency coefficients and discarding high-frequency noise coefficients, with the compression ratio controlled within the range of 15% to 20%.

[0045] The local caching mechanism is a distributed caching system. When the network latency weight exceeds 500ms, the access result of the target service is cached to the local storage node, the cache validity period is set to 300 seconds, and the cache hit rate is maintained above 80%.

[0046] The dimensionality reduction mapping framework employs principal component analysis to map from the original 1024-dimensional feature space to a 64-dimensional feature space. The mapping process maintains an information loss of less than 5%, and the mapping matrix is ​​1024×64 dimensions.

[0047] The hierarchical mapping process includes three levels: microservice-level mapping, node-level mapping, and cluster-level mapping. Microservice-level mapping handles resource allocation for a single service instance, node-level mapping handles resource scheduling for a single physical node, and cluster-level mapping handles load balancing for the entire cluster. The mapping relationship is realized through the hierarchical structure in the ultra-dense traffic matrix.

[0048] The weight allocation adjustment includes two stages: initial adjustment and dynamic adjustment. The initial adjustment is performed in step S04 based on the sensitivity coefficient, and the dynamic adjustment is performed in step S07 based on the prediction results of the adaptive resource prediction model. The adjustment range is controlled within ±20% of the original weight value, and the adjustment frequency is once every 10 minutes.

[0049] The network latency weight is calculated by the ratio of the corresponding element value in the latency-aware vector to a preset baseline latency of 100ms, and the calculation formula is: Network latency weight = / 100ms, the local caching mechanism is triggered when the ratio is greater than 5.

[0050] Optionally, the present invention is also implemented by a computer to form a low-code microservice architecture client with unlimited scalability. The computer is provided with a readable storage medium, which stores program instructions. When the program instructions are run on the computer, they execute the above-described method.

[0051] The specific implementation methods of the above steps are described in detail below.

[0052] The specific implementation of step S01 involves first establishing a distributed service registry center. This center uses a consistent hashing algorithm to achieve distributed storage and management of service instances, and high availability is ensured by deploying registry center replicas on multiple physical nodes. The initialization process of the load balancing matrix includes creating an n×m two-dimensional array structure, where n represents the total number of microservice instances in the current system, m represents the total number of load types, and each element in the matrix... The initial value is set to 0.5, representing the weight of each instance's processing capacity for various types of loads. The real-time performance monitoring dataset is constructed using a time-window-based data collection strategy, with a collection interval of 10 seconds. Monitoring agents deployed on each microservice instance periodically collect three key performance indicators: CPU utilization, memory usage, and network bandwidth usage. The data collection range is 0% to 100% for CPU utilization, 0% to 100% for memory usage, and 0% to 100% for network bandwidth usage. Monitoring data is stored using a circular buffer structure, with a buffer size set to 1000 time windows. When the buffer is full, the oldest data record is automatically overwritten.

[0053] The specific implementation of step S02 is based on the real-time performance monitoring dataset established in step S01, and a latency-aware vector is constructed using a network latency statistical analysis algorithm. The dimension k of this vector is equal to the total number of network nodes in the system, and each element in the vector... The network latency was calculated by using a moving average of historical network latency data, with a sliding window size of 50 sampling points. The multi-level service discovery proxy node deployment adopts a layered architecture, including local proxy nodes, regional proxy nodes, and global proxy nodes. Each layer maintains connectivity through a heartbeat mechanism. Network latency weights are calculated based on the ratio of element values ​​in the latency-aware vector to a baseline latency of 100 milliseconds. When this ratio exceeds 5 (i.e., network latency exceeds 500 milliseconds), the system automatically activates the local caching mechanism. The local caching mechanism uses the Least Recently Used (LRU) algorithm to manage cached data, with a cache capacity set at 20% of local storage space, a cache expiration time of 300 seconds, and a cache hit rate threshold of 80%.

[0054] The specific implementation of step S03 involves constructing an exploding sparse matrix using a delay mutation detection algorithm in the delay-aware vector. Delay mutation detection employs a statistical analysis-based anomaly detection method, setting the detection threshold to twice the standard deviation of the historical average delay. When a delay mutation is detected, the corresponding position in the matrix is ​​marked as a non-zero value. The exploding sparse matrix is ​​stored using a compressed sparse row format, reducing storage space by storing only non-zero elements and their position information, with the proportion of non-zero elements controlled below 5%. Time series data compression uses a wavelet transform-based compression algorithm. First, the original monitoring data undergoes multi-scale wavelet decomposition, then low-frequency coefficients are retained while high-frequency noise coefficients are discarded. The compressed data volume is controlled within 15% to 20% of the original data. The amount of information retained during dimensionality reduction is evaluated by calculating the reconstruction error, which is required to be less than 5% of the original data variance.

[0055] The specific implementation of step S04 is to construct a jump detection matrix based on the temporal change analysis of non-zero elements in the exploded sparse matrix. This matrix is ​​an r×r square matrix structure, where r equals the number of key performance indicators in the system, typically including indicators such as response time, throughput, and error rate. Matrix elements The sensitivity coefficient is calculated using the Pearson correlation coefficient algorithm, which determines the sensitivity coefficient by analyzing the correlation between the changes of the i-th and j-th indicators. The sensitivity coefficient is calculated based on historical data within a sliding time window, with a window size of 100 sampling points and an update frequency of once per minute. When the sensitivity coefficient is greater than 0.8, it indicates a strong correlation between the corresponding indicators. At this point, the system automatically adjusts the weight distribution in the load balancing matrix using the gradient descent method, with a learning rate set to 0.01, and the adjustment range controlled within ±10% of the original weight values.

[0056] The specific implementation of step S05 involves using principal component analysis (PCA) to reduce the dimensionality of the jump detection matrix, generating an ultra-sparse matrix. PCA first calculates the covariance matrix of the jump detection matrix, then obtains eigenvectors and eigenvalues ​​through eigenvalue decomposition. The first eight principal eigenvectors are selected after sorting by eigenvalue size. The cumulative variance contribution rate is determined by the ratio of the sum of the first k eigenvalues ​​to the sum of the total eigenvalues, requiring a ratio of at least 95% before dimensionality reduction. The dimensionality reduction framework maps the original 1024-dimensional feature space to a 64-dimensional feature space, resulting in a 1024×64-dimensional mapping matrix. Information loss during the mapping process is assessed through reconstruction error, requiring a value less than 5%. The final dimension of the ultra-sparse matrix is ​​64×8, with matrix elements having an absolute value less than 0.01 set to zero to further improve sparsity.

[0057] The specific implementation of step S06 is to construct an ultra-dense traffic matrix based on an ultra-sparse matrix through inverse mapping and data imputation algorithms. The inverse mapping process uses the least squares method to reconstruct the original high-dimensional data, and the data imputation algorithm uses interpolation to supplement missing data points. Cubic spline interpolation is used to ensure data smoothness. The rows of the ultra-dense traffic matrix represent time windows, and the columns represent service interfaces. Matrix elements record the request traffic data of each service interface within each time window, with the traffic data ranging from 0 to 10,000 requests per second. The application of the K-means clustering algorithm includes the random selection of initial cluster centers, the use of Euclidean distance for distance calculation, and the use of centroid calculation for cluster center updates. The number of clusters is set to 8, and the maximum number of iterations is set to 100. The dimension of the super-clustered service vector is equal to the number of service categories. The vector elements represent the central feature value of each service category, with the central feature value ranging from 0 to 10. The classification judgment of new services is based on the Euclidean distance to existing cluster centers, with a distance threshold set to 2.5.

[0058] The specific implementation of step S07 involves inputting the ultra-dense traffic matrix and ultra-clustered service vectors as input features into an adaptive resource prediction model to predict resource demand within the next 30 minutes. Preprocessing of the input features includes data standardization and normalization. Standardization uses a zero-mean, unit-variance method, and normalization maps the data to the 0-1 range. The output of the prediction model is the resource demand of each microservice instance within the future time window, including CPU, memory, and network bandwidth requirements. The load balancing matrix adjustment based on the prediction results employs a dynamic weight update algorithm, with an update frequency set every 10 minutes and an adjustment range controlled within ±20% of the original weight values. Dynamic load balancing is implemented by comparing the predicted resource demand with currently available resources; when the predicted demand exceeds 80% of available resources, a load redistribution mechanism is triggered.

[0059] Further explanation is needed regarding the adaptive resource prediction model, which employs a multilayer perceptron architecture. This architecture comprises an input layer, three hidden layers, and an output layer—a feedforward neural network structure. The input layer has 72 neurons, corresponding to the concatenation of the 64-dimensional feature vector of the reduced-dimensionality ultra-dense traffic matrix and the 8-dimensional feature vector of the super-clustered service vector. The first hidden layer contains 128 neurons, the second hidden layer contains 64 neurons, and the third hidden layer contains 32 neurons, all connected via full connectivity. The output layer has the same number of neurons as the dimension n×m of the load balancing matrix, and is used to output the predicted resource requirements of each microservice instance for various load types. The activation function in all hidden layers is a modified linear unit function, while the output layer uses a linear activation function. The optimizer uses the adaptive moment estimation algorithm, with an initial learning rate of 0.001, a momentum parameter of 0.9, and an exponential decay rate of 0.999 for the second-order moment estimation.

[0060] The process of establishing the training dataset for the adaptive resource prediction model includes four stages: historical data collection, data preprocessing, feature engineering, and dataset partitioning. The historical data collection stage requires collecting more than six months of microservice runtime history data, including key indicators such as service request volume, response time, CPU utilization, memory usage, and network bandwidth usage. The data preprocessing stage cleans and formats the collected raw data, removing outliers and missing values. Outlier detection uses an interquartile range-based method, marking data points exceeding 1.5 times the interquartile range as outliers. The feature engineering stage slices the data according to 10-minute time windows, using the ultra-dense traffic matrix and ultra-clustered service vectors as input features, and the actual resource demand within the next 30 minutes of the corresponding time window as the prediction label. The dataset partitioning stage divides a total of 1 million samples into training, validation, and test sets in a 7:2:1 ratio. The training set is used for model parameter optimization, the validation set for hyperparameter tuning and early stopping mechanisms, and the test set for final performance evaluation.

[0061] The adaptive resource prediction model is trained using batch gradient descent with a batch size of 256 samples and a total of 1000 training epochs. Every 100 epochs, model performance is evaluated on the validation set, with evaluation metrics including root mean square error (RMSE) and mean absolute error (MAE). Early stopping is triggered when the validation set loss shows no significant decrease for 20 consecutive epochs; a significant decrease is defined as a relative improvement in the loss function value exceeding 0.001. The final performance target is a prediction accuracy of at least 85% on the test set, with the RMS error controlled within 10%. The model's generalization ability is evaluated using cross-validation, specifically 5-fold cross-validation, requiring performance differences between folds to be less than 5%.

[0062] It should be noted that the key technical ideas of this invention are mainly reflected in the following aspects. First, a multi-level caching mechanism based on latency-aware vectors. This mechanism monitors network latency in real time and dynamically activates local caching, which significantly reduces system response latency and improves resource utilization efficiency compared to traditional static caching strategies. Traditional methods typically employ fixed caching strategies, which cannot adaptively adjust according to changes in network status. This invention, however, achieves intelligent decision-making for caching strategies through latency-aware vectors. When network latency exceeds a threshold, the local caching mechanism is automatically activated, effectively reducing the latency overhead of remote access. Second, a collaborative dimensionality reduction processing technology combining exploding sparse matrices and ultra-dense traffic matrices. This technology achieves efficient storage and fast retrieval of monitoring data through multi-level data compression and reconstruction. Traditional data storage methods often face problems of insufficient storage space and low query efficiency. This invention, through the combination of sparse matrix compression storage and dense matrix rapid reconstruction, compresses storage space to 15% to 20% of the original while ensuring data integrity, and improves data access efficiency through optimized matrix operations. Thirdly, there is the sensitivity analysis mechanism of the jump detection matrix. This mechanism predicts sudden changes in system load by monitoring the correlation changes between key performance indicators in real time. Compared with traditional threshold monitoring methods, it has stronger predictive ability and faster response speed. Traditional monitoring systems are usually based on threshold judgment of a single indicator, which is prone to false alarms and false negatives. However, this invention can more accurately identify the trend of system state changes through multi-indicator correlation analysis and make load adjustments in advance to avoid system performance degradation.

[0063] The synergistic effect of these key technological approaches forms a complete adaptive load balancing system, offering significant technological advantages over traditional load balancing methods. Traditional load balancing typically relies on simple round-robin or weight allocation strategies, lacking deep perception and predictive capabilities regarding system status, making it difficult to cope with complex and ever-changing microservice environments. This invention constructs an intelligent load balancing system with self-learning and adaptive capabilities through the organic combination of latency awareness, sparse matrix compression, sensitivity analysis, and machine learning prediction. This system can accurately predict future resource demands based on historical data and real-time status, and achieve optimal resource allocation through multi-level optimization strategies, thereby maximizing resource utilization efficiency and service quality while ensuring system stability.

[0064] Specifically, the principle of this invention is as follows: This invention solves the technical problem that load balancing in microservice architectures cannot dynamically and adaptively adjust based on real-time performance monitoring data. Its technical principle lies in establishing a multi-layered dynamic perception and adaptive adjustment mechanism. First, by constructing a distributed service registry, key performance indicators such as CPU utilization, memory usage, and network bandwidth usage of microservice instances are collected, forming a real-time performance monitoring dataset to provide a data foundation for subsequent dynamic adjustments. Second, latency-aware vector technology is used to capture network latency changes, and an exploding sparse matrix is ​​used to efficiently compress and reduce the dimensionality of massive monitoring data, ensuring data integrity while improving processing efficiency. Third, the jump detection matrix calculates the sensitivity coefficients of various performance indicator changes, enabling timely detection of abnormal changes in system performance and triggering a weight adjustment mechanism. When the sensitivity coefficient exceeds a threshold, the weight allocation in the load balancing matrix is ​​automatically adjusted, achieving dynamic response based on performance changes. Furthermore, the principal component analysis algorithm of the ultra-sparse matrix effectively extracts key feature information, and the construction of the ultra-dense traffic matrix and ultra-clustered service vectors achieves a multi-layered mapping from the microservice level to the cluster level, enabling the load balancing strategy to adapt to resource scheduling needs at different granularities. Finally, the adaptive resource prediction model uses a multi-layer perceptron architecture to predict future resource demands and proactively adjusts load weights based on the prediction results, achieving predictive load balancing optimization. This multi-layered technical architecture ensures that the load balancing system can continuously and adaptively adjust based on real-time monitoring data, thus overcoming the technical limitations of traditional static load balancing methods.

[0065] The following provides a specific embodiment 1 of the present invention, and the specific implementation of each step in this embodiment 1 is described in detail below.

[0066] The specific implementation of step S01 involves first establishing a distributed service registry center, which uses a consistent hashing algorithm to achieve distributed storage and management of service instances. The initialization process of the load balancing matrix involves creating... A dimensional matrix structure, where matrix elements The calculation formula is: In the formula, Indicates the first The instance is for the first The processing capacity weights for each load type are dimensionless values, and the weight values ​​range from [value range missing]. , , , Indicates the number of microservice instances. Indicates the number of load types. For the first The CPU utilization of each instance, with a value range of [value missing]. , For the first The memory usage of each instance, with a value range of [value missing]. , For the first The network bandwidth utilization of each instance, with a value range of [value missing]. The real-time performance monitoring dataset is constructed using a time window-based data acquisition strategy with a 10-second acquisition interval. The monitoring data is stored using a circular buffer structure with a buffer size set to 1000 time windows.

[0067] The specific implementation of step S02 is to construct a latency-aware vector based on the real-time performance monitoring dataset. This vector is... A dimensional vector, represented as In the formula, Indicates the distance from the current node to the th node. The average response latency of a network node, in milliseconds, with a latency range of [missing value]. ms, Equal to the total number of network nodes Each element in the delayed sensing vector is obtained by calculating a moving average, using the following formula: In the formula, For the first From the point in time to the The latency value of each node, in milliseconds, is obtained in real time using the ping command or network probing tools. The sliding window size is set to 50 sampling points. The formula for calculating network latency weight is as follows: In the formula, This represents the network latency weight, a dimensionless value, with 100ms as the preset baseline latency. When Start the local caching mechanism at the appropriate time.

[0068] The specific implementation of step S03 is to construct an exploding sparse matrix using delayed-aware vectors, the matrix having dimension . ,in Number of time windows To monitor the number of metric types, including key indicators such as CPU utilization, memory usage, and network bandwidth usage, the construction of the exploding sparse matrix is ​​based on the detection of latency mutation points, and the detection threshold is calculated using the following formula: In the formula, The detection threshold is expressed in milliseconds (ms). The historical average latency is expressed in milliseconds (ms). This is achieved by analyzing historical data. The delay data from each sampling point is averaged to obtain the result. Set to 1000 sampling points, This represents the standard deviation of historical latency, measured in milliseconds (ms), and is obtained by calculating the standard deviation over the same historical data. When detected... At the corresponding position in the matrix A non-zero value is marked as 1, otherwise it is marked as 0. Time series data compression uses a wavelet transform-based compression algorithm, with the compression ratio controlled within the range of 15% to 20%, and the reconstruction error... Requirements must be met In the formula, To account for reconstruction errors, the units are the same as those for the original data. This represents the variance of the original data, expressed as the square of the original data units.

[0069] The specific implementation of step S04 is to construct a jump detection matrix based on the explosive sparse matrix, and this matrix is... A square matrix, represented as In the formula, This equals the number of key performance indicators (KPIs), which typically include metrics such as response time, throughput, and error rate. Indicates the first The first indicator for the first The sensitivity coefficient for each indicator change is a dimensionless value, and the range of the sensitivity coefficient is [value missing]. , The sensitivity coefficient was calculated using the Pearson correlation coefficient algorithm, and the formula is as follows: In the formula, For the first The first time point The standardized value of each indicator is a dimensionless numerical value, obtained by standardizing the original indicator value by dividing it by its maximum value. For the first The mean of each indicator is a dimensionless value. The number of sampling points within the time window is set to 100. .when Weight allocation adjustments are triggered on a time-limited basis, using gradient descent. The weight update formula is as follows: In the formula, For the first The weights after the next iteration are dimensionless values. For the first The weights for each iteration are dimensionless values. The learning rate is set to 0.01, which is a dimensionless constant. Let the mean squared error loss function be expressed as: In the formula For the first One predicted value, For the first One actual value, This represents the total number of samples.

[0070] The specific implementation of step S05 involves generating an ultra-sparse matrix using the jump detection matrix via principal component analysis. The formula for calculating the covariance matrix is ​​as follows: In the formula, Let be the covariance matrix with dimension . The matrix elements are dimensionless numerical values. The centered transition detection matrix is ​​achieved by subtracting the mean of the corresponding column from each column. The number of sampling points is set to 100. The eigenvalue decomposition formula is: In the formula, The eigenvector matrix has dimensions of . Each column is a unit eigenvector. It is an eigenvalue diagonal matrix with dimension 1. diagonal elements For the first The eigenvalues ​​are dimensionless numerical values, arranged in descending order. The formula for calculating the cumulative variance contribution rate is as follows: In the formula, For the front The cumulative variance contribution rate of each principal component is a dimensionless value, with a range of [value missing]. , For the first 1 eigenvalue, requiring 2 eigenvalues, ... The dimension reduction mapping matrix is: ,in For the first There are n principal feature vectors, and the matrix dimension is . The final supersparse matrix dimension is Matrix elements with an absolute value less than 0.01 are set to zero to improve sparsity.

[0071] The specific implementation of step S06 is to establish an ultra-dense flow matrix based on the ultra-sparse matrix, and reconstruct it using the least squares method through inverse mapping. The reconstruction formula is as follows: In the formula, For reconstructing a high-dimensional data matrix, the dimension is , It is an ultra-sparse matrix with dimension . , Let be a mapping matrix with dimension . Data imputation uses cubic spline interpolation to fill in missing data points, ensuring the matrix element density reaches over 90%. The objective function of the K-means clustering algorithm is... In the formula, The value represents the objective function, and its unit is the same as the data point. As an indicator variable, when data points Belongs to clustering hour Otherwise, it is 0. For the first There are 10 data points, in vector form. For the first There are 1 cluster centers, in vector form. The total number of data points. Set the number of clusters to 8. , The formula for updating cluster centers is: ; where cluster center The centroids of all data points assigned to this cluster are calculated, with a maximum iteration count set to 100. The super-cluster service vector is represented as follows: ,in For the first The central feature value of each service category, with the central feature value ranging from... The value is obtained by averaging the feature values ​​of all data points within the corresponding cluster. The new service classification uses Euclidean distance, with the formula: In the formula, For new services To the cluster center The Euclidean distance, with units identical to the eigenvectors, is calculated. The feature vector for the new service is obtained through real-time monitoring. It should be classified into the corresponding category.

[0072] The specific implementation of step S07 involves inputting the ultra-dense traffic matrix and the ultra-clustered service vector into the adaptive resource prediction model, where the input feature vector is represented as... The first 64 dimensions are the dimensionality reduction features of the ultra-dense traffic matrix, and the last 8 dimensions are the super-clustered service vector features. For the first The eigenvalues ​​are obtained by performing dimensionality reduction through principal component analysis on the ultra-dense flow matrix and concatenating the service vectors from hyper-clustering. The data standardization formula is: In the formula, For the standardized first Each eigenvalue is a dimensionless numerical value. For the original number 1 eigenvalue, For the first The mean of each feature is calculated using the training dataset. For the first The standard deviation of each feature is calculated using the training dataset. The output of the prediction model is... In the formula, To predict the output vector, the dimension is... The corresponding dimension of the load balancing matrix. , , These are the transformation functions for the three hidden layers, using the ReLU activation function, and are expressed as follows: , The output layer transformation function uses a linear activation function. The dynamic weight update formula is as follows: In the formula, The updated weights are dimensionless values. This represents the current weight, which is a dimensionless value. The adjustment coefficient has a range of values. This is used to control the adjustment range within ±20% of the original weight value. For the predicted resource demand, This sets the current resource requirements and updates every 10 minutes.

[0073] It should be explained that the principle of the load balancing matrix calculation formula is based on the weighted linear combination method;

[0074] ;

[0075] This formula comprehensively evaluates the load processing capacity of a service instance by weighting and summing CPU utilization, memory usage, and network bandwidth usage. The weighting coefficients of 0.4, 0.3, and 0.3 are based on the dominant role of CPU resources in system performance. Compared with traditional single-indicator evaluation methods, this formula can more comprehensively reflect the true performance status of the service instance, effectively avoid the problem of uneven load distribution caused by a single resource bottleneck, and improve the overall resource utilization efficiency and service quality of the system.

[0076] The formula for calculating the moving average of the delayed sensing vector uses a time window smoothing algorithm.

[0077] ;

[0078] This formula effectively reduces the impact of network latency fluctuations on system performance evaluation by smoothing historical latency data over a time window. The setting of a sliding window size of 50 sampling points ensures both the real-time nature of the data and the stability of the statistical results. Compared with instantaneous latency measurement methods, this formula provides more stable and reliable latency evaluation results, providing a more accurate data foundation for system load balancing decisions.

[0079] The network latency weight calculation formula is based on the ratio standardization method;

[0080] ;

[0081] This formula converts latency into a dimensionless weighting coefficient, and achieves a quantitative assessment of latency by comparing it with a baseline latency of 100ms. The selection of the baseline value of 100ms is based on the normal response time in a typical local area network environment. Compared with the absolute latency value judgment method, this formula can better adapt to latency changes in different network environments, improve the accuracy of the cache triggering mechanism and the system's adaptability.

[0082] The formula for calculating the Pearson correlation coefficient of the jump detection matrix quantifies the correlation between indicators through statistical correlation analysis;

[0083] ;

[0084] This formula quantifies the correlation between different performance indicators, enabling early warning and dynamic response to changes in system performance. The numerator calculates the covariance to reflect the strength of the linear relationship between indicators, while the denominator is standardized to ensure the comparability of results. Compared with traditional threshold detection methods, this formula can capture more subtle performance change patterns, improving the system's sensitivity to load changes and response speed.

[0085] The covariance matrix calculation formula of the principal component analysis algorithm is based on the variance-covariance analysis theory;

[0086] ;

[0087] This formula effectively reduces data storage space and computational complexity through dimensionality reduction, while preserving the main informational features of the original data. Using unbiased estimation ensures the accuracy of covariance calculation. Compared with methods that directly use high-dimensional data, this formula significantly improves the computational efficiency of subsequent processing and reduces the storage cost of the system. The data after dimensionality reduction can still maintain more than 95% of the information integrity.

[0088] The objective function of the K-means clustering algorithm is based on the optimization theory of minimizing intra-cluster distance;

[0089] ;

[0090] This formula achieves intelligent service classification by minimizing intra-class distance. The squared distance in the objective function ensures the compactness of the clustering results, and the indicator variable... The use of this formula enables hard segmentation clustering. Compared with traditional static service classification methods, this formula can dynamically cluster services based on their actual operational characteristics, improving the accuracy of service management and the rationality of system resource allocation.

[0091] The dynamic weight update formula employs a predictive feedback adjustment mechanism;

[0092] ;

[0093] This formula achieves proactive load balancing of the system by comparing the predicted results with the current state and adjusting the load weights. The adjustment coefficient... The settings ensure the stability and convergence of the system adjustment, and the prediction error term This formula reflects the system's expected adjustment direction for future states. Compared with passive response load adjustment methods, this formula can predict changes in resource demand in advance and proactively adjust the load allocation strategy, effectively avoiding the occurrence of system performance bottlenecks and improving the overall system stability and responsiveness.

[0094] It should be noted that the variables involved in this embodiment are explained in detail in Table 1 below.

[0095] Table 1. Variable Explanation Table

[0096]

[0097] To better understand and implement this invention, a specific application scenario is provided below as Example 2: A technical team is responsible for developing a microservice system for an e-commerce platform. This platform includes core service modules such as user management, product management, order processing, payment services, and inventory management. With rapid business growth, the system faces challenges such as a surge in the number of service instances, uneven load distribution, and fluctuating response latency. The technical team decided to use the low-code microservice architecture client-side unlimited scaling system of this invention to solve these problems.

[0098] During the initial system deployment phase, the technical team built a distributed service registry and established an initial cluster environment containing 24 microservice instances. Through real-time monitoring, they acquired data on the CPU utilization, memory usage, and network bandwidth usage of each service instance. Based on the collected performance data, a 24×3-dimensional load balancing matrix was established, where the matrix elements... The calculation uses a weighted approach, with CPU utilization weighted at 0.4, memory usage weighted at 0.3, and network bandwidth usage weighted at 0.3. After initial calculation, the load weights are: User Management Service 0.65, Product Management Service 0.72, Order Processing Service 0.84, Payment Service 0.58, and Inventory Management Service 0.77.

[0099] During the construction of the latency-aware vector, the technical team deployed 12 multi-level service discovery proxy nodes, distributed across different network regions. Through statistical analysis of real-time performance monitoring data, a 12-dimensional latency-aware vector was constructed. The elements in the vector... The latency parameters are as follows: local node latency 15ms, same-city node latency 35ms, neighboring city node latency 85ms, cross-province node latency 145ms, cross-regional node latency 280ms, and international node latency 520ms. When the network latency weight of an international node exceeds the 500ms threshold, the system automatically activates the local caching mechanism, setting the cache validity period to 300 seconds, achieving an 82% cache hit rate.

[0100] Based on delay-aware vectors, the system constructs a 144×18 dimensional exploded sparse matrix, where 144 time windows correspond to a 12-hour monitoring period, and 18 monitoring indicators cover key performance parameters such as response time, throughput, and error rate. A compressed sparse row format is used for storage, with the proportion of non-zero elements in the matrix controlled at 4.2%. Through a time-series data compression strategy, the original monitoring data is compressed from 2.8GB to 516MB, achieving a compression rate of 18.4%. The compression process employs a wavelet transform algorithm, retaining low-frequency coefficients and discarding high-frequency noise to ensure no loss of critical information.

[0101] During the transition detection matrix construction process, the system identified eight key performance indicators, forming an 8×8 square matrix. Matrix elements The sensitivity coefficients between the various indicators are shown in Table 2:

[0102] Table 2 Sensitivity Coefficients of Key Indicators in the Jump Detection Matrix

[0103]

[0104] When the system detects that the sensitivity coefficient of throughput to CPU utilization reaches 0.94, exceeding the threshold of 0.8, it triggers the weight adjustment mechanism of the load balancing matrix.

[0105] By processing the transition detection matrix using principal component analysis (PCA), the system generates a 64×8 dimensional ultra-sparse matrix. The first eight principal eigenvectors are selected to construct a dimensionality reduction mapping framework, achieving a cumulative variance contribution rate of 96.3%, thus realizing an efficient mapping from 1024 dimensions to 64 dimensions. Elements with absolute values ​​less than 0.01 in the matrix are set to zero, further improving storage efficiency.

[0106] The ultra-dense traffic matrix was constructed based on 72 time windows and 156 service interfaces, achieving a matrix density of 92.1%. Through reverse mapping and data filling algorithms, the system recorded the request traffic data for each service interface within each time window. During peak periods, the user login interface saw 8500 requests per second, the product search interface 6800 requests per second, the order submission interface 4200 requests per second, and the payment interface 3600 requests per second.

[0107] Using the K-means clustering algorithm, the system generated 8-dimensional super-clustered service vectors from the ultra-dense traffic matrix. The central feature values ​​of each service category are as follows: User service category 7.2, Product service category 6.8, Order service category 8.1, Payment service category 5.9, Inventory service category 7.5, Logistics service category 6.3, Customer service category 4.7, and Data analysis service category 5.2. When the Euclidean distance between a newly deployed recommendation service and the center of the Product service category is 2.1, which is less than the threshold of 2.5, it is successfully classified into the Product service category.

[0108] The adaptive resource prediction model employs a multilayer perceptron architecture, comprising an input layer of 72 neurons, a first hidden layer of 128 neurons, a second hidden layer of 64 neurons, a third hidden layer of 32 neurons, and an output layer of 72 neurons. The input layer receives a concatenation of a 64-dimensional feature vector from an ultra-dense traffic matrix and an 8-dimensional feature vector from a super-clustered service vector. The system collected eight months of microservice runtime history data, establishing a training dataset containing 1.2 million samples, which was divided into training, validation, and test sets in a 7:2:1 ratio.

[0109] The model training process employed batch gradient descent with a batch size of 256 and an initial learning rate of 0.001. After 850 training epochs, the training stopped early when the validation set loss showed no significant decrease for 20 consecutive epochs. The final model achieved a prediction accuracy of 87.3% on the test set, with the root mean square error of the prediction error controlled at 8.7%.

[0110] Microservice-level mapping handles resource allocation for individual service instances, node-level mapping handles resource scheduling for individual physical nodes, and cluster-level mapping handles load balancing for the entire cluster. In actual operation, the system performs dynamic adjustments every 10 minutes, with the adjustment range controlled within ±20% of the original weight values.

[0111] In a typical load fluctuation scenario, the system predicted a 45% increase in resource demand for the order processing service within the next 30 minutes. Based on this prediction, the system automatically adjusted the load balancing matrix, raising the weight of the order processing service from 0.84 to 1.01 while lowering the weight of the inventory management service to 0.62, thus achieving dynamic resource reallocation. Through this predictive adjustment, the system successfully handled the traffic surge brought by promotional activities, avoiding a significant increase in service response time.

[0112] The system demonstrated excellent adaptive capabilities during operation. When a network failure occurred in a data center, the latency-aware vector quickly detected the anomaly and triggered a local caching mechanism. The system automatically routed affected service requests to other functioning data centers, ensuring service continuity. Simultaneously, the exploding sparse matrix captured this anomaly pattern, providing data support for subsequent fault prediction.

[0113] Through a hierarchical mapping mechanism, the system achieves fine-grained resource management. At the microservice level, the system dynamically allocates CPU and memory resources based on the real-time load of each service instance. At the node level, the system optimizes container deployment strategies to ensure complementary resource requirements for service instances on the same physical node. At the cluster level, the system coordinates load distribution across data centers, achieving globally optimal resource utilization.

[0114] In this embodiment, Figure 2 The dynamic adjustment process of microservice load weights demonstrates the dynamic changes in the load weights of five core microservices (user management, product management, order processing, payment, and inventory management) over a 30-minute period, including adjustment thresholds, reflecting the system's predictive adjustment process in response to traffic surges during promotional activities. Figure 3 The latency-aware vector analysis shows the latency-aware vector distribution of 12 multi-level service discovery agent nodes. Combined with cache hit rate data, the 500ms threshold line is highlighted, demonstrating the intelligent feature of the system automatically activating the caching mechanism based on network latency. Figure 4 The time distribution of the ultra-dense flow matrix shows the flow density distribution of the four main interfaces over 24 hours. It adopts the form of a stacked area map, marking the peak period and reflecting the flow pattern with a density of 92.1% in the 72×156-dimensional ultra-dense flow matrix.

[0115] This invention represents a significant technological advancement over traditional microservice architecture management methods. Traditional methods typically employ static load balancing strategies, which struggle to adapt to dynamically changing business needs. This invention, by constructing a multi-layered data abstraction matrix, achieves a step-by-step transformation from raw monitoring data to high-level decision-making information, enabling the system to perform accurate resource prediction and scheduling at different time scales. The introduction of latency-aware vectors allows the system to perceive changes in the network environment and proactively activate caching mechanisms to reduce response latency. The compressed storage strategy of the exploding sparse matrix significantly reduces storage overhead while maintaining data integrity. The jump detection matrix enables early anomaly detection through sensitivity analysis, preventing a sharp decline in system performance. The collaborative work of ultra-sparse and ultra-dense traffic matrices achieves efficient data compression and rapid recovery, balancing storage efficiency and computational performance. The adaptive resource prediction model, based on deep learning algorithms, can capture complex nonlinear patterns, achieving prediction accuracy far exceeding traditional time series analysis methods.

[0116] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention.

Claims

1. A development method for a low-code microservice architecture client-side unlimited scalability system, characterized in that, Construct a distributed service registry and initialize a load balancing matrix. Establish a real-time performance monitoring dataset by collecting CPU utilization, memory usage, and network bandwidth usage of microservice instances. Based on the real-time performance monitoring dataset, construct a latency-aware vector, deploy multi-level service discovery proxy nodes, and calculate the network latency weight between each proxy node and the target service. An exploding sparse matrix is ​​constructed using delay-aware vectors to reduce the dimensionality of the real-time performance monitoring dataset, and a time-series data compression storage strategy is adopted. A jump detection matrix is ​​constructed based on the exploding sparse matrix. The sensitivity of the eigenvalues ​​of the jump detection matrix to changes in service load parameters is calculated, and the weight distribution in the load balancing matrix is ​​adjusted accordingly. A super-sparse matrix is ​​generated using the jump detection matrix through principal component analysis algorithm, and the principal eigenvectors are selected to construct a dimensionality reduction mapping framework. An ultra-dense traffic matrix is ​​established based on an ultra-sparse matrix. A super-clustered service vector is generated from the ultra-dense traffic matrix using the K-means clustering algorithm, realizing a step-by-step mapping process from the microservice level to the cluster level. The ultra-dense traffic matrix and the super-clustered service vector are input into an adaptive resource prediction model to predict future resource demand. Based on the prediction results, the load balancing matrix is ​​further adjusted to achieve dynamic load balancing. Wherein, the delayed sensing vector is dimensional vector, Equal to the total number of network nodes, vector elements Indicates the distance from the current node to the th node. The average response latency of each network node, with a latency range of [missing information]. ∈[10, 1000] ms, obtained through statistical analysis of network latency data in the real-time performance monitoring dataset; The exploding sparse matrix is ​​stored in a compressed sparse row format, and the matrix dimension is [missing information]. ,in Number of time windows To monitor the number of indicator types, the proportion of non-zero elements in the matrix is ​​controlled to be below 5%, and the element value range is matrix element ∈ [0, 100]. It is constructed by detecting and marking delay mutation points in the delay-aware vector. The jump detection matrix is ​​as follows: The square formation, Equals the number of key performance indicators, matrix elements Indicates the first The first indicator for the first The sensitivity coefficient for changes in each indicator, with a sensitivity coefficient range of [value missing]. ∈[0,2], obtained by analyzing the temporal changes of non-zero elements in the exploded sparse matrix; The ultra-sparse matrix has a dimension of 64×8 and is constructed by processing the transition detection matrix using principal component analysis. It retains the principal eigenvectors with a cumulative variance contribution rate of over 95%, and sets the absolute value of matrix elements less than 0.01 to zero. The ultra-dense traffic matrix is ​​a time series matrix, with rows representing time windows and columns representing service interfaces. The matrix element density reaches over 90% and is constructed by the inverse mapping and data filling algorithm of the ultra-sparse matrix. It records the request traffic data of each service interface within each time window, and the traffic data range is request traffic ∈ [0, 10000] times / second.

2. The development method of the low-code microservice architecture client-side unlimited scalability system according to claim 1, characterized in that, The load balancing matrix is A dimensional matrix, where The matrix elements represent the number of microservice instances, m represents the number of load types, and matrix elements. Indicates the first The instance is for the first The processing capacity weights for different load types, with weight values ​​ranging from [value range missing]. ∈[0,1], is calculated by weighting CPU utilization, memory usage and network bandwidth usage.

3. The development method of the low-code microservice architecture client-side unlimited scalability system according to claim 2, characterized in that, The dimension of the super-cluster service vector is equal to the number of service categories. The vector elements represent the central feature values ​​of each service category. The range of central feature values ​​is [0, 10]. When the Euclidean distance between a new service and the existing cluster center is less than the threshold of 2.5, it is assigned to the corresponding category.

4. The development method of the low-code microservice architecture client-side unlimited scalability system according to claim 3, characterized in that, The adaptive resource prediction model is structured as a multilayer perceptron, comprising an input layer, three hidden layers, and an output layer. The input layer has 72 neurons, the first hidden layer has 128 neurons, the second hidden layer has 64 neurons, the third hidden layer has 32 neurons, and the number of neurons in the output layer is equal to the dimension of the load balancing matrix. The activation function is the ReLU function, and the optimizer is the Adam algorithm.

5. The development method of the low-code microservice architecture client-side unlimited scalability system according to claim 4, characterized in that, When the network latency exceeds 500ms, the local caching mechanism is activated. The local caching mechanism is a distributed caching system that caches the access results of the target service to the local storage node. The cache validity period is set to 300 seconds, and the cache hit rate is maintained above 80%.

Images