Intelligent fault self-healing and performance optimization method and device based on K8s and MCP

Abstract

The embodiment of the invention relates to the technical field of operation and maintenance, and discloses an intelligent fault self-healing and performance optimization method and device based on K8s and MCP, and the method comprises the steps: obtaining standard multi-dimensional data which is a comprehensive data set which accords with the MCP protocol specification and reflects the overall operation condition and performance of K8s; performing detection processing on the standard multi-dimensional data based on a fault detection model, identifying fault risk information, and positioning to a target fault based on the fault risk information and a preset knowledge graph; analyzing the standard multi-dimensional data by combining time sequence analysis with statistical analysis, predicting a prediction performance problem after the current moment, and identifying performance bottleneck information; generating a fault solving instruction based on the fault risk information and the target fault, and executing the fault solving instruction to realize fault self-healing; and generating a performance optimization instruction based on the performance bottleneck information and the prediction performance problem, and executing the performance optimization instruction to perform performance optimization. And the data interoperability is improved based on the MCP protocol specification.

Description

Technical Field

[0001] This invention relates to the field of operation and maintenance technology, and in particular to an intelligent fault self-healing and performance optimization method and device based on K8s and MCP. Background Technology

[0002] With the widespread adoption of cloud computing and containerization technologies, Kubernetes (K8s) has become the mainstream container orchestration platform, supporting the operation of large-scale, highly dynamic distributed applications. However, the complex architecture, numerous components, and tight dependencies of K8s clusters present many challenges to their operation and maintenance. Existing technologies suffer from the following prominent problems in practical applications: First, inconsistent data formats and poor communication protocol compatibility among different monitoring systems and components lead to difficulties in data interaction, high integration costs, and challenges in achieving globally unified observability. Second, when faced with new and complex fault scenarios (such as cascading failures, resource contention, and abnormal network policies), traditional methods based on single-indicator analysis suffer from detection lag and inaccurate alarms, failing to meet real-time requirements. Third, fault localization relies heavily on manual experience for log review and link analysis, resulting in low efficiency, high error rates, and difficulty in quickly identifying root causes. Furthermore, existing self-healing mechanisms are mostly limited to simple operations such as restarting Pods, lacking automated processing capabilities for complex faults and still requiring significant manual intervention. In terms of performance management, resource allocation generally relies on static thresholds, and optimization strategies lag behind actual load changes, easily leading to resource waste or performance bottlenecks. Simultaneously, performance bottleneck identification lacks accurate attribution analysis and trend prediction capabilities, making it difficult to provide effective support for capacity planning and dynamic scheduling. Therefore, it can be seen that the existing K8s operation and maintenance system has obvious shortcomings in terms of data interoperability, fault response capability, automation level and intelligent performance optimization. Summary of the Invention

[0003] The purpose of this invention is to provide at least one intelligent fault self-healing and performance optimization method and device based on K8s and MCP, which can at least solve the technical problems that the K8s operation and maintenance system has significant deficiencies in data interoperability, fault response capability, automation level and intelligent performance optimization, and can at least improve the K8s operation and maintenance system in terms of data interoperability, fault response capability, automation level and intelligent performance optimization.

[0004] To address the aforementioned technical problems, at least one embodiment of this application provides an intelligent fault self-healing and performance optimization method based on Kubernetes and MCP, comprising: acquiring standard multi-dimensional data, wherein the standard multi-dimensional data is a comprehensive data set that conforms to the MCP protocol specification and reflects the overall operating status and performance of Kubernetes; performing detection processing on the standard multi-dimensional data based on a fault detection model to identify fault risk information, and locating the target fault based on the fault risk information and a preset knowledge graph; analyzing the standard multi-dimensional data using time series analysis combined with statistical analysis to predict the predicted performance problem after the current moment and identify performance bottleneck information; generating fault resolution instructions based on the fault risk information and the target fault, and executing the fault resolution instructions to achieve fault self-healing; generating performance optimization instructions based on the performance bottleneck information and the predicted performance problem, and executing the performance optimization instructions to perform performance optimization.

[0005] This solution standardizes and processes multi-dimensional data reflecting the overall cluster structure based on the MCP protocol specification, effectively solving integration challenges caused by inconsistent data formats and poor protocol compatibility between heterogeneous systems, thus improving data interoperability and enhancing system compatibility and scalability. By combining a fault detection model with a pre-defined knowledge graph, real-time and accurate detection and rapid root cause localization of novel and complex faults are achieved, significantly reducing reliance on human experience and improving fault response efficiency and accuracy, thereby greatly enhancing the fault response capability of the cluster system. Furthermore, by utilizing a collaborative mechanism of time-series analysis and statistical analysis, future performance issues can be proactively predicted, and system bottlenecks can be accurately identified, overcoming the limitations of traditional reliance on static thresholds. Based on this, fault self-healing instructions and performance optimization instructions are automatically generated and executed, not only realizing a shift from "passive response" to "proactive governance," but also significantly enhancing the system's automated handling capability for complex faults, achieving automated and intelligent performance optimization.

