Configuration management visual graph modeling method and readable storage medium

Abstract

The invention discloses a configuration management visual graph modeling method and a readable storage medium, and the method comprises the steps: firstly, a user creates configuration item nodes through a graphical modeling engine and defines a relationship, a rule engine converts the relationship into executable logic, relational data is stored in a graph database, and the relational data is stored in the graph database; static attribute data is stored in a relational database to generate an initial view model. When a user modifies the initial view model configuration item, data synchronization is completed based on the API service, visual management and real-time monitoring of the configuration item are achieved, and the operation and maintenance efficiency and the system stability are improved.

Description

Technical Field

[0001] The present invention relates to the field of data processing, and in particular to a configuration management visualization graphic modeling method and a readable storage medium. Background Art

[0002] In the configuration management of complex systems, traditional methods often have problems such as low modeling efficiency, poor operation and maintenance management experience, lack of automation and intelligence. The relationship between configuration items is complex, difficult to intuitively manage and monitor in real time, resulting in low operation and maintenance efficiency and difficulty in ensuring system stability. Existing configuration management methods have deficiencies in data integration, graphical representation, dynamic updates, etc., and cannot meet the increasingly complex system configuration management needs. An efficient, dynamic and visual configuration management method is urgently needed. Summary of the invention

[0003] The object of the present invention is to provide a configuration management visualization graphic modeling method and a readable storage medium.

[0004] In a first aspect, an embodiment of the present invention provides a configuration management visualization graphic modeling method, which is applied to a configuration management visualization graphic modeling system, wherein the configuration management visualization graphic modeling system includes a presentation layer, a service layer, and a data layer, wherein the presentation layer includes a graphical modeling engine, the service layer includes a rule engine and an API service, and the data layer includes a graph database and a relational database, wherein the method includes: In response to a user creating a configuration item node on a graphical interface through the graphical modeling engine, and defining a relationship between configuration items through the graphical interface; Calling the rule engine to convert the relationship into executable logic, storing the relationship data between the configuration items in the graph database, storing the static attribute data of the configuration items in the relational database, and generating an initial view model; In response to a user modifying a configuration item of the initial view model through the graphical interface, data synchronization is completed based on the API service.

[0005] In a second aspect, an embodiment of the present invention provides a configuration management visualization graphic modeling device, which is applied to a configuration management visualization graphic modeling system, wherein the configuration management visualization graphic modeling system includes a presentation layer, a service layer, and a data layer, wherein the presentation layer includes a graphical modeling engine, the service layer includes a rule engine and an API service, and the data layer includes a graph database and a relational database, wherein the method includes: A modeling module, for responding to a user creating a configuration item node on a graphical interface through the graphical modeling engine, and defining the relationship between configuration items through the graphical interface; calling the rule engine to convert the relationship into executable logic, and storing the relationship data between configuration items in the graph database, storing the static attribute data of the configuration items in the relational database, and generating an initial view model; for responding to a user modifying the configuration item of the initial view model through the graphical interface, and completing data synchronization based on the API service.

[0006] In a third aspect, an embodiment of the present invention provides a computer device, comprising a processor and a non-volatile memory storing computer instructions, wherein when the computer instructions are executed by the processor, the computer device executes the method described in the first aspect.

[0007] In a fourth aspect, an embodiment of the present invention provides a readable storage medium, wherein the readable storage medium includes a computer program, and when the computer program is executed, the computer device where the readable storage medium is located is controlled to execute the method described in the first aspect.

[0008] Compared with the prior art, the beneficial effects provided by the present invention include: using a configuration management visualization graphical modeling method and a readable storage medium disclosed by the present invention, the user creates configuration item nodes and defines relationships through a graphical modeling engine, the rule engine converts the relationships into executable logic, the relationship data is stored in a graph database, and the static attribute data is stored in a relational database to generate an initial view model. When the user modifies the configuration item of the initial view model, data synchronization is completed based on the API service, intuitive management and real-time monitoring of the configuration item are achieved, and operation and maintenance efficiency and system stability are improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings required for use in the embodiments are briefly introduced below. It should be understood that the following drawings only illustrate certain embodiments of the present invention and should not be regarded as limiting the scope. For those of ordinary skill in the art, other related drawings can also be obtained based on these drawings without creative work.

[0010] Figure 1 A schematic diagram of the steps of the configuration management visualization graphical modeling method provided by an embodiment of the present invention; Figure 2 A schematic diagram of a configuration management visualization graphical modeling system architecture provided by an embodiment of the present invention; Figure 3 A schematic diagram of the structure of a configuration management visualization graphic modeling device provided by an embodiment of the present invention; Figure 4A schematic block diagram of the structure of a computer device provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0011] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Generally, the components of the embodiments of the present invention described and shown in the drawings here can be arranged and designed in various different configurations.

[0012] The specific implementation modes of the present invention are described in detail below in conjunction with the accompanying drawings.

[0013] In order to solve the technical problems in the aforementioned background technology, Figure 1 A flow chart of a configuration management visualization graphical modeling method provided in an embodiment of the present disclosure is provided. The method is applied to a configuration management visualization graphical modeling system. The configuration management visualization graphical modeling system includes a presentation layer, a service layer, and a data layer. The presentation layer includes a graphical modeling engine, the service layer includes a rule engine and an API service, and the data layer includes a graph database and a relational database. The configuration management visualization graphical modeling method is introduced in detail below.

[0014] Step S201, in response to a user creating a configuration item node on a graphical interface through the graphical modeling engine, and defining a relationship between configuration items through the graphical interface; Step S202, calling the rule engine to convert the relationship into executable logic, storing the relationship data between the configuration items in the graph database, storing the static attribute data of the configuration items in the relational database, and generating an initial view model; Step S203, in response to the user modifying the configuration item of the initial view model through the graphical interface, completing data synchronization based on the API service.

[0015] In the embodiment of the present invention, for example, in a data center of a large enterprise, the operation and maintenance team needs to perform configuration management on the server cluster. The operation and maintenance personnel open the front-end interface of the configuration management visualization graphical modeling system, which is supported by the graphical modeling engine of the presentation layer. It is assumed that they use a web-based interface to access the system through a browser.

[0016] The operation and maintenance personnel must first create server-related configuration item nodes. On the graphical interface, they can see various tools and options. For example, there is a "Create Node" button. After clicking it, a dialog box pops up with templates for different types of configuration items to choose from, such as server hardware configuration items, server software configuration items, etc. The operation and maintenance personnel select the "Server Hardware Configuration Item" template based on the actual situation.

[0017] Next, they began to fill in specific server hardware information, such as setting the server name to "Server01", the server model to "Dell PowerEdge R740", the number of CPU cores to "32 cores", and the memory capacity to "128GB". This information is the static attributes of the configuration item. After filling in the information, click the "OK" button, and a node representing the "Server01" server hardware configuration item will appear on the graphical interface.

