Automatic operation and maintenance method and system suitable for distributed database

Abstract

The invention provides an automatic operation and maintenance method and system suitable for a distributed database, and the method comprises the steps: deploying a monitoring probe at each calculation node of the distributed database, collecting the data index of each node in real time, and dynamically calculating the gradient of each node; constructing a tilt feature library through a decision tree engine, and judging a tilt type based on a decision tree; according to information provided by the automatic diagnosis module, the automatic processing module has a dynamic tuning strategy, processing strategy selection and strategy matching are carried out on data according to a data skew mode, then according to diagnosis data provided by the automatic diagnosis module, the automatic processing module initiates a processing flow to carry out automatic processing, and a processing result is returned to the decision tree engine; and performing machine learning. According to the method, problems are found in advance through modes of real-time monitoring, automatic diagnosis, dynamic tuning and the like in large-scale parallel computing, and the problem of data skew is solved through automatic disposal.

Description

Technical Field

[0001] This invention relates to the field of big data storage and computing, and more specifically, to an automated operation and maintenance method and system suitable for distributed databases. Background Technology

[0002] In big data storage and computing, distributed databases are typically used to handle massively parallel computing. Data skew is a common problem during computation, referring to the uneven distribution of data or computational tasks among nodes, causing some nodes to be overloaded while others remain idle. This imbalance can trigger a series of issues, affecting system performance and stability, leading to performance bottlenecks and resource waste. Traditional methods for resolving data skew usually involve reactive troubleshooting after slow or delayed task execution occurs, failing to prevent data skew from arising in advance and thus increasing the risk of production problems. Summary of the Invention

[0003] This invention addresses the technical problems existing in the prior art by providing an automated operation and maintenance method and system suitable for distributed databases. In large-scale parallel computing, it can detect problems in advance through real-time monitoring, automatic diagnosis and dynamic optimization, and solve data skew problems through automated handling.

[0004] According to a first aspect of the present invention, an automated operation and maintenance method suitable for distributed databases is provided, comprising the following steps: Monitoring probes are deployed on each computing node of the distributed database to collect data indicators of each node in real time and dynamically calculate the tilt of each node. By using a decision tree engine, a tilt feature library is built, and the tilt type is determined based on the decision tree. Based on the data skewness, a data processing strategy is selected and matched. Then, based on the provided diagnostic data, a processing flow is initiated for automatic processing. The processing results are fed back to the decision tree engine for machine learning.

[0005] Based on the above technical solution, the present invention can also be improved as follows.

[0006] Optionally, the data metrics include the MAX node data volume and the average data volume metric; the dynamic calculation of the tilt of each node includes: The collected data is then standardized. Calculate the load score for each node based on the weight of each indicator; The tilt of each node is calculated based on the load score.

[0007] Optionally, the tilt feature library is divided into basic features and high-order features; the calculation of high-order features includes CPU tilt calculation and percentile feature calculation; the CPU tilt calculation uses linear regression to calculate the trend of the index changing over time; the percentile feature calculation constructs a slope array based on the slope of the CUP change trend of each node in the distributed database cluster, sorts the slopes of each node, and calculates the percentile of each node in the cluster, thereby determining whether the node is tilted.

[0008] Optionally, constructing the skewed feature library using a decision tree engine includes: Extract high-order features, compare them with the feature knowledge base, and determine the type of tilt. An intelligent decision tree classification model is constructed using a large AI model. Simulated data is used to train the intelligent decision tree classification model through machine learning for various tilt types, enabling the intelligent decision tree to calculate the tilt type through feature indicators.

[0009] Optionally, the basic features are directly acquired through step S1; the higher-order features are mainly derived from the basic features.

[0010] Optionally, the determination of skew type based on the decision tree includes: We use scikit-learn to build decision trees, introduce feature vectors, train decision model trees, use the fit method to train data to establish decision rules, and output readable decision rule trees to understand the model's judgment logic. Intelligent diagnosis is performed using intelligent decision trees. The provided feature indicators are converted into a two-dimensional array, and a trained decision model is used to make predictions. The predicted category number and the probability of each category are returned. The maximum value is taken as the confidence score to determine the type of skew.