[0006] In some examples, generating fault resolution instructions based on the fault risk information and the target fault includes: generating a fault resolution strategy based on the fault risk information and the target fault; formatting the fault resolution strategy using the MCP protocol specification to obtain fault resolution instructions, thereby generating fault resolution instructions that can interact with the K8s API Server.

[0007] In some examples, if the fault resolution instruction and / or the performance optimization instruction fail to be generated, the method further includes: sending the fault risk information, the target fault, the performance bottleneck information, and the predicted performance problem to the administrator's smart device to notify the administrator to perform fault handling and performance optimization.

[0008] In some examples, after obtaining the standard multidimensional data, the method further includes: cleaning and format conversion of the standard multidimensional data to obtain new standard multidimensional data; establishing a data index for the standard multidimensional data; and storing the standard multidimensional data using distributed storage technology.

[0009] In some examples, the method also includes displaying the standard multidimensional data in the form of charts and dashboards.

[0010] In some examples, the fault detection model is obtained by training any one of the following models: support vector machine, decision tree, or neural network, based on historical fault data.

[0011] In some examples, the standard multidimensional data includes cluster component status data, application runtime data, network data, and resource usage data.

[0012] At least one embodiment of this application also provides an intelligent fault self-healing and performance optimization device based on K8s and MCP, comprising: an acquisition unit for acquiring standard multi-dimensional data, wherein the standard multi-dimensional data is a comprehensive data set that conforms to the MCP protocol specification and reflects the overall operation and performance of K8s; an identification unit for detecting and processing the standard multi-dimensional data based on a fault detection model, identifying fault risk information, and locating the target fault based on the fault risk information and a preset knowledge graph; an analysis unit for analyzing the standard multi-dimensional data using time series analysis combined with statistical analysis, predicting the predicted performance problem after the current moment, and identifying performance bottleneck information; an execution unit for generating fault resolution instructions based on the fault risk information and the target fault, and executing the fault resolution instructions to achieve fault self-healing; the execution unit is further configured to generate performance optimization instructions based on the performance bottleneck information and the predicted performance problem, and execute the performance optimization instructions to perform performance optimization.

[0013] At least one embodiment of this application also provides an electronic device, including: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the above-described intelligent fault self-healing and performance optimization method based on K8s and MCP.

[0014] At least one embodiment of this application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described intelligent fault self-healing and performance optimization method based on K8s and MCP. Attached Figure Description

[0015] One or more embodiments are illustrated by way of example with reference to the accompanying drawings, and these illustrative descriptions do not constitute a limitation on the embodiments.

[0016] Figure 1 This is a flowchart illustrating an embodiment of the intelligent fault self-healing and performance optimization method based on K8s and MCP provided in this application. Figure 2 This is a schematic diagram of the structure of an intelligent fault self-healing and performance optimization device based on K8s and MCP provided in another embodiment of this application; Figure 3 This is a schematic diagram of the structure of an electronic device provided in another embodiment of this application. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the various embodiments of this application will be described in detail below with reference to the accompanying drawings. However, those skilled in the art will understand that many technical details have been provided in the various embodiments of this application to help readers better understand this application. However, the technical solutions claimed in this application can be implemented even without these technical details and various changes and modifications based on the following embodiments. The division of the various embodiments below is for the convenience of description and should not constitute any limitation on the specific implementation of this application. The various embodiments can be combined with and referenced by each other without contradiction.

[0018] It should be noted that the acquisition or use of data in the embodiments of this application requires the user's consent. The relevant data can only be obtained after the user's authorization, and the acquisition or use of the data complies with the provisions of relevant laws and regulations.

[0019] To facilitate understanding of the embodiments of this application, the relevant content of the intelligent fault self-healing and performance optimization method based on K8s and MCP will be introduced first.

[0020] With the widespread adoption of cloud computing and containerization technologies, Kubernetes (K8s) has become the mainstream container orchestration platform, supporting the operation of large-scale, highly dynamic distributed applications. However, the complex architecture, numerous components, and tight dependencies of K8s clusters present many challenges to their operation and maintenance. Existing technologies suffer from the following prominent problems in practical applications: First, inconsistent data formats and poor communication protocol compatibility among different monitoring systems and components lead to difficulties in data interaction, high integration costs, and challenges in achieving globally unified observability. Second, when faced with new and complex fault scenarios (such as cascading failures, resource contention, and abnormal network policies), traditional methods based on single-indicator analysis suffer from detection lag and inaccurate alarms, failing to meet real-time requirements. Third, fault localization relies heavily on manual experience for log review and link analysis, resulting in low efficiency, high error rates, and difficulty in quickly identifying root causes. Furthermore, existing self-healing mechanisms are mostly limited to simple operations such as restarting Pods, lacking automated processing capabilities for complex faults and still requiring significant manual intervention. In terms of performance management, resource allocation generally relies on static thresholds, and optimization strategies lag behind actual load changes, easily leading to resource waste or performance bottlenecks. Simultaneously, performance bottleneck identification lacks accurate attribution analysis and trend prediction capabilities, making it difficult to provide effective support for capacity planning and dynamic scheduling. Therefore, it can be seen that the existing K8s operation and maintenance system has obvious shortcomings in terms of data interoperability, fault response capability, automation level and intelligent performance optimization.