[0018] Then, the operation and maintenance personnel need to define the relationship between the configuration items. Assuming that the server also has a specific operating system software installed, they need to create a "Server Software Configuration Item" node and set the name to "CentOS 7.9". After the creation is completed, the operation and maintenance personnel use the connection tool on the graphical interface to drag a line from the "Server01" hardware configuration item node to the "CentOS 7.9" software configuration item node, and select the relationship type as "Running" in the pop-up relationship definition dialog box, indicating that the "CentOS 7.9" operating system is running on the "Server01" server.

[0019] In this way, the operation and maintenance personnel successfully created the configuration item nodes on the graphical interface through the graphical modeling engine and defined the relationship between them. This visual operation method makes the complex configuration relationship intuitive and easy to understand, greatly reducing the difficulty of operation for the operation and maintenance personnel.

[0020] When the operation and maintenance personnel complete the creation of configuration item nodes and the definition of relationships on the graphical interface, the service layer on the server side will receive this information. The rule engine in the service layer will be called to process the relationships between these configuration items.

[0021] The rule engine (assuming Drools is used) will first parse the defined relationship. For example, for the "Running" relationship between "Server01" and "CentOS 7.9", the rule engine will convert it into executable logic according to the predefined rules. For example, the rule engine may generate such logic: when the status of the server hardware configuration item is "Normal" and the version of the corresponding software configuration item meets the requirements, the running status of the entire server system is marked as "Normal".

[0022] Next, the server will store the relationship data between the configuration items in a graph database (assuming it is Neo4j). In this example, the "Running" relationship between "Server01" and "CentOS 7.9" will be stored as an edge in the graph database, and the nodes "Server01" and "CentOS 7.9" represent the vertices in the graph database. With Neo4j's powerful graph data storage and query capabilities, these complex configuration relationships can be efficiently managed and retrieved.

[0023] At the same time, the static attribute data of the configuration item, such as the name, model, number of CPU cores, memory capacity, etc. of "Server01", will be stored in a relational database (assuming it is MySQL). In MySQL, there may be a table named "server_hardware_config", in which the columns correspond to the various attributes of the server hardware configuration items, and a row of data represents the static attribute information of a specific server hardware configuration item.

[0024] After the data is stored, the server will generate an initial view model based on the stored data. This initial view model will be presented to the operation and maintenance personnel in a visual way on the front-end graphical interface. For example, on the graphical interface, the nodes of "Server01" and "CentOS 7.9" will be displayed with specific icons and colors, and the "running" relationship line between them will also have corresponding logos and styles, so that the operation and maintenance personnel can clearly see the configuration and relationship of the server.

[0025] During the operation of the server cluster, due to changes in business requirements or upgrades to hardware equipment, the operation and maintenance personnel may need to modify the configuration items in the initial view model.

[0026] Assume that in order to improve the performance of the "Server01" server, the enterprise upgrades its hardware and increases the memory capacity from the original "128GB" to "256GB". The operation and maintenance personnel find the node representing the hardware configuration item of the "Server01" server on the graphical interface, double-click the node, and the property editing dialog box pops up. In the dialog box, change the value of the memory capacity to "256GB" and then click the "Save" button.

[0027] At this point, the front-end graphical interface will immediately perceive the modification operation and send the modification request to the service layer on the server side through the RESTful API. After receiving the request, the API service of the service layer will perform a series of data synchronization operations.

[0028] First, the API service will update the modified static attribute data (i.e., memory capacity is "256GB") to the corresponding "server_hardware_config" table in the relational database (MySQL) through the database interface. MySQL will find the record of "Server01" based on the primary key (which may be the unique identifier of the server) and update the value of the memory capacity field to "256GB".

[0029] At the same time, the API service will also check whether the modification of the configuration item affects the relationship between the configuration items. In this example, the increase in memory capacity may not directly affect the "Running" relationship between "Server01" and "CentOS 7.9". However, if there are other relationship rules based on server hardware resources (for example, when the memory capacity reaches a certain threshold, the relationship with certain application configuration items will change), the rule engine will be triggered to re-evaluate these relationships.

[0030] If the relationship changes, the rule engine will update the relationship data between the configuration items and store the updated relationship data in the graph database (Neo4j). For example, if the new memory capacity meets the operating requirements of an application, the rule engine may automatically establish a new relationship between "Server01" and the configuration item of the application and store this new relationship as an edge in Neo4j.

[0031] After completing the data update, the server will return the latest data to the front-end graphical interface through the API interface. The front-end graphical interface will refresh the initial view model in real time based on the returned data, so that the operation and maintenance personnel can see that the memory capacity of the "Server01" server has been updated to "256GB", and if there is a new relationship established, it will also be displayed on the graphical interface with new connections and logos.

[0032] This API service-based data synchronization mechanism ensures that the user's modification operations on configuration items in the graphical interface can be reflected in the back-end database in a timely and accurate manner. It also ensures the consistency between the front-end view model and the back-end data, providing operation and maintenance personnel with a real-time and accurate configuration management visualization interface, which helps them to perform server cluster operation and maintenance management more efficiently.

[0033] In the embodiments of the present invention, the following implementation modes are also provided.

[0034] Automatically discover and collect configuration data of hardware, software and virtual resources through API interface, Agent program or network scanning tool to dynamically obtain all configuration items and their relationship data.

[0035] In the embodiment of the present invention, for example, in an enterprise-level data center, there are multiple servers responsible for different business applications. In order to achieve efficient configuration management of these servers, the server-side configuration management visualization graphical modeling system will use the API interface to automatically discover and collect configuration data of hardware, software and virtual resources.

[0036] Take a server running a critical business application as an example. The server is installed with a variety of hardware devices, such as a high-performance CPU, a large-capacity memory, and multiple disk arrays. It also runs an operating system, a database management system, and various middleware software. In order to obtain the configuration data of these hardware and software, the configuration management system interacts with the API interfaces provided by various management software or system services on the server.

[0037] For the collection of hardware configuration data, the server's hardware management system usually provides the corresponding API. The configuration management system will regularly send requests to the API interface of the hardware management system to obtain detailed information about the hardware. For example, by calling the API interface, the configuration management system can obtain information such as the server's CPU model, number of cores, main frequency, total memory capacity, number of slots, memory frequency, and the number of disks, capacity, and RAID level of the disk array. This information will be returned to the configuration management system in a structured data format, and the system will parse it and store it in the corresponding database.

[0038] The collection of software configuration data can also be achieved through API interfaces. For example, the operating system running on the server will provide system management APIs. The configuration management system can obtain information such as the operating system version number, installation date, and kernel version by calling these APIs. For the database management system, it will also provide APIs for querying and managing database configurations. The configuration management system can use these APIs to obtain configuration data such as the database instance name, port number, storage path, and database size.

