Visualization method and device for kernel running state

Abstract

One or more embodiments of the invention provide a kernel running state visualization method and device. The method comprises the following steps: receiving a check request of a user for a kernel running state of a target service node in a cloud service platform; in response to the viewing request, acquiring operation data of an operation system on the target service node; wherein the operation data comprises operation data related to an execution process of a kernel mode of the operation system; determining an association relationship between operation objects contained in the operation data; and generating a visual image used for describing the association relationship, and outputting the visual image to the user.

Description

Technical Field

[0001] One or more embodiments of the present specification relate to the field of data processing, and more particularly, to a method and device for visualizing kernel running status. Background Art

[0002] As an open source operating system, Linux operating system is favored and used by more and more users. In order to better allocate and manage limited resources, Linux system divides software operation into kernel mode and user mode with different execution levels. Among them, kernel mode has a higher level, can call instructions running in the operating system kernel, and can use more resources.

[0003] When using an operating system, users will inevitably have questions and needs related to understanding the kernel running status of the operating system. To this end, users can view the kernel running status of the operating system by capturing running data related to the execution process of the kernel state of the operating system. However, due to the large amount of captured running data, the parsing process is very time-consuming and labor-intensive, and users cannot quickly obtain the kernel running status. Summary of the invention

[0004] In view of this, one or more embodiments of the present specification provide a method and device for visualizing the operating status of a kernel to solve the problems existing in the related art.

[0005] To achieve the above objectives, one or more embodiments of this specification provide the following technical solutions:

[0006] According to a first aspect of one or more embodiments of this specification, a method for visualizing a kernel running state is provided, which is applied to a client and includes:

[0007] Receive a user's request to view the kernel running status of a target service node in the cloud service platform;

[0008] In response to the viewing request, acquiring the operating data of the operating system on the target service node; wherein the operating data includes operating data related to the execution process of the kernel state of the operating system;

[0009] Determining association relationships between operation objects included in the operation data;

[0010] A visual image for describing the association relationship is generated, and the visual image is output to the user.

[0011] Optionally, the client is a cloud service using a microservice architecture deployed on a cloud service platform.

[0012] Optionally, the cloud service includes a first microservice and a second microservice deployed on the cloud service platform; wherein the first microservice is used to provide interactive services between the user and the service node in the cloud service platform; and the second microservice is used to collect operating data of the operating system on the target service node;

[0013] The receiving a user's request for viewing the kernel running status of a target service node in the cloud service platform includes:

[0014] The first microservice receives a request for viewing the kernel running status of a target service node in the cloud service platform triggered by a user on an interactive interface, and transmits the viewing request to the second microservice;

[0015] The step of obtaining, in response to the viewing request, the operating data of the operating system on the target service node comprises:

[0016] The second microservice collects running data of the operating system on the target service node in response to the viewing request.

[0017] Optionally, the cloud service further includes a third microservice deployed on the cloud service platform; the third microservice is used to filter the operation data according to the viewing request;

[0018] The first microservice transmits the viewing request to the second microservice, including:

[0019] The first microservice transmits the viewing request to the third microservice, and the third microservice screens the operating data according to the viewing request and determines whether there is operating data corresponding to the viewing request; if not, the viewing request is transmitted to the second microservice.

[0020] Optionally, the cloud service further includes a fourth microservice deployed on the cloud service platform; the fourth microservice is used to encapsulate the viewing request and the operation data into a standardized data format;

[0021] The first microservice transmits the viewing request to the third microservice, including:

[0022] The first microservice transmits the viewing request to the fourth microservice;

[0023] The fourth microservice encapsulates the viewing request into a standardized data format and transmits it to the third microservice.

[0024] Optionally, encapsulating the viewing request and the running data into a standardized data format includes:

[0025] The view request and the operation data are tagged with description information for creating a visualization image based on a supported markup language, so as to convert the view request and the operation data into a standardized data format supporting transmission between various microservices.

[0026] Optionally, the cloud service further includes a fifth microservice deployed on the cloud service platform; the fifth microservice is used to perform visual modeling on the filtered operating data according to the viewing request;

[0027] The determining of the association relationship between the operation objects included in the operation data includes:

[0028] The third microservice transmits the filtered running data to the fifth microservice;

[0029] The fifth microservice performs visual modeling on the filtered operation data according to the viewing request to obtain visual model data, wherein the visual model data includes association relationships between operation objects included in the operation data;

[0030] The step of generating a visual image for describing the association relationship and outputting the visual image to the user comprises:

[0031] The fifth microservice sends the visualization model data to the first microservice, and the first microservice performs visualization rendering on the interactive interface based on the visualization model data to generate a visualization image for describing the association relationship, and outputs the visualization image to the user.