[0021] To address the significant shortcomings of the existing Kubernetes (K8s) operation and maintenance system in terms of data interoperability, fault response capabilities, automation level, and intelligent performance optimization, this invention proposes an intelligent fault self-healing and performance optimization method based on K8s and MCP. The implementation details of this embodiment of the intelligent fault self-healing and performance optimization method based on K8s and MCP are described below. The following content is only for ease of understanding and is not necessary for implementing this solution.

[0022] Example 1: The intelligent fault self-healing and performance optimization method based on Kubernetes and MCP in this embodiment can be applied to electronic devices with communication, computing, and data storage capabilities. Its specific process can be as follows: Figure 1 As shown, it includes: Step 110: Obtain standard multi-dimensional data. Standard multi-dimensional data is a comprehensive data set that conforms to the MCP protocol specification and reflects the overall operation and performance of K8s.

[0023] The standard multi-dimensional data includes cluster component status data, application runtime data, network data, and resource usage data. Cluster component status data refers to the health and operational status of each core component constituting the entire cluster, used to determine the overall health and availability of the cluster. Application runtime data refers to the data generated during the operation of specific business applications deployed on the cluster, used to determine whether the corresponding specific business applications are running normally and whether there are performance bottlenecks or functional defects. Network data refers to data related to network communication within the cluster and between the cluster and external networks, used to troubleshoot network bottlenecks, network latency, or connection failures to ensure smooth inter-server communication. Resource usage data refers to the occupancy of various hardware or computing resources in the cluster, used to assess cluster load. MCP (Machine Configuration Protocol) aims to achieve standardized interaction and synchronization of configuration information between different components, facilitating data transmission and command delivery in complex systems and ensuring effective communication between parts. The MCP protocol specification is a set of standardized technical documents and rules defined for MCP, defining the format, process, interface, and behavioral guidelines that the protocol must follow when implementing configuration information interaction and synchronization. K8s refers to Kubernetes clusters, an open-source container orchestration platform used for automating the deployment, scaling, and management of containerized applications. A comprehensive data cluster refers to a unified, structured data entity formed by integrating data from multiple sources, dimensions, and types. Specifically, it's a unified data body standardized and encapsulated according to the MCP protocol specification, incorporating data from four dimensions: cluster component status, application operation, network communication, and resource usage. This comprehensive data cluster contains data that characterizes the cluster's operational status from multiple perspectives.

[0024] Specifically, based on the collection agents deployed on each Kubernetes node, the node resource usage data, node component status data, node network data, and node application log data of each node are collected in real time; the node component status data of each node is combined into cluster component status data; the node application log data of each node is combined into application running data; the node network data of each node is combined into network data; and the node resource usage data of each node is combined into resource usage data.

[0025] Node resource usage data includes CPU utilization, memory utilization, disk I / O, and other resource data. Node component status data includes the status of components running on the node, component startup time, and number of component restarts. Node network data includes the call relationships of services deployed on the node, network traffic, latency, and other data. Node application log data refers to the log data of applications deployed on the node.

[0026] Furthermore, due to the diverse data formats of the collected node resource usage data, node component status data, node network data, and node application log data, in order to improve data consistency, facilitate data transmission and processing, enhance data interaction efficiency, and improve the adaptability of the cluster and components, this method also includes: for each node, standardizing the node resource usage data, node component status data, node network data, and node application log data based on the MCP protocol specification to obtain standard node resource usage data, standard node component status data, standard node network data, and standard node application log data; combining the standard node component status data of each node into cluster component status data; combining the standard node application log data of each node into application runtime data; combining the standard node network data of each node into network data; and combining the standard node resource usage data of each node into resource usage data.

[0027] For example, each acquisition agent in the data acquisition layer collects node resource usage data, node component status data, node network data, and node application log data from each node in real time. This data is then transmitted to the MCP adaptation module in the same layer. The MCP adaptation module standardizes this data according to the MCP protocol specification, resulting in standardized node resource usage data, standardized node component status data, standardized node network data, and standardized node application log data.

[0028] In some examples, after obtaining the standard multidimensional data in step 110, the method further includes: cleaning and format conversion of the standard multidimensional data to obtain new standard multidimensional data; establishing a data index for the standard multidimensional data; and storing the standard multidimensional data using distributed storage technology.