[0011] Optionally, the strategy matching includes: selecting available strategies based on strategy priority and the severity threshold of triggering the strategy, including: limiting query resource utilization and data redistribution; the strategy selection includes: using a strategy selection function to select the optimal execution plan from available strategies based on the severity of the skew.

[0012] Optionally, the automatic handling module initiating a handling process based on the diagnostic data provided by the automatic diagnosis module includes: The intelligent diagnosis module obtains the diagnosis results, calls the strategy selection function, returns a list of strategies sorted by priority, and executes the treatment plans in the strategies in sequence; at the same time, the execution results are sent back to the intelligent decision model. The intelligent decision engine judges whether the treatment plan is effective based on the real-time data provided by the automatic acquisition module, and further trains the decision model to gradually optimize the intelligent decision engine. Based on the provided abnormal data, the decision tree engine performs automatic diagnosis. After diagnosis, the result set is transmitted to the automatic handling module to match the optimal handling plan. Then, based on the provided diagnostic data, the handling process is automatically initiated.

[0013] Optionally, the step of selecting and matching data processing strategies based on data skew patterns further includes: Initiate online rebalancing for skewed shards, including: intervening in query plans, automatically converting skewed JOINs to broadcast JOINs, and allocating additional temporary computing resources to lagging nodes for resource skew.

[0014] According to a second aspect of the present invention, an automated operation and maintenance system suitable for distributed databases is provided, comprising: The automatic data acquisition module deploys monitoring probes on each computing node of the distributed database to collect data indicators of each node in real time, dynamically calculate the tilt of each node, and provide the data to the automatic diagnosis module. The decision tree engine module builds a tilt feature library through the decision tree engine, determines the tilt type based on the decision tree, and sends the diagnostic indicators to the automatic processing module. The automatic processing module selects and matches processing strategies based on the data skew pattern. Based on the provided diagnostic data, it initiates the processing flow for automatic processing, and the processing results are sent back to the decision tree engine for machine learning.

[0015] The technical effects and advantages of this invention are as follows: This invention provides an automated operation and maintenance method and system for distributed databases. During large-scale parallel computing in distributed databases, an automatic monitoring device can detect potential data skew problems in advance, and an automatic handling module can resolve data skew problems. This avoids slow task operation and excessive resource consumption of some nodes caused by data skew, thereby improving the efficiency of data service operation.

[0016] Other features and advantages of the invention will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the invention. The objects and other advantages of the invention may be realized and obtained by means of the structures pointed out in the description, claims and drawings. Attached Figure Description

[0017] Figure 1 This invention provides an automated operation and maintenance method for distributed databases, with an automatic handling flowchart. Detailed Implementation

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

[0019] Understandably, given the deficiencies in the background technology, this invention proposes an automated operation and maintenance method suitable for distributed databases, specifically as follows: Figure 1 As shown, it includes the following steps: Step S1: Deploy monitoring probes on each computing node of the distributed database to collect data indicators of each node in real time and dynamically calculate the tilt of each node. The data metrics include the MAX node data volume and the average data volume metrics; the real-time collection of data metrics for each node and the dynamic calculation of the tilt of each node include: Deploy monitoring probes to collect metrics. Use eBPF (Linux kernel-level collection) technology to deploy monitoring probes and collect real-time performance metrics of each node in the distributed database, including: CPU utilization, memory utilization, disk I / O throughput, network bandwidth usage, query response time, number of concurrent connections, and data partition size. The collected data is transmitted to the analysis module in real time using the lightweight gRPC protocol for dynamic calculation of tilt.

[0020] The dynamic calculation of the tilt of each node includes: First, the data is standardized to facilitate calculation.

[0021] Standardization processing logic: Create an empty dictionary to store the standardization results; Iterate through each monitoring metric: check if the maximum / minimum value of the metric is the same (to prevent division by zero error). If they are the same, directly assign the value 0.5 (intermediate value). If they are different, calculate: (current value - minimum value) / (maximum value - minimum value). Apply double boundary constraints to the calculation result (force it to be within the range of 0 to 1). Return the standardized metric dictionary.