[0032] Optionally, the visualization image includes a plurality of visualization images arranged based on execution time.

[0033] Optionally, the visualization image is a two-dimensional vector diagram with an interactive function, and the two-dimensional vector diagram includes nodes corresponding to each running object and connection relationships between the nodes determined based on association relationships between the running objects.

[0034] Optionally, the two-dimensional vector graph includes node sets corresponding to each type, which are generated according to the type of the running object, and a bipartite graph between each node set for describing the association relationship between different types of running objects.

[0035] Optionally, the cloud service supports external data sources and plug-ins corresponding to the external data sources.

[0036] According to a second aspect of one or more embodiments of this specification, a kernel running status visualization system is provided, wherein the visualization system includes multiple microservices deployed on a cloud service platform, including:

[0037] The first microservice is used to receive a user's request for visualizing the kernel running status of any target service node in the cloud service platform;

[0038] A second microservice, configured to obtain, in response to the visualization request, running data of the operating system kernel on the target service node on the target node; wherein the running data includes running data related to the execution process in the kernel state of the operating system;

[0039] A fifth microservice, used to determine the association relationship between the preset operation objects contained in the operation data;

[0040] The first microservice is further configured to generate a visualization image for describing the association relationship between the running objects, and output the visualization image to the user.

[0041] According to a third aspect of one or more embodiments of this specification, an electronic device is provided, including:

[0042] processor;

[0043] a memory for storing processor-executable instructions;

[0044] The processor implements the method as described in the first aspect by running the executable instructions.

[0045] According to a fourth aspect of one or more embodiments of the present specification, a computer-readable storage medium is provided, on which computer instructions are stored, and when the instructions are executed by a processor, the steps of the method described in the first aspect are implemented.

[0046] The embodiment of the present application obtains the operating data of the operating system on the target service node in response to the user's viewing request; determines the association relationship between the operating objects contained in the operating data, and generates a visual image for describing the association relationship between the operating objects, so that the user no longer needs to face a large amount of operating data and spend a lot of time on parsing, but can intuitively understand the operating status of the operating system kernel from the visual image, so as to facilitate the processing of anomalies and requirements of the operating system content. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] Figure 1 It is a flowchart of a method for visualizing kernel running status provided by an exemplary embodiment;

[0048] Figure 2 is a schematic diagram of a visualization image provided by an exemplary embodiment;

[0049] Figure 3is a schematic diagram of an architecture of a cloud service provided by an exemplary embodiment;

[0050] Figure 4 is a flowchart of another method for visualizing kernel running status provided by an exemplary embodiment;

[0051] Figure 5 It is a structural schematic diagram of a visualization device for kernel running status provided by an exemplary embodiment;

[0052] Figure 6 It is a structural schematic diagram of a kernel operation status visualization system provided by an exemplary embodiment;

[0053] Figure 7 It is a schematic structural diagram of an electronic device provided by an exemplary embodiment. DETAILED DESCRIPTION

[0054] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, the same numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the following exemplary embodiments do not represent all implementations consistent with one or more embodiments of this specification. Instead, they are merely examples of devices and methods consistent with some aspects of one or more embodiments of this specification as detailed in the appended claims.

[0055] It should be noted that: in other embodiments, the steps of the corresponding method are not necessarily performed in the order shown and described in this specification. In some other embodiments, the steps included in the method may be more or less than those described in this specification. In addition, a single step described in this specification may be decomposed into multiple steps for description in other embodiments; and multiple steps described in this specification may be combined into a single step for description in other embodiments.

[0056] As an open source operating system, Linux operating system is favored and used by more and more users. In order to better allocate and manage limited resources, Linux operating system divides software operation into kernel mode and user mode with different execution levels. Among them, kernel mode has a higher execution level, can call instructions running in the kernel of the operating system, and can use more resources. In the process of using the operating system, users will inevitably have problems and needs related to understanding the kernel running state of the operating system. In this regard, users can view the kernel running state of the operating system by capturing the running data related to the execution process of the kernel state of the operating system. However, due to the large amount of data captured, the parsing process is very time-consuming and labor-intensive, and users cannot quickly obtain the kernel running state.

[0057] In order to allow users to quickly understand the kernel running status of the operating system, the relevant technology adopts the flame graph technical solution, which performs drastic statistical processing on the data according to the number of function executions. The effect is acceptable in related scenarios such as performance jitter, but it is too rough in the cloud native observability scenario. Especially in the scenarios of new isolation methods and grouping methods such as containers and cgroups, flame graphs are more difficult to deal with, and users cannot intuitively obtain the required kernel running status. In addition, a technical solution combining functional data analysis (FDA) and statistical shape analysis (Shapes) can also be used, but the processing time of this technical solution is too long, and the resulting images also have problems such as mutual obscuration and cannot be used.