[0029] Data cleaning refers to removing outlier, noisy, and duplicate data to ensure accuracy and integrity. For example, collected CPU usage data that significantly exceeds a reasonable range is considered an outlier and deleted. Format conversion involves transforming the data format to facilitate analysis, organization, and storage. For example, time-series data is converted into a format that can be processed by a time-series analysis model. Distributed storage technology can be either HDFS (Hadoop Distributed File System) or Elasticsearch.

[0030] Specifically, a data index is established for standard multi-dimensional data, and distributed storage technology is used to store the standard multi-dimensional data. This includes: establishing a data index for each data item in the standard multi-dimensional data based on its metadata attributes, which at least include: data source, timestamp, cluster identifier, namespace, Pod name, component type, metric category, and MCP protocol version number; persistently storing the indexed standard multi-dimensional data using distributed storage technology, such as HDFS or Elasticsearch; when using HDFS, the standard multi-dimensional data is written in columnar storage format or in the form of sharded log files, and the standard multi-dimensional data is managed collaboratively based on the HDFS NameNode indexing mechanism and the locally established data index, supporting batch processing analysis of large-scale standard multi-dimensional data; when using Elasticsearch, the standard multi-dimensional data is mapped to a document type with predefined index templates, and real-time querying and aggregation analysis of the standard multi-dimensional data is achieved by utilizing Elasticsearch's inverted index and distributed search capabilities.

[0031] For example, standard multi-dimensional data is sent to the data cleaning module of the data processing and storage layer. Upon receiving the standard multi-dimensional data, the data cleaning module cleans it to remove noise, duplicate data, and outliers, and then sends the cleaned standard multi-dimensional data to the data conversion module. The data conversion module converts the format of the cleaned standard multi-dimensional data to make it suitable for analysis and storage. The data storage module of the data processing and storage layer provides the stored standard multi-dimensional data to various modules or models in the intelligent analysis layer as needed. The intelligent analysis layer is a data analysis layer that uses artificial intelligence algorithms to segment the data stored in the data processing and storage layer, enabling fault detection, fault location, performance bottleneck identification, and performance prediction.

[0032] Therefore, by cleaning and format conversion of standard multi-dimensional data, noise, duplication, missing and invalid information in the original data are effectively removed, and the encoding format, timestamp precision and measurement units of data from different sources are unified, thereby improving the accuracy, consistency and availability of the data and generating high-quality "new standard multi-dimensional data". On this basis, a refined data index is established, and distributed storage technologies such as HDFS or Elasticsearch are combined to achieve efficient and persistent storage of data. This not only enhances the scalability and high availability of the data, but also significantly improves the write throughput and query efficiency of massive monitoring data.

[0033] Step 120: Based on the fault detection model, the standard multi-dimensional data is detected and processed to identify fault risk information, and the target fault is located based on the fault risk information and the preset knowledge graph.

[0034] The fault detection model is used to identify potential faults within the cluster. Fault risk information represents information about potential faults in the cluster, including at least risky components, abnormal indicators, and fault symptoms. The pre-defined knowledge graph is a graph-based data structure composed of nodes and edges. Nodes represent entities, and edges represent relationships between entities. In this scheme, nodes mainly include components, faults, and fault symptoms, while edges mainly include dependencies and invocation relationships between components, causal relationships between faults and fault symptoms, and attribution and influence relationships between components and faults, used to support fault propagation analysis and root cause localization. The target fault refers to the root cause of the fault indicated by the fault risk information, i.e., the fault root cause.

[0035] Specifically, the fault detection model is obtained by training any one of the following models: support vector machine, decision tree, or neural network, based on historical fault data.

[0036] Support vectors (SVMs) are a machine learning algorithm that classifies or regresses data by finding an optimal hyperplane in the feature space. In fault detection, they can be used to distinguish between normal and fault modes. Decision trees are tree-structured machine learning models that classify or predict data based on a series of judgments (such as the magnitude of feature values), and can be used in scenarios such as fault detection. Neural networks are machine learning models that mimic the connection patterns of neurons in the human brain. They consist of multiple neuron layers and can learn complex patterns in data through training. They are suitable for handling various complex nonlinear problems, such as fault detection and performance prediction.

[0037] In some examples, machine learning algorithms are trained using sample fault data to obtain fault detection models. The machine learning algorithm can be any one of support vector machines, decision trees, or neural networks. The sample fault data is historical fault data, referring to relevant data corresponding to instances where the cluster experienced faults in the past. The trained fault detection model can compare real-time collected standard multi-dimensional data with normal patterns to detect potential faults in the cluster and output fault risk information.

[0038] For example, if the number of restarts of a certain Pod suddenly increases in a short period of time in the standard multi-dimensional data, the fault detection model identifies and outputs fault risk information indicating that the Pod has a fault risk.