[0022] Anomaly handling: Automatically handles extreme value cases to ensure that calculation results always remain within a reasonable range. The code is as follows: def normalize(metrics, min_vals, max_vals): norm_metrics = {} for k, v in metrics.items(): norm_metrics[k] = (v - min_vals[k]) / (max_vals[k] - min_vals[k]) return norm_metrics Then, the load score is calculated: based on the weight of each indicator, such as CPU weight being 0.3 and memory indicator weight being 0.25, the load score for each node is calculated. The specific calculation method is as follows: Predefined weight configuration: CPU utilization: 30%, Memory utilization: 25%, Disk I / O: 20%, Network bandwidth: 15%, Query response: 10%. Calculation steps: Initialize the total score to 0. Iterate through each predefined indicator: Obtain the indicator value from the standardized data (use the default value of 0.5 if missing). Multiply the indicator value by the corresponding weight coefficient and sum them to the total score. Return the final load score (range 0-1). The formula is as follows: weights = { 'cpu': 0.3, 'memory': 0.25, 'disk_io': 0.2, 'network': 0.15, 'query': 0.1 } def calculate_load_score(norm_metrics): score = 0 for metric, weight in weights.items(): score += norm_metrics.get(metric, 0) x weight return score Cluster skewness calculation: The skewness of each node is calculated based on the load score. Input: A list of load scores for all nodes. Calculation process: Calculate the average load of the cluster The variance is calculated by summing the scores of all nodes and dividing by the number of nodes. Square the difference between the score and the average for each node. Sum of all squared differences and divide by the number of nodes Calculate the standard deviation: take the square root of the variance. Final tilt: Standard deviation divided by the mean, multiplied by 100, converted to percentage Output meaning: The larger the percentage value, the more unbalanced the cluster load.

[0023] The formula is as follows: def calculate_skewness(node_scores): mean = sum(node_scores) / len(node_scores) variance = sum((x - mean) x 2 for x in node_scores) / len(node_scores) std_dev = variance x 0.5 return (std_dev / mean) x 100 # Returns a percentage. Step S2: Construct a tilt feature library using a decision tree engine, and determine the tilt type based on the decision tree; The tilt feature library includes: historical tilt patterns + solutions.

[0024] The construction of the skewed feature library using a decision tree engine includes: Extract high-order features, compare them with the feature knowledge base, determine the type of skew, and provide production balance suggestions; The tilt feature library is divided into basic features and higher-order features. Basic features are directly collected by the monitoring probe in step S1. These mainly include the following indicators: 'cpu_usage': 'Current CPU utilization (%)' 'mem_usage': 'Memory usage (%)' 'disk_iops': 'Disk IOPS', 'net_in': 'Network input traffic (MB / s)', 'net_out': 'Network outbound traffic (MB / s)' The higher-order features are mainly derived from the basic features. The main types and calculation methods of higher-order features are as follows: # Time series characteristics 'cpu_trend': 'CPU usage slope over 5 minutes' 'mem_growth': 'Memory growth rate per minute' # Association Features 'io_per_query': 'Average number of IO operations per query' 'cpu_per_conn': 'CPU resources used per connection' # Statistical characteristics 'deviation_3sigma': '3σ deviation of the indicator value from the cluster mean' 'percentile_90th': 'The percentile of the metric value in the cluster' } Higher-order feature computation includes CPU-skewed computation and percentile feature computation; among which: CPU skew calculation includes: using linear regression to calculate the trend of the index over time, specifically as follows: First, import the linear regression function `linregress`. Then, create an x-axis sequence, generating an evenly spaced sequence starting from 0. Call the linear regression function to perform linear regression calculations on the x and y values, returning the slope value. Multiplying the slope value by 60 gives the rate of change of the CUP index per minute. The specific calculation code is as follows: from scipy.stats import linregress def calculate_trend(history_values): """Calculate the slope of the indicator's changing trend""" x = np.arange(len(history_values)) slope, _, _, _, _ = linregress(x, history_values) `return slope x 60#` converts the slope to a rate of change per minute. Percentile feature calculation: Based on the calculated slope of the CUP change trend of each node in the distributed database cluster, a slope array is constructed. The slopes of each node are sorted, and the percentile of each node in the cluster is calculated. This allows determination of whether the node is skewed. The specific code is as follows: def calculate_percentile(current_value, cluster_values): """Calculate the percentile of the current value within the cluster""" sorted_values ​​= np.sort(cluster_values) return np.searchsorted(sorted_values, current_value) / len(sorted_values) x100; In this embodiment, an intelligent decision tree classification model is constructed using AI large-scale model technology. Simulated data is used to train the intelligent decision tree classification model through machine learning, enabling it to calculate the tilt type based on feature indicators, for various tilt types. The specific implementation method is as follows: Define skew type: CPU-intensive: CPU utilization is significantly higher than other resources; Memory-intensive: Memory usage is significantly high; IO-intensive: Disk IOPS metrics are abnormally high; Network-intensive: Network bandwidth utilization is dominant; Composite type: Multiple resources experience high loads simultaneously; Uneven query distribution: Uneven resource distribution caused by specific queries.