[0039] In addition, the configuration data collection of virtual resources can also be completed with the help of API interfaces. For example, there may be multiple virtual machines running on a server, and the virtual machine management software will provide APIs for querying the configuration information of virtual machines. By calling these APIs, the configuration management system can obtain information such as the name, memory allocation, CPU core allocation, disk size, and network configuration of each virtual machine.

[0040] By automatically discovering and collecting configuration data through the API interface, the server-side configuration management system can obtain the configuration information of the server's hardware, software and virtual resources in real time and accurately, providing basic data support for subsequent configuration item relationship analysis and visual modeling.

[0041] In another scenario, some servers in the enterprise's data center are distributed in different geographical locations, and some servers cannot directly collect configuration data through the API interface due to security policies or network restrictions. In this case, the configuration management visual graphical modeling system will use the Agent program to automatically discover and collect configuration data.

[0042] The Agent program is a small software agent that is installed on each server that needs to collect configuration data. Taking one of the remote servers as an example, the operation and maintenance personnel will first deploy the Agent program to the server and perform corresponding configurations so that it can communicate with the server of the configuration management system.

[0043] After the Agent program runs on the server, it will actively collect the configuration data of the server's hardware, software, and virtual resources. For the collection of hardware information, the Agent program will directly interact with the server's hardware devices. For example, it can obtain detailed hardware specifications by reading the server's BIOS information, including the motherboard model, BIOS version, serial number of the hardware device, etc. For the collection of software configuration data, the Agent program will scan the software installed on the server and obtain information such as the software name, version number, and installation path.

[0044] For the configuration data collection of virtual resources, the Agent program will communicate with the virtualization management software on the server. For example, when the KVM virtualization platform is running on the server, the Agent program will interact with the KVM management tool to obtain the configuration information of the virtual machine, such as the name of the virtual machine, IP address, memory usage, disk I / O, etc.

[0045] After collecting the configuration data, the Agent program will encapsulate the data in a certain format and send the data to the server of the configuration management system through an encrypted communication protocol. After receiving the data, the server will verify and parse the data and then store it in the corresponding database.

[0046] The Agent program automatically discovers and collects configuration data. Even if the server cannot directly collect data through the API interface, the configuration management system can obtain accurate configuration information, ensuring the integrity and real-time nature of the configuration data.

[0047] In the enterprise network environment, there may be some unknown devices or newly added servers, and their configuration data needs to be discovered and collected in a timely manner. At this time, the configuration management visualization graphic modeling system will use network scanning tools to achieve this function.

[0048] The network scanning tool will run periodically on the server side to scan the entire network. Taking a scanning process as an example, the network scanning tool will send detection packets to all IP addresses in the network to determine which devices corresponding to the IP addresses are active. When active devices are found, the network scanning tool will further perform port scanning on these devices to determine the open ports and services on the devices.

[0049] For the scanned servers, the network scanning tool will try to obtain the server's configuration data through specific protocols and ports. For example, for servers that support SNMP (Simple Network Management Protocol), the network scanning tool will send query requests to the server's SNMP port to obtain the server's hardware and software configuration information. Through the SNMP protocol, the network scanning tool can obtain real-time information such as the server's CPU utilization, memory usage, network traffic, and basic configuration information such as the server's hardware model and operating system version.

[0050] In addition to the SNMP protocol, network scanning tools can also use other protocols and technologies to collect configuration data. For example, for servers that support the SSH or Telnet protocol, network scanning tools can establish a remote connection, log in to the server and execute specific commands to obtain configuration data. For example, by executing system commands, you can obtain the server's hardware information, software installation list, etc.

[0051] After collecting the configuration data, the network scanning tool will send the data to the server of the configuration management system. The server will organize and analyze the data, extract useful configuration information, and store it in the database. At the same time, the server will automatically identify newly added servers or devices based on the collected configuration data and include them in the management scope of the configuration management system.

[0052] By automatically discovering and collecting configuration data through network scanning tools, the configuration management system can promptly discover new devices and servers in the network and obtain their configuration information, providing strong support for the enterprise's network management and configuration management.

[0053] In the embodiment of the present invention, storing the relationship data between the configuration items in the graph database may be implemented through the following examples.

[0054] The Neo4j graph database is used to store the configuration model and the relationship data, and the Cypher query language is used to realize the retrieval and dynamic update of large-scale configuration relationships; the configuration model is the relationship between pre-stored configuration items.

[0055] In the embodiment of the present invention, for example, in a data center of a large financial enterprise, a server cluster is responsible for the storage, processing and transaction of massive data. In order to achieve refined configuration management of these servers, the configuration management visualization graphical modeling system uses the Neo4j graph database to store configuration models and relationship data.

[0056] Take a group of servers responsible for core transaction business as an example. This group of servers includes multiple physical servers, each of which runs multiple virtual machines, and also has various database management systems, middleware software, etc. During the configuration management process, the operation and maintenance personnel created many configuration item nodes on the front-end interface through the graphical modeling engine and defined the relationship between them.

[0057] When the server receives these configuration item nodes and their relationship information, it will store them in the Neo4j graph database. In Neo4j, configuration item nodes are represented as graph vertices, and the relationships between configuration items are represented as graph edges. For example, for a physical server named "Server02", it will be created as a node in Neo4j, and the node's attributes include static attribute information such as the server's name, model, and IP address.

[0058] When a virtual machine named "VM01" is running on "Server02", a node representing "VM01" will be created in Neo4j, and an edge will be used to connect the "Server02" node and the "VM01" node. The attribute of this edge can be defined as "Running", indicating that "VM01" is running on "Server02". Similarly, if a database management system named "Oracle Database 11g" is installed on "VM01", a node representing "Oracle Database 11g" will be created and connected to the "VM01" node through an edge with the attribute "Installed".

[0059] In this way, the configuration model and relationship data of the entire server cluster are stored in the Neo4j graph database in the form of a graph. This storage method can clearly reflect the complex relationship between configuration items, which facilitates subsequent retrieval and analysis.

[0060] As the business of enterprises continues to develop, the scale of server clusters continues to expand, and the relationship between configuration items becomes more and more complex. In this case, operation and maintenance personnel need to quickly and accurately retrieve specific configuration relationship information in order to perform troubleshooting, performance optimization, etc. At this time, Cypher query language plays an important role.

[0061] Suppose the operation and maintenance personnel want to query the information of all virtual machines running on a specific model of physical server. They can enter Cypher query statements in the query interface of the configuration management system. For example: ``` MATCH (server:PhysicalServer {model:'Dell PowerEdge R740'})-[:RUNS]->(vm:VirtualMachine) RETURN vm.name, vm.memory, vm.cpu_cores ``` The meaning of this query statement is: in the Neo4j graph database, find all physical server nodes (labeled as `server`) with the model of "Dell PowerEdgeR740", find the virtual machine nodes (labeled as `vm`) connected to it through the "RUNS" relationship, and then return the names, memory sizes and CPU core numbers of these virtual machines.