[0039] Specifically, locating the target fault based on fault risk information and a pre-defined knowledge graph includes: using fault risk information as query input and performing matching and reasoning processing in the pre-defined knowledge graph to obtain the target fault. Further, using fault risk information as query input and performing matching and reasoning processing in the pre-defined knowledge graph to obtain the target fault includes: locating nodes in the pre-defined knowledge graph corresponding to the risk components and fault symptoms in the fault risk information; based on the causal relationship edges of the pre-defined knowledge graph, performing reverse reasoning along the direction from the fault symptoms to the fault to identify candidate faults matching the fault symptoms; and prioritizing the candidate faults by combining path weights, selecting the candidate fault with the highest priority as the target fault.

[0040] For example, when the fault risk information indicates that service 1 is unavailable, the system analyzes the call dependencies between service 1 and other services, the running status of related Pods (such as whether they have been restarted or are ready), node resource usage (such as CPU and memory pressure), and network connectivity indicators. Combining this with the component topology and causal relationships in a pre-defined knowledge graph, the system performs correlation reasoning. This allows it to pinpoint the root cause of the fault: whether it's an anomaly in the worker node hosting the Pod of service 1 (such as node disconnection or resource exhaustion), or a failure in network communication between services (such as network policy blocking, DNS resolution failure, or excessive network latency). This achieves accurate diagnosis from symptoms to root cause.

[0041] Step 130: Using time series analysis combined with statistical analysis, analyze the standard multi-dimensional data to predict the prediction performance problems after the current moment and identify performance bottleneck information.

[0042] In time-series analysis, time-series forecasting algorithms can be used to analyze standard multi-dimensional data to predict the cluster's resource usage status over a future period after the current moment, thereby identifying performance bottlenecks. Long Short-Term Memory (LSTM) networks can be used as time-series forecasting algorithms. Predicting performance problems refers to potential performance anomalies or resource overload events that may occur in the cluster within a future period after the current moment (e.g., 5 minutes, 30 minutes, or 1 hour) that could affect the normal operation of the service. Performance bottleneck information refers to the most fundamental component on the critical path that causes overall performance limitations when predicted performance problems occur in the cluster.

[0043] Specifically, time series analysis and statistical analysis are used to analyze standard multi-dimensional data to predict potential performance problems that may occur in the cluster in the future, and to predict the performance bottleneck information that the cluster will encounter when such performance problems occur.

[0044] For example, by analyzing the changing trends of data such as CPU utilization and memory utilization in standard multi-dimensional data, it can be determined whether there is a resource shortage problem. If a resource shortage problem exists, the performance of components that are limited by insufficient resources can be further identified. By analyzing the application's response time distribution, it can be predicted that there is a problem of excessively long response time, and the components with slow response times can be further identified.

[0045] Step 140: Generate fault resolution instructions based on fault risk information and target fault, and execute the fault resolution instructions to achieve fault self-healing.

[0046] Among them, the fault resolution instruction is used to resolve the target fault and eliminate the fault risk corresponding to the fault risk information.

[0047] Specifically, step 140 above generates fault resolution instructions based on fault risk information and target fault, including: generating fault resolution strategies based on fault risk information and target fault; formatting the fault resolution strategies using the MCP protocol specification to obtain fault resolution instructions, so as to generate fault resolution instructions that can interact with the K8s API Server.

[0048] The fault resolution strategy is the approach to resolve the target fault. Fault resolution strategies may include restarting the Pod, migrating the Pod to another node, or repairing the node. For example, when a node's CPU utilization is consistently high and predicted to worsen further, a strategy is generated to migrate some Pods on that node to other nodes. The K8s API Server is the core control component and sole entry point for the Kubernetes cluster, responsible for receiving, verifying, and coordinating all operations within and outside the cluster.

[0049] Specifically, the MCP instruction conversion module can format the fault resolution strategy according to the MCP protocol specification to obtain fault resolution instructions, thereby converting the generated fault resolution strategy into fault resolution instructions that conform to the MCP protocol, making it easier for the K8s cluster to execute.

[0050] Furthermore, the MCP instruction conversion module interacts with the K8s API Server to send the obtained fault resolution instructions to the instruction execution module in K8s, so that the instruction execution module can execute the fault resolution instructions.

[0051] For example, the fault location module, combined with relevant data, determines that the fault is caused by insufficient memory on the node where Pod1 resides. Based on this result, the policy generation module generates a fault resolution policy to restart Pod1 and migrate it to a node with sufficient memory. This fault resolution policy is converted into fault resolution instructions by the MCP instruction conversion module and then sent to the K8s API Server by the instruction execution module. K8s executes the fault resolution instructions and feeds back the execution results to the instruction execution module. The instruction execution module then sends the results to the visualization module for display and to the data storage module for storage.

[0052] In addition, the instruction execution results stored in the data storage module can be used for subsequent model optimization of the fault detection model.