[0025] The decision tree-based skew type determination includes: This code uses scikit-learn to build a decision tree, introduces feature vectors, trains the decision model tree, and uses the `fit` method to establish decision rules from the training data. It outputs a readable decision rule tree, making it easier to understand the model's decision logic. Example code: from sklearn.tree import DecisionTreeClassifier, export_text # Example training data X_train = [ [85, 30, 1200, 50, 0.9, 0.2], # CPU-intensive case [40, 90, 800, 30, 0.3, 0.8], # Memory-intensive case [60, 50, 5000, 10, 0.5, 0.1], # I / O intensive case # ...more training samples ] y_train = [0, 1, 2, ...] # Corresponding category labels # Building a decision tree clf = DecisionTreeClassifier( max_depth=5, criterion='gini', min_samples_split=10 ) clf.fit(X_train, y_train) # Output decision rules print(export_text(clf, feature_names=[ 'cpu_usage', 'mem_usage', 'disk_iops', 'net_usage', 'cpu_percentile', 'mem_percentile' ])) Intelligent diagnosis is performed using an intelligent decision tree. The feature indicators provided in step S1 are converted into a two-dimensional array. The trained decision model is used to make predictions, and the predicted category number and the probability of each category are returned. The maximum value is taken as the confidence level to determine the type of tilt.

[0026] Example code is as follows: def diagnose_skew_type(node_features, cluster_stats): # Calculate dynamic features features = [ node_features['cpu_usage'], node_features['mem_usage'], node_features['disk_iops'], (node_features['net_in'] + node_features['net_out']) / 2, calculate_percentile(node_features['cpu_usage'], cluster_stats['cpus']), calculate_percentile(node_features['mem_usage'], cluster_stats['mems']) ] # Predicting the type of tilt skew_type = clf.predict([features])[0] confidence = np.max(clf.predict_proba([features])) return SKEW_TYPES[skew_type], confidence Step S3: Select and match data processing strategies based on the data skew pattern. Then, based on the provided diagnostic data, initiate the processing flow for automatic processing. The processing results are sent back to the decision tree engine for machine learning.

[0027] In this embodiment, based on the information provided by the automatic diagnosis module, the automatic treatment module has a dynamic optimization strategy. It selects a treatment strategy based on the tilt type provided in step S2, performs strategy matching, and then selects a suitable treatment method. The specific implementation is as follows: For strategy matching, the system predefines handling strategies corresponding to different skew types, which are stored in the dictionary SKEW_STRATEGIES. Based on the strategy priority and the severity threshold of the triggered strategy, an available strategy is selected, such as limiting query resource utilization or data redistribution.