[0062] After receiving this query statement, the server will execute the query operation in the Neo4j graph database. Neo4j will quickly locate the physical server node that meets the conditions based on the structure and index information of the graph, and then find the corresponding virtual machine node along the "RUNS" relationship edge, and extract the required attribute information and return it to the server. The server then presents the query results to the operation and maintenance personnel, who can quickly understand the detailed information of the virtual machines running on the specific model physical server through the query results.

[0063] During the operation of the server cluster, the relationship between configuration items may change. For example, due to business adjustments, a virtual machine needs to be migrated from one physical server to another. In this case, the configuration relationship in the Neo4j graph database needs to be dynamically updated.

[0064] After the operation and maintenance personnel perform the virtual machine migration operation on the front-end interface of the configuration management system, the server will receive the corresponding operation request. The server will use the Cypher query language to update the configuration relationship in the Neo4j graph database. For example, if you want to migrate the virtual machine "VM02" from the physical server "Server03" to "Server04", you can execute the following Cypher statement: ``` MATCH (oldServer:PhysicalServer {name:'Server03'})-[:RUNS]->(vm:VirtualMachine {name:'VM02'}) DELETE (oldServer)-[:RUNS]->(vm) WITH vm MATCH (newServer:PhysicalServer {name:'Server04'}) CREATE (newServer)-[:RUNS]->(vm) ``` The purpose of this statement is: first find the "RUNS" relationship between "Server03" and "VM02" and delete it, then find the "Server04" node and create a "RUNS" relationship from "Server04" to "VM02".

[0065] After the server executes this Cypher statement, the configuration relationship in the Neo4j graph database will be updated, accurately reflecting the actual situation after the virtual machine migration. In this way, the Cypher query language can be used to conveniently update large-scale configuration relationships dynamically, ensuring that the data in the configuration management system is always consistent with the actual situation, providing accurate configuration information and management support for operation and maintenance personnel.

[0066] In an embodiment of the present invention, the graphical interface uses WebGL to perform graphical rendering of the model, and combines the force-directed layout algorithm to display the configuration relationship topology diagram.

[0067] In the embodiment of the present invention, for example, in a data center of a large Internet company, a server cluster undertakes the task of storing and processing massive amounts of user data. In order to achieve efficient management of these servers and their related configurations, the graphical interface of the configuration management visualization graphical modeling system uses WebGL for model graphical rendering.

[0068] When the operation and maintenance personnel log in to the graphical interface of the configuration management system, the server begins to process and present the configuration model of the server cluster. Take a group of servers responsible for user data storage as an example. This group of servers includes multiple storage servers, backup servers, and associated network devices and software systems.

[0069] As a powerful 3D drawing standard, WebGL can achieve high-performance graphics rendering in the browser. The server first sends the configuration item nodes and relationship data stored in the database to the front-end graphical interface. For each configuration item node, such as a storage server node, the server assigns corresponding graphic elements and styles to it according to its attribute information (such as server model, storage capacity, etc.). For example, a storage server node may be rendered as a 3D cube with a hard disk icon and storage capacity logo.

[0070] For the relationship between configuration items, such as the data backup relationship between the storage server and the backup server, the server will use WebGL to draw the corresponding connection lines according to the relationship type and attributes. These connection lines may be represented by different colors and thicknesses to represent different relationship types and data transfer amounts. For example, the connection line of the data backup relationship may be represented by blue, and the thickness of the connection line may be adjusted according to the amount of backup data.

[0071] During the rendering process, WebGL uses the server's GPU (graphics processing unit) to accelerate computing and can quickly process large amounts of graphic data. Even when facing large-scale server cluster configuration models, it can achieve smooth graphics rendering, avoiding the possible freezes that may occur when processing complex graphics using traditional rendering methods. Operation and maintenance personnel can use the mouse to zoom, pan, and rotate to observe the configuration relationship topology of the server cluster from different angles, and easily view the detailed information of each configuration item and the connection relationship between them.

[0072] In the data center scenario of the Internet company mentioned above, as the server cluster continues to expand, the relationship between configuration items becomes more and more complex. In order to make the configuration relationship topology diagram more clear and intuitive for operation and maintenance personnel, the system uses a force-directed layout algorithm to layout nodes and connection lines.

[0073] The core idea of ​​the force-directed layout algorithm is to determine the position of nodes by simulating the forces in the physical system, so that the layout between nodes is more reasonable. When the server receives a request to display the configuration relationship topology, it first builds a force-directed layout calculation model based on the relationship data between configuration items.

[0074] Take the relationship between storage servers, backup servers, and network switches as an example. There is a data backup relationship between the storage server and the backup server, and they both transmit data through the network switch. In the force-directed layout algorithm, each configuration item node is regarded as a particle with a charge, and the relationship connection line between the nodes is regarded as a spring.

[0075] The server will calculate the attraction and repulsion between nodes based on factors such as the strength of the relationship between the nodes and the distance. For example, due to the close data backup relationship between the storage server and the backup server, the attraction between them will be large, making them close to each other in the topology map; while the repulsion between the nodes will prevent the nodes from being too crowded and maintain a certain distance.

[0076] At the same time, the server will continuously adjust the position of the node according to the force-directed layout algorithm until the entire system reaches a relatively stable state. In this process, the network switch node may be placed in a suitable position according to the connection relationship with the storage server and the backup server, so that the connection line between them is as simple and clear as possible.

[0077] When the relationship between configuration items changes, such as adding a new storage server and establishing a new backup relationship, the server will update the force-directed layout model in real time. The new storage server node will be added to the calculation model, and the force-directed layout algorithm will recalculate the forces and positions between the nodes, dynamically adjust the layout of the topology map, and ensure that the new configuration relationship can be clearly displayed.

[0078] By combining WebGL for model graphical rendering and force-directed layout algorithm to display configuration relationship topology diagram, the server can provide operation and maintenance personnel with an intuitive, clear and dynamically updated visual interface, helping them better understand and manage the complex configuration relationships of server clusters and improve operation and maintenance efficiency and accuracy.

[0079] In the embodiment of the present invention, the calling of the rule engine to convert the relationship into executable logic can be implemented through the following example.

[0080] Define and configure relationship rules and validation logic based on Drools or equivalent rule engines.

[0081] In the embodiment of the present invention, for example, in a cloud computing data center, the server undertakes the important task of providing computing resources and storage services for many enterprise users. In order to ensure the stable operation of the server cluster and the reasonable allocation of resources, the configuration management visualization graphical modeling system uses the Drools rule engine to define configuration relationship rules and verification logic.

[0082] First, the operation and maintenance team needs to formulate a series of configuration relationship rules based on business needs and the actual operation of the server. Taking the server storage configuration as an example, suppose there is such a rule: when the available storage space of the storage server is less than 20% of the total storage space, it is necessary to automatically trigger the operation of data migration to other storage servers to ensure normal data storage and business continuity.