[0053] Step 150: Generate performance optimization instructions based on performance bottleneck information and predicted performance problems, and execute the performance optimization instructions to perform performance optimization.

[0054] Among them, the performance optimization instructions are used to solve predicted performance problems, avoid performance bottleneck problems corresponding to performance bottleneck information, and achieve performance optimization.

[0055] Specifically, step 150 above generates performance optimization instructions based on performance bottleneck information and predicted performance problems, and executes the performance optimization instructions, including: generating a performance optimization strategy based on performance bottleneck information and predicted performance problems; formatting the performance optimization strategy using the MCP protocol specification to obtain performance optimization instructions, so as to generate performance optimization instructions that can interact with the K8s APIServer.

[0056] Specifically, the MCP instruction conversion module can format the performance optimization strategy according to the MCP protocol specification to obtain performance optimization instructions, thereby converting the generated performance optimization strategy into performance optimization instructions that conform to the MCP protocol, making it easier for the K8s cluster to execute.

[0057] Furthermore, the MCP instruction conversion module interacts with the K8s API Server to send the obtained performance optimization instructions to the instruction execution module in K8s, so that the instruction execution module can execute the performance optimization instructions.

[0058] For example, the performance bottleneck identification module analyzes that insufficient CPU resources in the Pod corresponding to Service 1 are causing the increased response time. The performance prediction module predicts that if no action is taken, the response time will further increase in the future. The policy generation module generates a performance optimization policy to increase the CPU resource quota of the Pod. This performance optimization policy is converted into performance optimization instructions by the MCP instruction conversion module and then sent to the K8s API Server by the instruction execution module. K8s executes the performance optimization instructions and feeds back the execution results to the instruction execution module. The instruction execution module then sends the results to the visualization module for display and to the data storage module for storage.

[0059] In addition, the instruction execution results stored in the data storage module can be used for subsequent training or optimization of the performance bottleneck identification model, so as to identify performance bottleneck information based on the performance bottleneck identification model.

[0060] This establishes a closed-loop control process of "data acquisition - intelligent analysis - decision execution - status feedback," with each module interacting through standardized processes to form a continuously optimized closed loop. Fault handling and performance optimization results are fed back to the data storage layer as the basis for subsequent model training and strategy optimization, enabling the system to learn and evolve independently.

[0061] In some cases, if troubleshooting instructions and / or performance optimization instructions fail to be generated, the method may also include sending fault risk information, target fault, performance bottleneck information, and predicted performance problems to the administrator's smart device to notify the administrator to perform fault handling and performance optimization.

[0062] Specifically, when the fault resolution instructions and / or performance optimization instructions generated by the system do not meet the actual needs, the system can proactively notify the administrator for handling.

[0063] Alarm messages can be sent to administrators via email, SMS, instant messaging tools, etc., reminding them to pay attention and handle faults and optimize performance in a timely manner. The alarm messages include fault risk information, target fault, performance bottleneck information, and predicted performance issues.

[0064] Therefore, in addition to automated processing, a manual intervention module is reserved to allow administrators to intervene and make adjustments when necessary. This "automation-based, manual-assisted" model ensures operational efficiency while retaining flexibility to handle special scenarios, thus balancing automation and controllability.

[0065] In some examples, the approach also includes displaying standard multidimensional data in the form of charts and dashboards.

[0066] For example, this solution also provides a visual interface for users to interact with the cluster, enabling them to understand the cluster's operational status, fault handling, and performance optimization effects. This visual interface can display standard multi-dimensional data in the form of charts, dashboards, etc., allowing users to intuitively understand the cluster's status. For example, it can display resource utilization trends for each node, the distribution of Pod operational status, etc.

[0067] Therefore, by providing a visualization interface based on charts and dashboards, complex standard multi-dimensional data is presented in an intuitive and dynamic form, which significantly improves users' ability to perceive the running status of Kubernetes clusters and improves operational efficiency.

[0068] In summary, this solution acquires standard multi-dimensional data, which is a comprehensive dataset conforming to the MCP protocol specification and reflecting the overall operational status and performance of Kubernetes. Based on a fault detection model, it processes this standard multi-dimensional data to identify fault risk information and locates the target fault using this information and a pre-defined knowledge graph. Using time-series analysis combined with statistical analysis, it analyzes the standard multi-dimensional data to predict performance issues after the current moment and identify performance bottlenecks. Based on the fault risk information and the target fault, it generates and executes fault resolution instructions to achieve fault self-healing. Finally, based on performance bottleneck information and predicted performance issues, it generates and executes performance optimization instructions to optimize performance.