[0058] In view of this, this specification proposes a method for visualizing the kernel running state, by obtaining the association relationship between preset running objects from the running data on the target service node of the operating system, and then generating a visualization image for describing the association relationship between the running objects, and outputting the visualization image to the user.

[0059] During implementation, in response to a user's request to view the kernel running status of a target service node in a cloud service platform, the running data of the operating system on the target service node is obtained; wherein the running data includes running data related to the execution process in the kernel state of the operating system; the association relationship between the running objects contained in the running data is determined; a visualization image for describing the association relationship between the running objects is generated, and the visualization image is output to the user.

[0060] In the above technical scheme, by responding to the user's viewing request, the operating data of the operating system on the target service node is obtained; the association relationship between the operating objects contained in the operating data is determined, and a visual image for describing the association relationship between the operating objects is generated, so that the user no longer needs to face a large amount of operating data and spend a lot of time on parsing, but can intuitively understand the operating status of the operating system kernel from the visual image, so as to facilitate the processing of anomalies and requirements of the operating system content.

[0061] In order to enable those skilled in the art to better understand the technical solutions in the present application, the technical solutions in this specification will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application.

[0062] See also Figure 1 , Figure 1 A method for visualizing kernel running status provided by an exemplary embodiment. The execution subject of the method may be a client, and the client may be a user-oriented client that supports users to manage or debug the operating system of a service node, and the client may be a service program, for example, a cloud service deployed on a cloud service platform; wherein the cloud service platform may be a cloud native service platform.

[0063] The method for visualizing the kernel running status may include the following steps.

[0064] S110: Receive a user's request to view the kernel running status of a target service node in the cloud service platform.

[0065] When the user wants to view the kernel running status of the target service node in the cloud service platform, a request for viewing the kernel running status of the target service node in the cloud service platform may be sent to the client or input in the interactive interface of the client.

[0066] Among them, the user's viewing request may include target service node, running time, CPU, thread and other demand information; the viewing request may also include the data source type of the running data, and the data source type may be used to indicate the capture method, data capture tool or data format of the running data.

[0067] S120. In response to the viewing request, obtain the operating data of the operating system on the target service node; wherein the operating data includes operating data related to the execution process of the kernel state of the operating system.

[0068] After receiving the user's viewing request, the client can obtain the operating system's running data on the target service node according to the user's viewing request. The running data may include running data related to the kernel state execution process of the operating system.

[0069] It should be noted that the operating system may be a Linux operating system, a Unix operating system, an Android operating system, an IOS operating system, etc. For the sake of simplicity, the following embodiments are all described by taking the Linux operating system as an example.

[0070] The target service node may be a server node in kernel mode for running an operating system, for example, a physical machine or a virtual machine, etc.

[0071] There are many ways to obtain the operating system's running data. For example, the client can collect the operating system's running data from the target service node through a preset data capture tool, which can also be called capturing or hooking; or, input by the user; or, obtain from a third-party system, etc.

[0072] There are many data capture tools for capturing running data, such as extended Berkeley Packet Filter (eBPF), systemtap, and system performance optimization tools perf and ftrace that come with the Linux operating system kernel.

[0073] S130: Determine the association relationship between the operation objects included in the operation data.

[0074] After acquiring the operation data related to the execution process of the kernel state of the operating system, the client may parse the acquired operation data to determine the association relationship between the operation objects preset in the operation data.

[0075] The running object may be varied and may be adjusted according to user needs, or may be specified by a user's viewing request, for example, any combination of a processor (CPU), a CPU core, a thread, a process, a program, and the like.

[0076] It should be noted that each server node may include one or more CPUs for executing one or more programs in a concurrent or parallel manner; a CPU may include one or more CPU cores; a process is the smallest unit of resource allocation, and the execution process of a program can generate at least one process; a thread is the smallest unit of program execution, and threads can be divided into kernel-mode threads and user-mode threads; a process may include one or more threads.

[0077] After obtaining the operating system's running data on the target service node, in order to facilitate subsequent processing of the obtained running data to determine the association relationship between the running objects contained in the running data, the obtained running data can be first encapsulated to encapsulate the running data into a standardized data format. Among them, the method for encapsulating the running data can be set according to actual needs, and the running data can be marked with descriptive information for creating a visual image based on a supported markup language to convert the running data into a standardized data format. For example, the attributes, fields, data quality and other information of each data content can be annotated. Among them, the descriptive information may include descriptive information corresponding to a preset running object; for example, the running data in the standardized data format may include attribute information marked with descriptive information such as the start time of function execution, the CPU core where it is located, the execution time, and the kernel function stack position.