[0028] SKEW_STRATEGIES = { 'CPU_SKEW': [ {'action': 'throttle_queries', 'priority': 1, 'threshold': 90}, {'action': 'redirect_queries', 'priority': 2, 'threshold': 85}, {'action': 'migrate_partitions', 'priority': 3, 'threshold': 80} ], 'MEMORY_SKEW': [ {'action': 'clear_cache', 'priority': 1}, {'action': 'adjust_mem_alloc', 'priority': 2} ] } Strategy selection uses a strategy selection function to choose the optimal execution plan from available strategies based on the severity of the skew. Example code: def select_strategy(skew_type, severity): available = SKEW_STRATEGIES.get(skew_type, []) # Filter by severity applicable = [s for s in available if severity>= s.get('threshold',0)] # Sort by priority return sorted(applicable, key=lambda x: x['priority']) The automatic handling module initiates a handling process based on the diagnostic data provided by the automatic diagnosis module, including: After obtaining the diagnostic results, the aforementioned strategy selection function is invoked, returning a list of strategies sorted by priority. The treatment plans within each strategy are then executed sequentially. Simultaneously, the execution results are fed back to the intelligent decision-making model. The intelligent decision-making engine uses the provided real-time data to determine the effectiveness of the treatment plan and further trains the decision-making model, gradually optimizing the intelligent decision-making engine.

[0029] Specifically, the complete processing procedure of the present invention is exemplified as follows: Case Study: Handling CPU-related skew The automatic monitoring module detected an anomaly, with the following main characteristics: 1) Node 3's CPU utilization reached 95% for three minutes. 2) Query rate: 200 qps, CPU consumption per query: 0.45% The automatic diagnosis module uses the abnormal data provided by the monitoring module to perform automatic diagnosis through the decision tree engine. After diagnosis, the result set is transmitted to the automatic treatment module to match the optimal treatment plan. Diagnostic decision: features = { 'cpu': 95, 'cpu_trend': +8% / min, 'query_rate': 200, 'cpu_per_query': 0.0045 } skew_type = diagnose(features)# Return 'CPU_SKEW' strategies = select_strategy(skew_type, severity=85) # Return [throttle_queries, redirect_queries, migrate_partitions] Based on the diagnostic data provided by the automatic diagnostic module, the automatic treatment module initiates the treatment process.

[0030] First priority action: Query rate limiting throttle_queries('node3', 150) # Reduces queries from 200 to 150 The automatic monitoring module synchronously monitored the effect, and after 3 minutes, the CPU usage dropped to 88%. Second priority action: Query redirection redirect_queries('node3', ['node1', 'node4']) Final result: CPU usage stabilized at 75%.

[0031] Finally, the results of this action are fed back to the decision tree engine, which records the results, updates the strategy weights, and matches a better action process for subsequent actions.

[0032] The selection and matching of data processing strategies based on data skew patterns also includes: Initiate online rebalancing for skewed shards, including: intervening in query plans, automatically converting skewed JOINs to broadcast JOINs, and allocating additional temporary computing resources to lagging nodes for resource skew.

[0033] In summary, the embodiments of the present invention, during the large-scale parallel computing of distributed databases, use an automatic monitoring device to detect potential data skew problems in advance, and use an automatic handling module to resolve data skew problems, thereby avoiding slow task operation and excessive resource consumption of some nodes caused by data skew, and improving the efficiency of data service operation.

[0034] This invention provides an automated operation and maintenance system suitable for distributed databases, comprising: The automatic data acquisition module deploys monitoring probes on each computing node of the distributed database to collect data indicators of each node in real time, dynamically calculate the tilt of each node, and provide the data to the automatic diagnosis module. The decision tree engine module builds a tilt feature library through the decision tree engine, determines the tilt type based on the decision tree, and sends the diagnostic indicators to the automatic processing module. The automatic processing module selects and matches processing strategies based on the data skew pattern. Based on the provided diagnostic data, it initiates the processing flow for automatic processing, and the processing results are sent back to the decision tree engine for machine learning.

[0035] It is understood that the automated operation and maintenance system for distributed databases provided by this invention corresponds to the automated operation and maintenance method for distributed databases provided in the foregoing embodiments. The relevant technical features of the automated operation and maintenance system for distributed databases can be referred to the relevant technical features of the automated operation and maintenance method for distributed databases, and will not be repeated here.

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

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

[0038] Finally, it should be noted that the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. An automated operation and maintenance method suitable for distributed databases, characterized in that, Includes the following steps: Monitoring probes are deployed on each computing node of the distributed database to collect data indicators of each node in real time and dynamically calculate the tilt of each node. By using a decision tree engine, a tilt feature library is built, and the tilt type is determined based on the decision tree. Based on the data skewness, a data processing strategy is selected and matched. Then, based on the provided diagnostic data, a processing flow is initiated for automatic processing. The processing results are fed back to the decision tree engine for machine learning.