[0069] Based on the MCP protocol specification, standard multi-dimensional data reflecting the overall situation of the cluster is processed in a standardized manner, effectively solving the integration problems caused by inconsistent data formats and poor protocol compatibility between heterogeneous systems, improving data interoperability, and enhancing system compatibility and scalability. Specifically, the MCP protocol specification is integrated into the entire process of K8s fault self-healing and performance optimization, realizing standardized interaction from data acquisition and data analysis to decision execution. Through the MCP adaptation module, multi-source heterogeneous data is standardized to obtain standard multi-dimensional data conforming to the MCP protocol specification. Fault resolution strategies and performance optimization strategies are also standardized to obtain instructions conforming to the MCP protocol specification, effectively solving the problems of chaotic data formats and poor component communication compatibility in traditional systems, and building a highly efficient collaborative technical system. By combining a fault detection model with a pre-set knowledge graph, real-time accurate detection and rapid root cause location of new and complex faults are achieved, significantly reducing reliance on human experience, improving fault response efficiency and accuracy, and greatly enhancing the fault response capability of the cluster system. Furthermore, by leveraging a collaborative mechanism of time-series analysis and statistical analysis, future performance issues can be proactively predicted, and system bottlenecks can be accurately identified, overcoming the limitations of traditional reliance on static thresholds. Based on this, fault self-healing instructions and performance optimization instructions are automatically generated and executed, not only realizing a shift from "passive response" to "proactive governance," but also significantly enhancing the system's automated handling capabilities for complex faults, achieving automated and intelligent performance optimization.

[0070] Example 2: Another embodiment of this application relates to an intelligent fault self-healing and performance optimization device based on Kubernetes and MCP. The implementation details of this embodiment's intelligent fault self-healing and performance optimization device based on Kubernetes and MCP are described below. The following implementation details are provided for ease of understanding and are not essential for implementing this solution. A schematic diagram of the intelligent fault self-healing and performance optimization device 20 based on Kubernetes and MCP in this embodiment can be seen as follows: Figure 2 As shown, it includes an acquisition unit 201, an identification unit 202, an analysis unit 203, and an execution unit 204.

[0071] The acquisition unit 201 is used to acquire standard multi-dimensional data, which is a comprehensive data set that conforms to the MCP protocol specification and reflects the overall operation and performance of K8s.

[0072] The identification unit 202 is used to detect and process the standard multi-dimensional data based on the fault detection model, identify fault risk information, and locate the target fault based on the fault risk information and the preset knowledge graph.

[0073] The analysis unit 203 is used to analyze the standard multi-dimensional data by combining time series analysis with statistical analysis, predict the prediction performance problems after the current moment and identify performance bottleneck information.

[0074] The execution unit 204 is used to generate a fault resolution instruction based on the fault risk information and the target fault, and execute the fault resolution instruction to achieve fault self-healing.

[0075] The execution unit 204 is further configured to generate performance optimization instructions based on the performance bottleneck information and the predicted performance problem, and execute the performance optimization instructions to perform performance optimization.

[0076] In some examples, when the execution unit 204 is used to generate fault resolution instructions based on the fault risk information and the target fault, it is specifically used to: generate a fault resolution strategy based on the fault risk information and the target fault; format the fault resolution strategy using the MCP protocol specification to obtain fault resolution instructions, so as to generate fault resolution instructions that can interact with the K8s API Server.

[0077] In some examples, if the fault resolution instruction and / or the performance optimization instruction fail to be generated, the device is further configured to: send the fault risk information, the target fault, the performance bottleneck information, and the predicted performance problem to the administrator's smart device to notify the administrator to perform fault handling and performance optimization.

[0078] In some examples, after acquiring the standard multidimensional data, the acquisition unit 201 is further configured to: clean and convert the standard multidimensional data to obtain new standard multidimensional data; establish a data index for the standard multidimensional data; and store the standard multidimensional data using distributed storage technology.

[0079] In some examples, the device further includes a display unit for displaying the standard multidimensional data in the form of charts and dashboards.

[0080] In some examples, the fault detection model is obtained by training any one of the following models: support vector machine, decision tree, or neural network, based on historical fault data.

[0081] In some examples, the standard multidimensional data includes cluster component status data, application runtime data, network data, and resource usage data.

[0082] It is worth mentioning that all units involved in this embodiment are logical units. In practical applications, a logical unit can be a physical unit, a part of a physical unit, or a combination of multiple physical units. Furthermore, to highlight the innovative aspects of this application, this embodiment does not introduce units that are not closely related to solving the technical problems proposed in this application; however, this does not mean that other units are absent in this embodiment.

[0083] Example 3: Another embodiment of this application relates to an electronic device, such as... Figure 3 As shown, it includes: at least one processor 901; and a memory 902 communicatively connected to the at least one processor 901; wherein the memory 902 stores instructions executable by the at least one processor 901, the instructions being executed by the at least one processor 901 to enable the at least one processor 901 to execute the intelligent fault self-healing and performance optimization methods based on K8s and MCP in the above embodiments.