[0078] For example, in one implementation, the markup language may be Extensible Markup Language (XML); and the standardized data format may be an XML document.

[0079] Since there may be a large amount of erroneous or unusable running data in the acquired running data, the running data can also be filtered. There are many ways to filter the running data, such as cleaning up unnecessary data, verifying whether there is necessary data content, including necessary attributes or fields, etc.; you can also verify whether the values ​​corresponding to some data content meet constraints, etc.

[0080] The process of screening the operation data may be performed before packaging the operation data into a standardized data format, or after packaging the operation data into a standardized data format, or simultaneously, which is not specifically limited here.

[0081] Before encapsulating and / or filtering the operation data, the data source type of the acquired operation data may be determined first. Different data source types may correspond to different capture methods, different data capture tools, or different data formats of the operation data. For example, the operation data captured by using eBPF and systemtap correspond to different data source types. The data source type may be identified by a preset data source identifier corresponding to the data source type, for example, a data source ID.

[0082] The operating data for different data source types may correspond to different packaging methods and / or screening methods. The operating data may be packaged into a standardized data format using a packaging method corresponding to the data source type; or the operating data may be screened using a screening method corresponding to the data source type.

[0083] After the operation data is packaged and screened, the association relationship between the operation objects included in the operation data can be determined from the operation data based on the viewing request.

[0084] The method for determining the association relationship between operating objects can be set according to actual needs. For example, multiple operating objects contained in the same operating data can be determined as operating objects with an associated relationship; or, for any operating object, other operating objects in the operating data carrying any operating object within a preset time period are determined as operating objects with an associated relationship, and so on.

[0085] S130: Generate a visualization image for describing the association relationship between the running objects, and output the visualization image to a user.

[0086] After the preset association relationship between the running objects is obtained, a visualization image for describing the association relationship between the running objects may be generated, and the visualization image may be output to the user on an interactive interface of the client.

[0087] Wherein, step S120 and step S130 may include: performing visual modeling on the filtered operation data according to the viewing request to obtain visual model data for describing the association relationship between the operation objects; based on the visual model data, performing visual rendering on the interactive interface to generate a visual image for describing the association relationship between the operation objects, and outputting the visual image to the user on the interactive interface.

[0088] The visualization image may be expressed in various forms, for example, it may be a two-dimensional vector graphic with interactive functions, such as Scalable Vector Graphics (SVG), and the two-dimensional vector graphic may include nodes corresponding to each running object and connection relationships between the nodes determined based on the association relationship between the running objects.

[0089] The user can perform relevant operations on the visualization image through the interactive interface. The interactive interface can support the user's retrieval function for running objects, the merging or splitting function for visualization images, the viewing angle conversion function for visualization images, etc.

[0090] In order to avoid mutual obscuration due to too many nodes and connection relationships, when visual modeling is performed on the filtered operation data for the viewing request to obtain the visual model data for describing the association relationship between the operation objects, multiple visual models can be constructed based on the execution time of each operation data, and then multiple visual images arranged based on the execution time can be generated.

[0091] By generating multiple visualization images arranged based on execution time, each visualization image can be made simpler, and users can understand the changing process of the operating system kernel running state by comparing visualization images corresponding to different execution times.

[0092] There are many methods for generating a two-dimensional vector diagram for describing the association relationship between the running objects. For example, in one embodiment, the nodes corresponding to different types of running objects can be divided into different node sets and a bipartite graph can be used. The bipartite graph can also be called a bipartite graph, which is used to represent the connection relationship between nodes in two node sets, while there is no connection relationship in the same node set.

[0093] First, based on the type of the running object, node sets corresponding to different types are generated; wherein each node set includes nodes corresponding to the running objects of the same type, for example, Figure 2 As shown, a node set consisting of nodes 21 corresponding to CPU cores, a node set consisting of nodes 22 corresponding to threads, a node set consisting of nodes 23 corresponding to kernel-state threads, and a node set consisting of nodes 24 corresponding to processes can be generated; in order to be able to quickly identify nodes corresponding to different types of running objects in the output visualization image, different node colors or node shapes can be used for rendering;

[0094] Based on the association relationship between different types of running objects, a bipartite graph between each node set is generated to obtain a two-dimensional vector diagram for describing the association relationship between the running objects. For example, based on the association relationship between each CPU core and the process, the association relationship between each CPU core and the thread, and the association relationship between each thread and the program, a bipartite graph between the node set corresponding to the CPU and the node set corresponding to the process, a bipartite graph between the node set corresponding to the CPU and the node set corresponding to the thread, and a bipartite graph between the node set corresponding to the thread and the node set corresponding to the program, etc. can be generated respectively; and based on the combination of each bipartite graph, a two-dimensional vector diagram for describing the association relationship between the running objects is obtained and output to the user.