[0083] In the Drools rule engine, this rule can be defined like this: ``` rule "Storage Space Threshold" when $storageServer : StorageServer(availableSpace <totalSpace 0.2) then / / Code logic to trigger data migration operation DataMigrationService.migrateData($storageServer); end ``` In the above rule, the `when` part defines the triggering condition of the rule, that is, when the available storage space of the storage server is less than 20% of the total storage space, the rule is activated. The `then` part defines the operation to be performed when the condition is met. Here, the `migrateData` method of `DataMigrationService` is called to perform the data migration operation.

[0084] In addition to storage configuration rules, there are also rules about the configuration relationship between servers and applications. For example, a specific application can only run on a server of a specific model and configuration. The operation and maintenance personnel define the following rules in Drools: ``` rule "Application Server Compatibility" when $app : Application(name ==AppX") $server : Server(model!="ModelY" || cpuCores<8) exists(Link(app = $app, server = $server)) then / / Throw an incompatibility warning and prevent the application from being deployed throw new CompatibilityException("AppX cannot be deployed on this server."); end ``` This rule means that when an application named "AppX" attempts to be deployed to a server whose model is not "ModelY" or whose CPU core count is less than 8, an incompatibility warning will be thrown and the application deployment operation will be blocked.

[0085] During server operation, the Drools rule engine continuously monitors the configuration status of the server and the relationship between configuration items. When there is a new configuration operation or the server status changes, the rule engine verifies and judges according to pre-defined rules. For example, when an operation and maintenance personnel tries to deploy an "AppX" application on a server that does not meet the requirements, the rule engine will immediately identify this incompatibility, trigger the corresponding verification logic, block the deployment operation, and send a warning message to the operation and maintenance personnel.

[0086] By defining configuration relationship rules and verification logic based on the Drools rule engine, the server can automatically check and process configuration operations according to business rules, ensuring that the configuration of the server cluster always meets expectations, improving the efficiency and accuracy of operation and maintenance management, and ensuring the stable operation of the business system.

[0087] In the embodiment of the present invention, the data synchronization based on the API service can be implemented through the following examples.

[0088] Combining the two-way data binding framework and RESTful API, the addition, modification, and deletion of configuration items associated with the real-time synchronous presentation layer, service layer, and data layer all trigger dynamic events and automatically refresh the configuration relationship topology diagram.

[0089] In the embodiment of the present invention, for example, in a data center of an e-commerce enterprise, a server cluster is responsible for processing key businesses such as massive order transactions, user data storage, and product information management. With the continuous expansion of business, it is necessary to continuously add server resources to meet the growing business needs.

[0090] The operation and maintenance personnel perform the operation of adding new server configuration items through the display layer (front-end interface) of the configuration management visual graphic modeling system. Suppose the operation and maintenance personnel want to add a new database server "DBServer03". On the graphical interface, the operation and maintenance personnel click the "Add Configuration Item" button, and a form pops up. Fill in the various attribute information of the new server in the form, such as the server name "DBServer03", IP address, database type (such as MySQL), storage capacity, etc.

[0091] When the operator fills out the form and clicks the "Confirm Add" button, the two-way data binding framework of the presentation layer (assuming Vue.js is used) will immediately sense this operation. The role of the two-way data binding framework is to ensure real-time synchronization of data between the view (front-end interface) and the data model. At this time, Vue.js will encapsulate the configuration item data of the new server as a JavaScript object and send this data to the service layer on the server side through the RESTful API.

[0092] After the service layer receives the request for new configuration items from the presentation layer, it will perform a series of business logic processing. First, the service layer will verify whether the received data meets the specifications, such as checking whether the IP address format is correct, whether the database type is in the supported list, etc. If the data verification passes, the service layer will call the corresponding interface to store the static attribute data of the new server in a relational database (such as MySQL). For example, insert a new record in the "server_config" table of MySQL, which contains information such as the server name, IP address, and database type.

[0093] At the same time, the service layer will also store the relational data in a graph database (such as Neo4j) based on the relationship between the new server and other configuration items. Assuming that "DBServer03" needs to establish a data connection relationship with the existing application server "AppServer02", the service layer will create a node representing "DBServer03" in Neo4j and connect it to the "AppServer02" node through an edge with the attribute "data connection".

[0094] After completing the data storage, the service layer will return a successful response message to the presentation layer through the RESTful API. After the presentation layer receives the response message, the two-way data binding framework will update the view according to the new data, that is, the newly added "DBServer03" server configuration item node will be displayed in real time on the graphical interface, and the connection line between it and "AppServer02" will be drawn according to the relationship data. At the same time, the system will trigger a dynamic event to automatically refresh the configuration relationship topology map, so that the configuration relationship of the entire server cluster is presented to the operation and maintenance personnel in the latest state.

[0095] During the peak period of e-commerce business, in order to optimize the performance of the database server, the operation and maintenance personnel need to expand the storage capacity of "DBServer03". The operation and maintenance personnel find the node representing "DBServer03" on the graphical interface of the presentation layer, double-click the node, and the property editing dialog box pops up. In the dialog box, change the storage capacity value from the original "500GB" to "1TB", and then click the "Save" button.

[0096] The two-way data binding framework of the presentation layer will immediately capture this modification operation and send the modified storage capacity data to the service layer through the RESTful API. After receiving the modification request, the service layer will first verify whether the modified data is legal, for example, check whether the storage capacity value is within the allowed range. If the verification is successful, the service layer will call the database interface to update the storage capacity field of the corresponding "DBServer03" record in the "server_config" table in the relational database (MySQL) to "1TB".

[0097] At the same time, the service layer will check whether this modification operation will affect the relationship between configuration items. In this example, the expansion of storage capacity may affect the performance and resource allocation of applications related to the database server. If there are relevant rules defined (for example, when the storage capacity of the database server reaches a certain threshold, the application server associated with it needs to adjust certain parameters), the rule engine will be triggered, and the relationship between related configuration items will be automatically adjusted according to the rules, and the updated relationship data will be stored in the graph database (Neo4j).

[0098] After completing the data update, the service layer returns a successful update message to the presentation layer through the RESTful API. The two-way data binding framework of the presentation layer updates the view based on the latest data and displays the storage capacity attribute of the "DBServer03" node as "1TB". At the same time, the system triggers dynamic events and automatically refreshes the configuration relationship topology diagram to reflect the changes in the configuration item relationship that may be caused by the storage capacity modification.

[0099] As the business is adjusted, a certain application is no longer used, and the corresponding application server "AppServer01" is no longer needed. The operation and maintenance personnel decide to delete the configuration item of "AppServer01" in the configuration management system.

[0100] The operation and maintenance personnel select the node representing "AppServer01" on the graphical interface of the presentation layer and click the "Delete" button. The two-way data binding framework of the presentation layer will perceive this deletion operation and send a request to delete the configuration item to the service layer through the RESTful API.