[0084] The memory and processor are connected via a bus, which can include any number of interconnecting buses and bridges, connecting various circuits of one or more processors and memories. The bus can also connect various other circuits, such as peripheral devices, voltage regulators, and power management circuits, which are well known in the art and will not be described further herein. The bus interface provides an interface between the bus and the transceiver. The transceiver can be a single element or multiple elements, such as multiple receivers and transmitters, providing a unit for communicating with various other devices over a transmission medium. Data processed by the processor is transmitted over the wireless medium via an antenna, which further receives data and transmits it to the processor.

[0085] The processor manages the bus and general processing, and also provides various functions, including timing, peripheral interfaces, voltage regulation, power management, and other control functions. Memory, on the other hand, is used to store data used by the processor during operation.

[0086] Example 4: Another embodiment of this application relates to a computer-readable storage medium storing a computer program. When executed by a processor, the computer program implements the method embodiments described above.

[0087] That is, those skilled in the art will understand that all or part of the steps in the methods of the above embodiments can be implemented by a program instructing related hardware. This program is stored in a storage medium and includes several instructions to cause a device (which may be a microcontroller, chip, etc.) or processor to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0088] Those skilled in the art will understand that the above embodiments are specific embodiments for implementing this application, and in practical applications, various changes can be made to them in form and detail without departing from the spirit and scope of this application.

Claims

1. A method for intelligent fault self-healing and performance optimization based on Kubernetes and MCP, characterized in that, include: Obtain standard multi-dimensional data, which is a comprehensive data set that conforms to the MCP protocol specification and reflects the overall operation and performance of K8s; The standard multi-dimensional data is processed based on the fault detection model to identify fault risk information, and the target fault is located based on the fault risk information and the preset knowledge graph. By combining time series analysis with statistical analysis, the standard multi-dimensional data is analyzed to predict the prediction performance problems after the current moment and identify performance bottleneck information. Based on the fault risk information and the target fault, a fault resolution instruction is generated and executed to achieve fault self-healing. Based on the performance bottleneck information and the predicted performance problems, a performance optimization instruction is generated and executed to optimize the performance.

2. The intelligent fault self-healing and performance optimization method based on Kubernetes and MCP according to claim 1, characterized in that, The step of generating fault resolution instructions based on the fault risk information and the target fault includes: Based on the fault risk information and the target fault, a fault resolution strategy is generated. The fault resolution strategy is formatted using the MCP protocol specification to obtain fault resolution instructions, which are then used to generate fault resolution instructions that can interact with the K8s API Server.

3. The intelligent fault self-healing and performance optimization method based on Kubernetes and MCP according to claim 1, characterized in that, If the fault resolution instruction and / or the performance optimization instruction fail to be generated, the method further includes: The fault risk information, the target fault, the performance bottleneck information, and the predicted performance problem are sent to the administrator's smart device to notify the administrator to handle the fault and optimize the performance.

4. The intelligent fault self-healing and performance optimization method based on K8s and MCP according to claim 1, characterized in that, After obtaining the standard multi-dimensional data, the method further includes: The standard multidimensional data is cleaned and converted to obtain new standard multidimensional data. A data index is established for the standard multidimensional data, and the standard multidimensional data is stored using distributed storage technology.

5. The intelligent fault self-healing and performance optimization method based on Kubernetes and MCP according to claim 1, characterized in that, The method further includes: The standard multidimensional data is displayed in the form of charts and dashboards.

6. The intelligent fault self-healing and performance optimization method based on Kubernetes and MCP as described in claim 1, characterized in that, The fault detection model is obtained by training any one of the following models: support vector machine, decision tree, or neural network, based on historical fault data.

7. The intelligent fault self-healing and performance optimization method based on K8s and MCP according to any one of claims 1 to 6, characterized in that, The standard multi-dimensional data includes cluster component status data, application runtime data, network data, and resource usage data.

8. A smart fault self-healing and performance optimization device based on Kubernetes and MCP, characterized in that, include: The acquisition unit is used to acquire standard multi-dimensional data, which is a comprehensive data set that conforms to the MCP protocol specification and reflects the overall operation and performance of K8s. The identification unit is used to detect and process the standard multi-dimensional data based on the fault detection model, identify fault risk information, and locate the target fault based on the fault risk information and the preset knowledge graph. The analysis unit is used to analyze the standard multi-dimensional data by combining time series analysis with statistical analysis, predict the prediction performance problems after the current moment and identify performance bottleneck information. An execution unit is configured to generate fault resolution instructions based on the fault risk information and the target fault, and execute the fault resolution instructions to achieve fault self-healing; The execution unit is further configured to generate performance optimization instructions based on the performance bottleneck information and the predicted performance problem, and execute the performance optimization instructions to perform performance optimization.

9. An electronic device, characterized in that, include: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which enables the at least one processor to perform the intelligent fault self-healing and performance optimization method based on Kubernetes and MCP as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the intelligent fault self-healing and performance optimization method based on K8s and MCP as described in any one of claims 1 to 7.

Images