[0095] By partitioning the node set and using a bipartite graph, the resulting visualization can be made clearer and easier to read.

[0096] It can be seen from the technical solutions of the above-mentioned embodiments that the embodiments of the present application obtain the operating data of the operating system on the target service node by responding to the user's viewing request; determine the association relationship between the operating objects contained in the operating data, and generate a visual image for describing the association relationship between the operating objects, so that the user no longer needs to face a large amount of operating data and spend a lot of time on parsing, but can intuitively understand the operating status of the operating system kernel from the visual image, so as to facilitate the processing of anomalies and requirements of the operating system content.

[0097] See also Figure 3 , Figure 3 A schematic diagram of the architecture of a cloud service that can be used to execute the above-mentioned technical solution is shown. The client that executes the above-mentioned technical solution can be a cloud service deployed on a cloud service platform. The cloud service can adopt a microservice architecture. Each microservice is used to provide part of the services in the above-mentioned technical solution. The various microservices can be deployed in a distributed manner on the cloud service platform, thereby avoiding the problem of resource limitations on each microservice.

[0098] like Figure 3 As shown, the cloud service may include a first microservice 301 and a second microservice 302; wherein the first microservice 301 is used to provide interactive services between users and the service nodes in the cloud service platform; and the second microservice 302 is used to collect operating data of the operating system on the target service node.

[0099] The first microservice 301 can provide a user-oriented interactive interface. The first microservice 301 can receive a request for viewing the kernel running status of a target service node in the cloud service platform triggered by the user on the interactive interface, and transmit the viewing request to the second microservice 302.

[0100] The second microservice 302 may provide a preset data capture tool. When receiving the viewing request, if the viewing request includes a data capture request, the second microservice 302 may respond to the viewing request and collect the operating data of the operating system on the target service node through the data capture tool. The viewing request may include the target service node and the operating time and other demand information, and may also include a data capture strategy.

[0101] Furthermore, the cloud service also includes a third microservice 303 deployed on the cloud service platform; the third microservice 303 is used to filter the operation data according to the viewing request, for example, to clean up unavailable operation data, to verify whether necessary attributes and fields in the operation data exist, and whether the corresponding values ​​meet the constraints.

[0102] The first microservice 301 transmitting the viewing request to the second microservice 302 may include:

[0103] The first microservice 301 may first transmit the viewing request to the third microservice 303, and the third microservice 303 may filter the operating data according to the viewing request and determine whether there is operating data corresponding to the viewing request; if not, the viewing request may be transmitted to the second microservice 302, so that the second microservice 302 collects the operating data of the operating system on the target service node in response to the viewing request.

[0104] Furthermore, the cloud service also includes a fourth microservice 304 deployed on the cloud service platform; the fourth microservice 304 is used to encapsulate the viewing request and the operation data into a standardized data format.

[0105] After receiving a request for viewing the kernel running status of a target service node in the cloud service platform triggered by a user on the interactive interface, the first microservice 301 may first transmit the viewing request to the fourth microservice 304;

[0106] The fourth microservice 304 encapsulates the viewing request into a standardized data format and transmits it to the third microservice 303;

[0107] The third microservice 303 screens the operating data and determines whether there is operating data corresponding to the viewing request; if not, the viewing request may be transmitted to the second microservice 302, so that the second microservice 302 collects the operating data of the operating system on the target service node in response to the viewing request;

[0108] The second microservice 302 may first send the collected operation data to the fourth microservice 304;

[0109] The fourth microservice 304 encapsulates the collected operation data into a standardized data format, and then transmits the data to the third microservice 303 , so that the third microservice 303 can filter the operation data.

[0110] The fourth microservice 304 encapsulates the viewing request and the running data into a standardized data format, including: marking the viewing request and the running data with descriptive information for creating a visualization image based on a supported markup language, so as to convert the viewing request and the running data into a standardized data format that supports transmission between various microservices.

[0111] The markup language may be XML language; the standardized data format may be an XML document.

[0112] Furthermore, the cloud service further includes a fifth microservice 305 deployed on the cloud service platform; the fifth microservice 305 is used to perform visual modeling on the filtered operating data according to the viewing request;

[0113] After filtering the operation data, the third microservice 303 may transmit the filtered operation data to the fifth microservice 305;

[0114] The fifth microservice 305 performs visual modeling on the filtered operation data according to the viewing request to obtain visual model data, wherein the visual model data includes association relationships between operation objects included in the operation data;