[0101] After receiving the deletion request, the service layer will first check whether the configuration item has an association relationship. If "AppServer01" has an association relationship with other configuration items (such as database server, storage server, etc.), the service layer will process it according to predefined rules. For example, if there is an associated database connection relationship, the service layer will first disconnect from the database server, update the corresponding relationship data in the graph database (Neo4j), and delete the edge representing this connection relationship.

[0102] Then, the service layer calls the database interface to delete the record of "AppServer01" from the "server_config" table of the relational database (MySQL), and deletes the node representing "AppServer01" from the graph database (Neo4j).

[0103] After the data is deleted, the service layer returns a successful deletion message to the presentation layer through the RESTful API. The two-way data binding framework of the presentation layer updates the view based on the latest data and deletes the "AppServer01" node and its related connection lines from the graphical interface. At the same time, the system triggers dynamic events and automatically refreshes the configuration relationship topology diagram to ensure that the configuration relationship displayed by the presentation layer is consistent with the actual data of the data layer.

[0104] By combining the two-way data binding framework and RESTful API, the server can synchronize data between the presentation layer, service layer, and data layer in real time, ensuring that the addition, modification, and deletion of configuration items can be reflected in the entire system in a timely and accurate manner, and automatically refresh the configuration relationship topology diagram, providing operation and maintenance personnel with a real-time and accurate configuration management visualization interface.

[0105] In the embodiment of the present invention, the initial view model includes a topology view, an attribute view and a dependency chain view, and the topology view, the attribute view and the dependency chain view support node aggregation and dynamic adjustment of edge weights.

[0106] In the embodiment of the present invention, for example, in a data center of a large financial institution, a server cluster is responsible for processing various complex financial transactions and data storage tasks. Operation and maintenance personnel view the overall configuration relationship of the server cluster through the topology view of the configuration management visualization graphical modeling system.

[0107] In the topology view, a large number of server nodes and the connection relationships between them form a complex network topology. As the business develops, the number of servers continues to increase, and the topology becomes more and more complex, making it difficult for operation and maintenance personnel to clearly view the relationship between each part. At this time, the node aggregation function plays an important role.

[0108] For example, there are multiple servers responsible for data storage in a data center, and they are displayed separately in the topology map. In order to more clearly view the overall relationship between storage servers and other types of servers (such as application servers and database servers), operation and maintenance personnel can use the node aggregation function. Operation and maintenance personnel select the nodes of these data storage servers on the topology view interface, and then click the "Node Aggregation" button.

[0109] After receiving this operation request, the server will aggregate these data storage server nodes into a virtual node according to the preset aggregation rules. This virtual node represents all the aggregated data storage servers, and its attributes may be some statistical information of these servers, such as total storage capacity, average usage rate, etc. At the same time, the edges (connection relationships) related to these data storage servers will also be adjusted accordingly.

[0110] The dynamic adjustment function of edge weights also has important applications in the topology view. Assume that the amount of data transmitted between the data storage server and the application server is an indicator for measuring edge weights. When the business peak arrives, the amount of data transmitted between the data storage server and some application servers increases significantly. The server will monitor this data change in real time and dynamically adjust the weight of the corresponding edge according to the preset rules. For example, the thickness of the edge will be adjusted according to the amount of data transmitted. The larger the amount of data transmitted, the thicker the edge. In this way, operation and maintenance personnel can intuitively see which servers have the most frequent data interactions through the topology view, so as to optimize performance and adjust resources in a timely manner.

[0111] In the data center operation and maintenance of financial institutions, operation and maintenance personnel often need to view the detailed attribute information of the server. When they switch to the attribute view, they can see a specific attribute list of each server node, such as server model, number of CPU cores, memory capacity, etc.

[0112] In the property view, the node aggregation function is also of practical significance. For example, the operation and maintenance personnel want to view the overall properties of a certain type of servers with the same hardware configuration. They can filter according to the hardware configuration properties of the server in the property view, and then aggregate the filtered server nodes. The server will aggregate these nodes into a virtual node and display the comprehensive property information of the virtual node in the property view. For example, the average CPU usage, total memory capacity and other statistical information of this type of server are displayed, which makes it convenient for operation and maintenance personnel to quickly understand the overall operation status of this type of server.

[0113] Dynamic adjustment of edge weights can also provide valuable information in the property view. Assume that the edge weights between servers represent the degree of dependency between them. The higher the dependency, the greater the edge weight. When certain attributes of a server change, for example, the business logic of an application server is adjusted and the dependency on a specific database server increases. The server will adjust the weight of the corresponding edge in real time based on this change. In the property view, operation and maintenance personnel can see the changes in edge weights, thereby understanding the dynamic changes in the dependency relationship between servers and adjusting and optimizing the configuration in a timely manner.

[0114] In the process of financial data processing, there are complex dependencies between servers. The dependency chain view can help operation and maintenance personnel clearly view this dependency. For example, the processing of a financial transaction may involve multiple links such as the application server receiving requests, the database server storing data, and the storage server backing up data. These servers form a dependency chain.

[0115] In the dependency chain view, the node aggregation function can help operators view the dependency relationship at a more macro level. Assuming that there are multiple database servers that provide data support for a group of application servers, operators can aggregate these database server nodes into a virtual node. In this way, the dependency chain view will be more concise and clear, and operators can quickly understand the dependency relationship between the application server and the entire database server cluster.

[0116] Dynamic adjustment of edge weights is also very important in the dependency chain view. For example, when the volume of financial transaction business increases within a certain period of time, the frequency of data query requests from the application server to the database server increases significantly. The server will detect this change and dynamically adjust the weight of the edge connecting the application server and the database server. The increase in edge weight may be indicated by a change in the color or thickness of the edge. By observing the dynamic adjustment of edge weights, operation and maintenance personnel can promptly discover the impact of changes in business traffic on server dependencies, and take corresponding measures, such as increasing database server resources, optimizing query logic, etc., to ensure the smooth progress of financial transaction business.

[0117] By supporting node aggregation and dynamic adjustment of edge weights in topology views, property views, and dependency chain views, the server can provide operation and maintenance personnel with a more flexible and intuitive configuration management visualization interface, helping them better understand and manage complex server cluster configuration relationships, and improve operation and maintenance efficiency and system stability.

[0118] In order to more clearly describe the solution provided by the embodiment of the present invention, a relatively complete implementation method is provided below.

[0119] 1. Core idea Through graphic modeling technology, visualization technology, and data integration technology, a dynamic topology model between configuration items is established to reflect the configuration status and its relationship in real time, supporting fault location, change management, and optimization analysis.

[0120] 2. Key technologies 1) Dynamically obtain all configuration items and their relationship data a) Automatic discovery: Collect configuration data of hardware, software and virtual resources through API interface, Agent program or network scanning tool.

[0121] b) Data integration: Integrate data from different sources, such as CMDB, monitoring system, log analysis platform, etc.

[0122] c) Scheduled synchronization: Ensure the real-time and consistency of data through a scheduling mechanism.