2. The automated operation and maintenance method for distributed databases according to claim 1, characterized in that, The data metrics include the MAX node data volume and the average data volume metric. The real-time acquisition of data indicators from each node and the dynamic calculation of the tilt of each node include: Standardize the collected data; Calculate the load score for each node based on the weight of each indicator; The tilt of each node is calculated based on the load score.

3. The automated operation and maintenance method for distributed databases according to claim 1, characterized in that, The tilt feature library is divided into basic features and high-order features; the calculation of high-order features includes CPU tilt calculation and percentile feature calculation; the CPU tilt calculation uses linear regression to calculate the trend of the index changing over time; the percentile feature calculation constructs a slope array based on the slope of the CUP change trend of each node in the distributed database cluster, sorts the slopes of each node, and calculates the percentile of each node in the cluster, thereby determining whether the node is tilted.

4. The automated operation and maintenance method for distributed databases according to claim 3, characterized in that, The basic features are obtained directly through monitoring probes; the higher-order features are derived from the basic features through calculation.

5. The automated operation and maintenance method for distributed databases according to claim 1, characterized in that, The construction of the skewed feature library using a decision tree engine includes: Extract high-order features, compare them with the feature knowledge base, and determine the type of tilt. An intelligent decision tree classification model is constructed using a large AI model. Simulated data is used to train the intelligent decision tree classification model through machine learning for various tilt types, enabling the intelligent decision tree to calculate the tilt type through feature indicators.

6. The automated operation and maintenance method for distributed databases according to claim 1, characterized in that, The decision tree-based skew type determination includes: We use scikit-learn to build decision trees, introduce feature vectors, train decision model trees, use the fit method to train data to establish decision rules, and output readable decision rule trees to understand the model's judgment logic. Intelligent diagnosis is performed using intelligent decision trees. The provided feature indicators are converted into a two-dimensional array, and a trained decision model is used to make predictions. The predicted category number and the probability of each category are returned. The maximum value is taken as the confidence score to determine the type of skew.

7. The automated operation and maintenance method for distributed databases according to claim 1, characterized in that, The selection and matching of data processing strategies based on data skew patterns also includes: Initiate online rebalancing for skewed shards, including: intervening in query plans, automatically converting skewed JOINs to broadcast JOINs, and allocating additional temporary computing resources to lagging nodes for resource skew.

8. The automated operation and maintenance method for distributed databases according to claim 7, characterized in that, The strategy matching includes: selecting available strategies based on strategy priority and the severity threshold of triggering the strategy, including: limiting query resource utilization and data redistribution; the strategy selection includes: using a strategy selection function to select the optimal execution plan from available strategies based on the severity of the skew.

9. The automated operation and maintenance method for distributed databases according to claim 1, characterized in that, The step of initiating an automated treatment process based on the provided diagnostic data includes: The system obtains diagnostic results, calls the strategy selection function, returns a list of strategies sorted by priority, and executes the treatment plans in the strategies in sequence. At the same time, the execution results are sent back to the decision tree engine. The decision tree engine judges whether the treatment plan is effective based on the provided real-time data, and further trains the decision model to gradually optimize the decision tree engine. The system automatically diagnoses abnormal data using a decision tree engine. After diagnosis, the result set is transmitted to the automatic handling module to match the optimal handling plan. Based on the provided diagnostic data, the handling process is automatically initiated.

10. An automated operation and maintenance system suitable for distributed databases, characterized in that, include: The automatic data acquisition module deploys monitoring probes on each computing node of the distributed database to collect data indicators of each node in real time, dynamically calculate the tilt of each node, and provide the data to the automatic diagnosis module. The decision tree engine module builds a tilt feature library through the decision tree engine, determines the tilt type based on the decision tree, and sends the diagnostic indicators to the automatic processing module. The automatic processing module selects and matches processing strategies based on the data skew pattern. Based on the provided diagnostic data, it initiates the processing flow for automatic processing, and the processing results are sent back to the decision tree engine for machine learning.

Images