[0115] The fifth microservice 305 sends the visualization model data to the first microservice 301 , and the first microservice 301 performs visualization rendering on the interactive interface based on the visualization model data to generate a visualization image for describing the association relationship, and outputs the visualization image to the user.

[0116] Further, the visualization image may include a plurality of visualization images arranged based on execution time.

[0117] Furthermore, the visualization image is a two-dimensional vector diagram with an interactive function, and the two-dimensional vector diagram includes nodes corresponding to each running object and connection relationships between the nodes determined based on association relationships between the running objects.

[0118] The interactive interface provided by the first microservice 301 may also support the user's retrieval function for running objects, the merging or splitting function for visualization images, the perspective conversion function for visualization images, and the like.

[0119] Furthermore, the two-dimensional vector map includes node sets corresponding to each type, which are generated according to the type of the running object, and a bipartite graph between each node set for describing the association relationship between different types of running objects.

[0120] It should be noted that the cloud service supports external data sources and plug-ins corresponding to the external data sources. The acquired operation data may be operation data provided by the external data source, specifically input by the user through the first microservice 301, or may be acquired from a third-party system, and so on.

[0121] After obtaining the operating data provided by the external data source, the fourth microservice 304 needs to encapsulate the operating data provided by the external data source into a standardized data format, and then send it to the third microservice 303 for screening. Since the data source type of the operating data provided by the external data source may be different, when obtaining the operating data provided by the external data source, it is also necessary to obtain the data source type of the operating data. The fourth microservice 304 can encapsulate the operating data into a standardized data format using a packaging method corresponding to the data source type; the third microservice 303 can use a screening method corresponding to the data source type to screen the operating data. The packaging method and screening method corresponding to different data source types can be achieved by loading a plug-in corresponding to the external data source. The fourth microservice 304 can send information about the data source type to other modules and instruct to use the corresponding processing method or the corresponding plug-in.

[0122] It should be noted that the fourth microservice 304 can provide an interface for obtaining operating data of an external data source and a plug-in corresponding to the external data source, thereby providing extended functions for the cloud service.

[0123] It should be noted that the first microservice 301 receives a request for viewing the kernel running status of the target service node in the cloud service platform triggered by the user on the interactive interface, which may include a user request for any one of data capture, packaging, screening, modeling, and generation of visualization images performed by the above-mentioned microservices.

[0124] See also Figure 4 , Figure 4 Shows a method based on Figure 3 A flowchart of a method for visualizing the kernel operating status of a cloud service architecture is shown, and the method may include the following steps.

[0125] S401, the first microservice obtains a user's viewing request through an interactive interface, and sends the viewing request to a fourth microservice;

[0126] S402: The fourth microservice encapsulates the viewing request into a request message based on XML format, and sends it to the third microservice and the fifth microservice;

[0127] S403, the third microservice determines whether the operation data required by the request message already exists according to the received request message in XML format, that is, whether it is necessary to capture new operation data;

[0128] S404. If the required operation data already exists, the third microservice may filter the existing operation data based on the user's viewing request, and send the filtered operation data to the fifth microservice to execute step S409; the existing operation data may be operation data in XML format that has been encapsulated by the fourth microservice;

[0129] S405: If the required operation data does not exist, the third microservice may send a data capture request to the second microservice based on the user's viewing request, and the data capture request may include information such as the target service node and the operation time;

[0130] S406: The second microservice may collect operation data from the target service node based on the data capture request, and send the collected operation data to the fourth microservice;

[0131] S407: The fourth microservice encapsulates the operation data to obtain the operation data in XML format, and sends it to the third microservice;

[0132] S408: The third microservice filters the operation data in XML format based on the received viewing request, and sends the filtered operation data in XML format to the fifth microservice;

[0133] S409: The fifth microservice constructs a file of the visualization model data that meets the viewing request based on the received filtered operation data in XML format, and sends it to the first microservice;

[0134] S410: The first microservice generates a visualization image for describing the association relationship between the running objects based on the received visualization model data file, and outputs the visualization image in an interactive interface.

[0135] It should be noted that if an error occurs during the above execution process, the first microservice may output corresponding error information on the interactive interface.

[0136] It should be noted that after the fifth microservice generates the visualization model data, it can also verify whether the visualization model meets the user's needs based on a preset verification method. For example, the visualization model data can be scored based on a preset scoring method, and whether the visualization model data meets the user's needs can be determined based on a scoring threshold. The user's needs can be included in the request information based on the XML format.

[0137] Corresponding to the above-mentioned embodiment of the method for visualizing the kernel running state, the present application also provides an embodiment of the device for visualizing the kernel running state.