[0123] 2) Data-driven graphical representation Build a relationship model between configuration items to form a data-driven graphical representation.

[0124] 3) Model storage and retrieval based on graph database a) Use Neo4j graph database to store configuration models and relationship data, supporting efficient retrieval and dynamic update of large-scale configuration relationships.

[0125] b) Use Cypher query language to quickly query and analyze complex resource relationships.

[0126] 4) WebGL graphics rendering technology a) Use WebGL for model graphics rendering, breaking through the performance bottleneck of traditional interfaces and supporting real-time operations on large-scale nodes and edges.

[0127] b) Combined with the force-directed layout algorithm, a clear and intuitive configuration relationship topology diagram is presented.

[0128] 5) Intelligent configuration relationship management of rule engine a) Based on Drools or an equivalent rule engine, define and configure relationship rules and validation logic to achieve automatic relationship generation and conflict detection.

[0129] b) Support rule version management to ensure sustainable model optimization.

[0130] 6) Real-time data synchronization and dynamic update a) Combine two-way data binding frameworks (such as Vue.js) and RESTful APIs to synchronize user operations to the backend in real time.

[0131] b) Addition, modification, and deletion of configuration items trigger dynamic events, updating the model and automatically refreshing the topology map.

[0132] 7) Multi-dimensional view switching and interaction optimization a) Provides topology view, attribute view and dependency chain view, which can be flexibly switched to meet different user needs.

[0133] b) Supports node aggregation and dynamic adjustment of edge weights to optimize the display effect of complex topology graphs.

[0134] 8) Intelligent assisted modeling a) Use machine learning algorithms (e.g., pattern recognition based on configuration relationships) to automatically recommend possible missed associations.

[0135] b) Dynamically highlight abnormal points in the model to help users quickly locate problems.

[0136] 3. Configuration working principle 1) Workflow and steps Process steps description: Configuration model definition: Operation and maintenance personnel create configuration item nodes on the front-end interface through the graphical modeling engine and define the relationship between configuration items. Users can select existing templates, create manually, or automatically generate a preliminary configuration model through the intelligent modeling assistant.

[0137] Relationship rule generation: Users define the relationship rules between configuration items through a graphical interface. The system converts the relationship rules into executable logic through a rule engine and stores the relationship data in a graph database.

[0138] Data storage and synchronization: The system stores static attribute data of configuration items in a relational database, and relationship data between configuration items in a graph database. Data is synchronized in real time through an event-driven architecture (such as Kafka) to ensure data consistency.

[0139] Visual display and update: Users view and adjust the configuration model through the graphical modeling engine on the front-end interface. The system provides real-time feedback on changes in configuration items and synchronizes them to the back-end data layer through the API interface.

[0140] 2) Parameter selection Database selection: Neo4j is selected as the graph database to ensure the storage and query performance of complex relationships. The relational database MySQL is used to store static data of configuration items, such as attributes, types, etc.

[0141] Selection of graphical modeling engine: Use D3.js or Cytoscape.js as the visualization graphics library to support complex graphics rendering and interactive functions.

[0142] Rule engine selection: Drools is used as the rule engine to provide flexible rule definition and execution functions to meet the needs of automatic generation of configuration relationships.

[0143] 3) Positional relationship, connection relationship, and operation relationship between components Position relationship: The graphical modeling engine, rule engine and database are connected through API to ensure real-time synchronization and smooth interaction of data. The front-end display layer and the service layer interact with each other through RESTful API, and the service layer and the data layer are connected through graph database and relational database.

[0144] Connection relationship: The attribute data of configuration items and the relationship between configuration items are transmitted through the API layer to ensure efficient access and synchronization of data. The rule engine updates the relationship data between configuration items by calling the database interface to ensure the accuracy of the configuration management system.

[0145] Operational relationships: Users operate the graphical modeling engine through the front-end interface to create configuration items and define relationships. The rule engine automatically processes the relationships between configuration items according to predefined rules and returns the results to the database for storage. The data synchronization mechanism ensures data consistency and real-time updates at all levels.

[0146] 4. System functional architecture The overall architecture adopts a layered design, including data layer, service layer and presentation layer. Please refer to Figure 2 .

[0147] 1) Data layer: configure data storage and relationship management The data layer uses a graph database (Neo4j) and a relational database (MySQL) to store data. The graph database is used to store the relationship data between configuration items, and the relational database stores the static attribute data of configuration items (such as name, category, attribute, etc.). Among them, the location relationship is stored independently in the graph database and the relational database at the physical level, but data synchronization and linkage are performed through the API interface; the connection relationship in the attributes of the configuration items and the relationship between the configuration items are synchronized and updated between the graph database and the relational database to ensure consistency.

[0148] 2) Service layer: business logic and rule engine The service layer uses rule engines (such as Drools) and API services (RESTful API). The rule engine is used to define the relationship rules between configuration items and automatically generate dependencies between configuration items. The API service provides data synchronization, business logic processing, and front-end interaction.

[0149] Location relationship: The rule engine is deployed in the service layer, initiates data access requests to the data layer, and interacts with the front end through the API layer.

[0150] Connection relationship: The service layer is connected to the data layer through the API. The rule engine generates and updates the relationship between configuration items when the data storage is updated, and feeds back to the front end for display.

[0151] 3) Display layer: visual modeling interface The presentation layer uses front-end graphical modeling engines (such as D3.js, Cytoscape.js) and React / Vue UI to provide a graphical modeling interface. Users can intuitively create configuration items and define relationships through operations such as dragging and clicking. It supports multiple views such as topology diagrams and tree diagrams.

[0152] Location relationship: The front-end presentation layer is deployed on the user side and directly communicates with the back-end service layer to obtain and update configuration data.

[0153] Connection relationship: The front-end interface is connected to the back-end service layer through the RESTful API to update and display the data model in real time.

[0154] 5. Effect of technical solution implementation 1) Significantly improve modeling efficiency: By introducing visual modeling technology, the configuration model building cycle is shortened by more than 50%, effectively reducing the initial configuration cost of complex systems.

[0155] 2) Optimize the operation and maintenance management experience: The intuitive display and interactive adjustment of the visual model significantly reduce the understanding and operation threshold of technical operation and maintenance personnel, and improve the system maintenance efficiency.

[0156] 3) Supporting automated and intelligent O&M: The dynamic topology model not only supports real-time updates of resource relationships, but also provides basic data support for intelligent O&M (such as fault location and impact analysis).

[0157] Please refer to Figure 3 , Figure 3 A configuration management visualization graphic modeling device 110 provided in an embodiment of the present invention is applied to a configuration management visualization graphic modeling system, wherein the configuration management visualization graphic modeling system includes a presentation layer, a service layer, and a data layer, wherein the presentation layer includes a graphic modeling engine, the service layer includes a rule engine and an API service, and the data layer includes a graph database and a relational database, and the method includes: The modeling module 1101 is used to respond to the user creating a configuration item node on the graphical interface through the graphical modeling engine, and define the relationship between the configuration items through the graphical interface; call the rule engine to convert the relationship into executable logic, and store the relationship data between the configuration items in the graph database, store the static attribute data of the configuration items in the relational database, and generate an initial view model; and respond to the user's configuration item modification operation on the initial view model through the graphical interface, and complete data synchronization based on the API service.