[0138] like Figure 5As shown, the visualization device for the kernel running status includes: a request acquisition module 501 , a data acquisition module 502 , a data analysis module 503 and a visualization module 504 .

[0139] The request acquisition module 501 is used to receive a user's request for visualizing the kernel running status of any target service node in the cloud service platform;

[0140] The data acquisition module 502 is used to obtain the running data of the operating system kernel on the target service node on the target node in response to the visualization viewing request; wherein the running data includes running data related to the execution process in the kernel state of the operating system;

[0141] The data analysis module 503 is used to obtain the association relationship between the preset operation objects based on the determined operation data;

[0142] The visualization module 504 is used to generate a visualization image for describing the association relationship between the running objects, and output the visualization image to the user.

[0143] The embodiments of the present application can enable users to no longer face large amounts of operating data and spend a lot of time analyzing them, but can intuitively understand the operating status of the operating system kernel from the visual image, so as to facilitate the processing of anomalies and requirements of the operating system content.

[0144] Corresponding to the above-mentioned embodiment of the method for visualizing the kernel running state, the present application also provides an embodiment of the device for visualizing the kernel running state.

[0145] like Figure 6 As shown, the visualization system includes multiple microservices deployed on the cloud service platform, including:

[0146] The first microservice 601 is used to receive a user's request for visualizing the kernel running status of any target service node in the cloud service platform;

[0147] The second microservice 602 is used to obtain the running data of the operating system kernel on the target service node on the target node in response to the visualization viewing request; wherein the running data includes running data related to the execution process in the kernel state of the operating system;

[0148] A fifth microservice 603 is used to determine the association relationship between the preset operation objects contained in the operation data;

[0149] The first microservice 601 is further configured to generate a visualization image for describing the association relationship between the running objects, and output the visualization image to the user.

[0150] Optionally, the visualization system includes a cloud service distributedly deployed on the cloud service platform.

[0151] It should be noted that the visualization system may include: Figure 3 The various microservices shown in the figure and execute the above Figure 3 The methods of each microservice in the above method can achieve the same or similar technical effects, and the repeated parts will not be repeated here.

[0152] The embodiments of the present application can enable users to no longer face large amounts of operating data and spend a lot of time analyzing them, but can intuitively understand the operating status of the operating system kernel from the visual image, so as to facilitate the processing of anomalies and requirements of the operating system content.

[0153] Figure 7 is a schematic structural diagram of a device provided by an exemplary embodiment. Figure 7 At the hardware level, the device includes a processor 702, an internal bus 704, a network interface 706, a memory 708, and a non-volatile memory 710, and may also include other required hardware. One or more embodiments of this specification may be implemented based on software, such as the processor 702 reading the corresponding computer program from the non-volatile memory 710 into the memory 708 and then running it. Of course, in addition to the software implementation, one or more embodiments of this specification do not exclude other implementations, such as logic devices or a combination of software and hardware, etc., that is, the execution subject of the following processing flow is not limited to each logic unit, but may also be hardware or logic devices.

[0154] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer, which may be in the form of a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email transceiver, a game console, a tablet computer, a wearable device or a combination of any of these devices.

[0155] In a typical configuration, a computer includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0156] The memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. The memory is an example of a computer-readable medium.

[0157] Computer-readable media include permanent and non-permanent, removable and non-removable media that can be used to store information by any method or technology. Information can be computer-readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, disk storage, quantum memory, graphene-based storage media or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include temporary computer-readable media (transitory media), such as modulated data signals and carrier waves.

[0158] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and provide corresponding operation entrances for users to choose to authorize or refuse.

[0159] It should also be noted that the terms "include", "comprises" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of more restrictions, the elements defined by the sentence "comprises a ..." do not exclude the existence of other identical elements in the process, method, commodity or device including the elements.

[0160] The above is a description of a specific embodiment of the specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0161] The terms used in one or more embodiments of this specification are only for the purpose of describing specific embodiments, and are not intended to limit one or more embodiments of this specification. The singular forms of "a", "said" and "the" used in one or more embodiments of this specification and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and / or" used herein refers to and includes any or all possible combinations of one or more associated listed items.

[0162] It should be understood that although the terms first, second, third, etc. may be used to describe various information in one or more embodiments of this specification, these information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of one or more embodiments of this specification, the first information may also be referred to as the second information, and similarly, the second information may also be referred to as the first information. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".

[0163] The above description is merely a preferred embodiment of one or more embodiments of the present specification and is not intended to limit one or more embodiments of the present specification. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of one or more embodiments of the present specification shall be included in the scope of protection of one or more embodiments of the present specification.