[0158] It should be noted that the implementation principle of the aforementioned configuration management visualization graphic modeling device 110 can refer to the implementation principle of the aforementioned configuration management visualization graphic modeling method, and will not be repeated here. It should be understood that the division of the various modules of the above device is only a division of logical functions. In actual implementation, they can be fully or partially integrated into a physical entity, or physically separated. And these modules can all be implemented in the form of software calling through processing elements; they can also be all implemented in the form of hardware; some modules can also be implemented in the form of software calling through processing elements, and some modules can be implemented in the form of hardware. For example, the configuration management visualization graphic modeling device 110 can be a separately established processing element, or it can be integrated in a chip of the above device. In addition, it can also be stored in the memory of the above device in the form of program code, and called and executed by a processing element of the above device. The function of the above configuration management visualization graphic modeling device 110. The implementation of other modules is similar. In addition, these modules can be fully or partially integrated together, or they can be implemented independently. The processing element described here can be an integrated circuit with signal processing capabilities. In the implementation process, each step of the above method or each of the above modules can be completed by an integrated logic circuit of hardware in a processor element or instructions in the form of software.

[0159] For example, the above modules may be one or more integrated circuits configured to implement the above methods, such as one or more application specific integrated circuits (ASIC), or one or more microprocessors (digital signal processors, DSP), or one or more field programmable gate arrays (FPGA), etc. For another example, when a module above is implemented in the form of a processing element scheduling program code, the processing element may be a general-purpose processor, such as a central processing unit (CPU) or other processor that can call program code. For another example, these modules may be integrated together and implemented in the form of a system-on-a-chip (SOC).

[0160] The embodiment of the present invention provides a computer device 100, which includes a processor and a non-volatile memory storing computer instructions. When the computer instructions are executed by the processor, the computer device 100 executes the above-mentioned configuration management visualization graphic modeling device 110. Figure 4 As shown, Figure 4The computer device 100 provided in the embodiment of the present invention is a structural block diagram. The computer device 100 includes a configuration management visualization graphic modeling device 110, a memory 111, a processor 112 and a communication unit 113.

[0161] To achieve data transmission or interaction, the memory 111, the processor 112 and the communication unit 113 are electrically connected to each other directly or indirectly. For example, the electrical connection between these elements can be achieved through one or more communication buses or signal lines. The configuration management visual graphic modeling device 110 includes at least one software function module that can be stored in the memory 111 in the form of software or firmware or solidified in the operating system (OS) of the computer device 100. The processor 112 is used to execute the configuration management visual graphic modeling device 110 stored in the memory 111, such as the software function modules and computer programs included in the configuration management visual graphic modeling device 110.

[0162] An embodiment of the present invention provides a readable storage medium, which includes a computer program. When the computer program is executed, the computer device where the readable storage medium is located is controlled to execute the aforementioned configuration management visualization graphic modeling device 110.

[0163] For illustrative purposes, the foregoing description is made with reference to specific embodiments. However, the above illustrative discussion is not intended to be exhaustive or to limit the present disclosure to the precise form disclosed. Numerous modifications and variations are possible in accordance with the above teachings. These embodiments are selected and described in order to best illustrate the principles of the present disclosure and its practical application, so that those skilled in the art can best utilize the present disclosure and utilize various embodiments with different modifications to suit the intended specific application.

Claims

1. A configuration management visualization graphical modeling method, characterized in that: Applied to a configuration management visualization graphic modeling system, the configuration management visualization graphic modeling system includes a presentation layer, a service layer and a data layer, the presentation layer includes a graphical modeling engine, the service layer includes a rule engine and an API service, the data layer includes a graph database and a relational database, and the method includes: In response to a user creating a configuration item node on a graphical interface through the graphical modeling engine, and defining a relationship between configuration items through the graphical interface; Calling the rule engine to convert the relationship into executable logic, storing the relationship data between the configuration items in the graph database, storing the static attribute data of the configuration items in the relational database, and generating an initial view model; In response to a user modifying a configuration item of the initial view model through the graphical interface, data synchronization is completed based on the API service.

2. The method according to claim 1, characterized in that The method further comprises: Automatically discover and collect configuration data of hardware, software and virtual resources through API interface, Agent program or network scanning tool to dynamically obtain all configuration items and their relationship data.

3. The method according to claim 1, characterized in that The storing of the relationship data between the configuration items into the graph database includes: The Neo4j graph database is used to store the configuration model and the relationship data, and the Cypher query language is used to realize the retrieval and dynamic update of large-scale configuration relationships; the configuration model is the relationship between pre-stored configuration items.

4. The method according to claim 1, characterized in that: The graphical interface uses WebGL to perform graphical rendering of the model, and combines the force-directed layout algorithm to display the configuration relationship topology diagram.

5. The method according to claim 1, characterized in that The calling of the rule engine to convert the relationship into executable logic includes: Define and configure relationship rules and validation logic based on Drools or equivalent rule engines.

6. The method according to claim 1, characterized in that The data synchronization based on the API service includes: Combining the two-way data binding framework and RESTful API, the addition, modification, and deletion of configuration items associated with the real-time synchronous presentation layer, service layer, and data layer all trigger dynamic events and automatically refresh the configuration relationship topology diagram.

7. The method according to claim 1, characterized in that The initial view model includes a topology view, an attribute view and a dependency chain view, and the topology view, the attribute view and the dependency chain view support node aggregation and dynamic adjustment of edge weights.

8. A configuration management visualization graphic modeling device, characterized in that: Applied to a configuration management visualization graphic modeling system, the configuration management visualization graphic modeling system includes a presentation layer, a service layer and a data layer, the presentation layer includes a graphical modeling engine, the service layer includes a rule engine and an API service, the data layer includes a graph database and a relational database, and the method includes: A modeling module, for responding to a user creating a configuration item node on a graphical interface through the graphical modeling engine, and defining the relationship between configuration items through the graphical interface; calling the rule engine to convert the relationship into executable logic, and storing the relationship data between configuration items in the graph database, storing the static attribute data of the configuration items in the relational database, and generating an initial view model; for responding to a user modifying the configuration item of the initial view model through the graphical interface, and completing data synchronization based on the API service.

9. A computer device, characterized in that: The computer device comprises a processor and a non-volatile memory storing computer instructions. When the computer instructions are executed by the processor, the computer device executes the method according to any one of claims 1 to 7.

10. A readable storage medium, characterized in that: The readable storage medium includes a computer program, and when the computer program is executed, the computer device where the readable storage medium is located is controlled to execute the method according to any one of claims 1 to 7.

Images