Claims

1. A method for visualizing kernel operation status, characterized in that: Applied to the client, including: Receive a user's request to view the kernel running status of a target service node in the cloud service platform; In response to the viewing request, acquiring the operating data of the operating system on the target service node; wherein the operating data includes operating data related to the execution process of the kernel state of the operating system; Determining association relationships between operation objects included in the operation data; A visual image for describing the association relationship is generated, and the visual image is output to the user.

2. The method according to claim 1, characterized in that The client is a cloud service using a microservice architecture deployed on a cloud service platform.

3. The method according to claim 2, characterized in that The cloud service includes a first microservice and a second microservice deployed on the cloud service platform; wherein the first microservice is used to provide interactive services between the service node in the cloud service platform for users; and the second microservice is used to collect operating data of the operating system on the target service node; The receiving a user's request for viewing the kernel running status of a target service node in the cloud service platform includes: The first microservice receives a request for viewing the kernel running status of a target service node in the cloud service platform triggered by a user on an interactive interface, and transmits the viewing request to the second microservice; The step of obtaining, in response to the viewing request, the operating data of the operating system on the target service node comprises: The second microservice collects running data of the operating system on the target service node in response to the viewing request.

4. The method according to claim 3, characterized in that The cloud service also includes a third microservice deployed on the cloud service platform; The third microservice is used to filter the operation data according to the viewing request; The first microservice transmits the viewing request to the second microservice, including: The first microservice transmits the viewing request to the third microservice, and the third microservice screens the operation data according to the viewing request and determines whether there is operation data corresponding to the viewing request; If not present, the view request is transmitted to the second microservice.

5. The method according to claim 4, characterized in that The cloud service further includes a fourth microservice deployed on the cloud service platform; the fourth microservice is used to encapsulate the viewing request and the operation data into a standardized data format; The first microservice transmits the viewing request to the third microservice, including: The first microservice transmits the viewing request to the fourth microservice; The fourth microservice encapsulates the viewing request into a standardized data format and transmits it to the third microservice.

6. The method according to claim 5, characterized in that Encapsulating the viewing request and the running data into a standardized data format includes: The view request and the operation data are tagged with description information for creating a visualization image based on a supported markup language, so as to convert the view request and the operation data into a standardized data format supporting transmission between various microservices.

7. The method according to claim 5, characterized in that The cloud service further includes a fifth microservice deployed on the cloud service platform; the fifth microservice is used to perform visual modeling on the filtered operating data according to the viewing request; The determining of the association relationship between the operation objects included in the operation data includes: The third microservice transmits the filtered running data to the fifth microservice; The fifth microservice performs visual modeling on the filtered operation data according to the viewing request to obtain visual model data, wherein the visual model data includes association relationships between operation objects included in the operation data; The step of generating a visual image for describing the association relationship and outputting the visual image to the user comprises: The fifth microservice sends the visualization model data to the first microservice, and the first microservice performs visualization rendering on the interactive interface based on the visualization model data to generate a visualization image for describing the association relationship, and outputs the visualization image to the user.

8. The method according to claim 7, characterized in that The visualization image includes a plurality of visualization images arranged based on execution time.

9. The method according to claim 8, characterized in that The visualization image is a two-dimensional vector diagram with an interactive function, and the two-dimensional vector diagram includes nodes corresponding to each running object and connection relationships between the nodes determined based on the association relationship between the running objects.

10. The method according to claim 9, characterized in that The two-dimensional vector graph includes node sets corresponding to each type, which are generated according to the type of the running object, and a bipartite graph between each node set for describing the association relationship between different types of running objects.

11. The method according to claim 1, characterized in that: The cloud service supports external data sources and plug-ins corresponding to the external data sources.

12. A kernel operation status visualization system, characterized in that: The visualization system includes multiple microservices deployed on a cloud service platform, including: The first microservice is used to receive a user's request for visualizing the kernel running status of any target service node in the cloud service platform; A second microservice, configured to obtain, in response to the visualization request, running data of the operating system kernel on the target service node on the target node; wherein the running data includes running data related to the execution process in the kernel state of the operating system; A fifth microservice, used to determine the association relationship between the preset operation objects contained in the operation data; The first microservice is further configured to generate a visualization image for describing the association relationship between the running objects, and output the visualization image to the user.

13. An electronic device, characterized in that: include: processor; a memory for storing processor-executable instructions; The processor implements the method according to any one of claims 1 to 11 by running the executable instructions.

14. A computer-readable storage medium, characterized in that: Computer instructions are stored thereon, and when the instructions are executed by a processor, the steps of the method according to any one of claims 1 to 11 are implemented.

Images