Graphical construction and edge deployment method for microservice architecture using configuration software development

Abstract

The present invention provides a graphical construction and edge deployment method for developing configuration software for a microservice architecture. The method includes: using a graphical interface to construct the interface and logic of the configuration software through operations such as dragging and dropping and connecting; building a graphical component library containing multiple predefined microservice components, which include data collection, processing, storage, and display; predefined microservice components support converting graphical components into executable microservice code to build the configuration software; combining edge computing node deployment strategies to deploy the microservices of the configuration software close to the data source; an edge deployment framework automatically completes the deployment and startup of microservices based on configuration files, and supports automatic deployment, monitoring, and upgrading of microservices; monitoring the status of edge computing nodes through a graphical interface and remotely configuring and managing them; and real-time node status monitoring, log analysis, and troubleshooting. The present invention improves development efficiency.

Description

Technical Field

[0001] The present invention relates to the technical field of configuration software development, and in particular to a graphical construction and edge deployment method for configuration software development for a microservice architecture. Background Art

[0002] With the rapid development of Industry 4.0 and smart manufacturing, the demand and complexity of industrial software are continuously increasing. Traditional industrial software development methods often rely on code writing, which is not only time-consuming and labor-intensive, but also difficult to adapt to rapidly changing business needs. To improve development efficiency and system flexibility, microservices architecture has gradually become the mainstream choice for industrial software development. By breaking down complex systems into multiple independent services, each of which can be independently developed, deployed, and expanded, microservices architecture greatly improves system maintainability and scalability. Traditional microservices development methods still require developers to have high programming skills, which to some extent limits the rapid development and deployment of industrial software. To address this problem, graphical build technology has emerged; through a graphical interface, developers can easily create and deploy industrial software. In addition, with the rise of edge computing technology, more and more industrial applications require computing resources to be deployed close to the data source to reduce latency and improve response time.

[0003] Prior art 1, application number: CN 202410293026.3 discloses a method, apparatus, device and medium for graphical processing of table data, which obtains corresponding internal data from different modules according to the business information provided by the user; generates configuration information according to the instruction information provided by the user; performs layout calculation according to the internal data and configuration information, and performs graphical processing based on the internal data and the layout obtained after calculation. Although the table drawing is completed on the canvas, the internal data of different functional modules can be graphically processed, allowing users to have an overall intuitive feeling of the internal data of each module, so as to facilitate understanding and editing of data, thereby reducing development costs and difficulty. However, it mainly relies on the business information and instruction information provided by the user to generate configuration information, and perform layout calculation and graphical processing; when faced with complex and changing business needs, its flexibility and adaptability may be insufficient, making it difficult to quickly respond to and process new business scenarios.

[0004] Prior art 2, application number: CN202211607550.0 discloses a method and system for merging industrial software microservices, including: packaging each set industrial microservice business code into a single Jar package; storing the formed multiple single Jar packages in a single warehouse; determining the required microservice type and quantity in response to external service requests; calling the single Jar packages corresponding to the microservices from the single warehouse through a base application for combination, and merging the configurations of the microservices into a configuration file to start the combined microservice. Although by compiling the industrial microservice business code into a single Jar package and storing it in a single warehouse, the base application can call any single Jar package in the single warehouse for combination as needed, the configuration is flexible, does not involve specific business code, and the consistency of the solution is relatively strong; it reduces the deployment cost of a large number of microservices and the development and maintenance cost of software, but merging the configurations of multiple microservices into a single configuration file will significantly increase with the increase in the number of microservices, which may make the management and maintenance of the configuration file difficult and prone to configuration errors or conflicts.

[0005] Prior art three, application number: CN202310901638.1 discloses a method for modeling and code generation of industrial components in the OT domain based on a microservice architecture. Spring Cloud Alibaba is used as the specific implementation of the microservice architecture. The message queue component and service registration and discovery component use RocketMQ and Nacos respectively. The OT domain uses 4diacIDE as the development environment, including the following steps:

[0006] Step 1: Modeling the OT domain industrial software component; Step 2: Generating microservice program code; Step 3: Running the microservice program. While combining IT-domain microservice technology with the IEC61499 standard for the OT domain has resulted in an efficient and flexible universal model for OT-domain industrial software components, and utilizing a code generator to bridge the gap from OT-domain models to IT-domain program implementation, creating an efficient and low-learning-cost development environment, in practice, the mapping between the OT-domain industrial software component model and the IT-domain microservice program can be complex. Information loss or inconsistencies can occur during the model conversion process, making it difficult for the generated code to fully meet expectations.

[0007] Currently, existing technologies 1, 2, and 3 have insufficient flexibility and adaptability, and their industrial software performance and reliability are poor. Therefore, the present invention provides a graphical construction and edge deployment method for configuration software development of a microservice architecture. Summary of the Invention

[0008] In order to solve the above technical problems, the present invention provides a graphical construction and edge deployment method for microservice architecture using configuration software development, comprising the following steps:

[0009] Use a graphical interface to build a graphical component library and construct configuration software;

[0010] Combined with the edge computing node deployment strategy, the microservices of the configuration software are deployed close to the data source; the edge deployment framework automatically completes the deployment and startup of the microservices based on the configuration file;

[0011] Monitor the status of edge computing nodes through a graphical interface and perform remote configuration and management.

[0012] Optionally, the deployment framework automatically identifies and deploys the corresponding microservices, including the following steps:

[0013] Before parsing the configuration file, the framework analyzes and recommends it, automatically recommending resource allocation plans, node selection strategies, and startup parameters based on historical deployment data and current environmental conditions.

[0014] The framework is built using an adaptive dependency graph. It builds an initial dependency graph based on the configuration file, monitors the running status of each microservice in real time during the deployment process, and dynamically adjusts the dependency relationships.

[0015] During the resource demand assessment and allocation phase, the framework uses real-time monitoring data from edge computing nodes to detect node resource usage and dynamically adjust resource allocation strategies based on this real-time data. Each microservice image generates a unique hash value when it is generated and is recorded on the blockchain. During the image pull process, the framework automatically verifies the image's hash value.

[0016] During the service startup and monitoring phase, when the number of requests for a microservice increases, the framework automatically calls computing resources to cope with high-concurrency requests, and automatically releases resources after the number of requests decreases to achieve elastic scaling; the framework monitors the running status of the microservice in real time and automatically triggers operation and maintenance operations in an event-driven manner.

[0017] Optionally, if a microservice encounters an exception during startup, the framework automatically adjusts the dependency graph and re-plans the startup order.

[0018] The optional resource needs assessment and allocation phase includes the following steps:

[0019] The framework integrates multiple sensors to collect multi-dimensional resource data of edge computing nodes in real time. Through high-frequency sampling and real-time analysis, it forms a dynamic resource usage map and predicts the resource demand trend of nodes in the future.

[0020] Based on real-time monitoring of multi-dimensional resource data and resource demand trends, the framework dynamically adjusts resource allocation strategies. By introducing an intelligent load balancing algorithm, the framework dynamically distributes microservice requests across multiple nodes.

[0021] The generated hash value is recorded on the blockchain, forming an unalterable image identity. The framework automatically obtains the hash value of the image from the blockchain and compares it with the locally calculated hash value. If the hash values do not match, the framework will refuse to pull the image and trigger a security alert.

[0022] Optionally, the framework dynamically adjusts the resource allocation strategy, including the following steps:

[0023] The threshold is dynamically adjusted based on historical data and real-time fluctuations. When the CPU usage of a node exceeds the dynamic threshold, the framework identifies the node as a high-load node and triggers an early warning mechanism. The decision engine makes microservice migration decisions.

[0024] Using multi-dimensional resource data collected in real time, the framework predicts the load change trend of each node over the next period of time. By simulating the migration process, it evaluates the adaptability of different nodes and selects the node with the lowest load and the best resource utilization as the migration target.

[0025] By calculating the Nash equilibrium point, the framework dynamically adjusts the migration strategy between multiple nodes. After the migration decision is made, the framework automatically executes the microservice migration operation. After the migration is completed, the framework records the migration results and continuously optimizes the migration strategy.

[0026] Optionally, the process of selecting the node with the lowest load and the best resource utilization as the migration target includes the following steps:

[0027] Based on real-time load data and resource status, it automatically generates multiple migration scenarios, diverse migration combinations, and paths to cover different load and resource conditions. It also optimizes the use of bandwidth, CPU, and memory resources through linear programming and integer programming.

[0028] Utilize the virtualization migration engine to perform migration operations in a virtual environment, simulating resource changes and performance indicators in a real environment. Simultaneously simulate multiple migration scenarios, accelerating the simulation process through distributed computing and parallel processing.

[0029] Introducing dynamic load balancing indicators to evaluate the load distribution of each node after migration in real time; adaptive weighted load balancing to ensure load balancing of each node.

[0030] Optionally, a load difference coefficient is calculated to quantify the load difference between nodes, and the load difference coefficient is used to evaluate the uniformity of the load distribution after migration.

[0031] Optionally, the process of calculating the Nash equilibrium point includes the following steps:

[0032] In the resource allocation scenario, the participants are individual nodes or microservices, and the strategy selected by each participant is a different resource allocation scheme or migration path;

[0033] For each participant, calculate the benefits of each strategy when other participants choose a specific strategy, and find the optimal strategy; among all participants, find a strategy combination such that the strategy selected by each participant under this combination is the optimal one;

[0034] Through iterative calculation, the strategy of each participant is gradually adjusted until a stable strategy combination, namely the Nash equilibrium point, is found.

[0035] Optionally, for each participant, define a payoff function that represents the payoff or cost of each participant under different strategy combinations.

[0036] Optionally, the process of automatically deploying the microservice image to a specified edge computing node in combination with the edge computing node deployment strategy includes the following steps:

[0037] The deployment framework parses the configuration file and extracts the deployment information of the microservice. The parsing process includes verifying the integrity and correctness of the configuration file. The deployment framework checks the resource status of the target edge computing node. Based on the resource requirements in the configuration file, the deployment framework reserves the corresponding resources on the target node.

[0038] The deployment framework pulls the microservice image from the image repository based on the image information in the configuration file. After the pull is complete, the deployment framework verifies the image.

[0039] The deployment framework deploys the verified microservice image to the specified edge computing node. The deployment process includes decompressing the image, mounting the file system, and injecting the configuration file. After the deployment is completed, the deployment framework executes the microservice startup command according to the startup parameters in the configuration file.

[0040] The graphical construction configuration software system of the present invention, through a graphical interface, allows developers to intuitively construct the interface and logic of the configuration software, avoiding the tedious code writing process and significantly improving development efficiency; the graphical component library contains a variety of predefined microservice components, such as data acquisition, processing, storage and display, etc., which developers can quickly assemble into a complete software system without in-depth understanding of the underlying technical details, thus lowering the development threshold; the graphical programming environment supports the conversion of graphical components into executable microservice code, and developers can quickly implement the development and deployment of business logic through simple drag and drop and configuration, thereby enhancing the flexibility and scalability of the system. Significance: Through graphical construction, developers can quickly implement business logic, shorten the software development cycle, and enable products to be brought to market faster; graphical construction lowers the development threshold, reduces the technical training costs of developers, and also reduces the time cost of code writing and debugging. The edge computing node deployment strategy deploys the configuration software's microservices close to the data source, reducing data transmission latency and improving system responsiveness. The edge deployment framework supports automated deployment, monitoring, and upgrades of microservices, ensuring system stability and maintainability. Automatic deployment and monitoring capabilities quickly restore services in the event of node failures, improving system reliability. The edge deployment framework enables automated operation and maintenance of microservices, reducing manual intervention and lowering operation and maintenance costs. Significance: By reducing data transmission latency, system responsiveness is improved, enhancing the user experience. Automatic deployment, monitoring, and upgrade capabilities ensure stable system operation and reduce business interruptions caused by node failures. Graphical monitoring and management: Through a graphical interface, administrators can monitor the status of edge computing nodes in real time and perform remote configuration and management, improving operation and maintenance efficiency. The graphical interface supports real-time viewing of node status, log analysis, and troubleshooting, helping administrators quickly locate and resolve issues, reducing troubleshooting time. The graphical interface allows administrators to conveniently operate remotely, eliminating the need for on-site visits, improving management convenience and efficiency. Significance: Graphical monitoring and management tools enable operation and maintenance personnel to quickly locate and resolve problems, improving operation and maintenance efficiency and reducing system downtime. Remote configuration and management functions reduce the need for on-site maintenance and lower operation and maintenance costs.

[0041] Other features and advantages of the present invention will be described in the following description, and in part will become apparent from the description, or will be understood by practicing the present invention. The purpose and other advantages of the present invention can be realized and obtained by the structures particularly pointed out in the written description and the accompanying drawings.

[0042] The technical solution of the present invention is further described in detail below through the accompanying drawings and embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] The accompanying drawings are used to provide a further understanding of the present invention and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention and do not constitute a limitation of the present invention. In the accompanying drawings:

[0044] Figure 1 A flowchart of a graphical construction and edge deployment method for developing configuration software for a microservice architecture in Example 1 of the present invention;

[0045] Figure 2 A process diagram for constructing the interface and logic of the configuration software in Example 2 of the present invention;

[0046] Figure 3 This is a process diagram for automatically completing the deployment and startup of microservices according to the configuration file in Example 3 of the present invention;

[0047] Figure 4 This is a process diagram of the deployment framework automatically identifying and deploying corresponding microservices in Example 4 of the present invention;

[0048] Figure 5 This is a process diagram of the resource demand assessment and allocation stage in Example 5 of the present invention;

[0049] Figure 6 This is a process diagram of dynamically adjusting resource allocation strategies within the framework in Example 6 of the present invention;

[0050] Figure 7 This is a diagram of the process of selecting the node with the lowest load and the best resource utilization as the migration target in Example 7 of the present invention;

[0051] Figure 8 This is a diagram of the process of calculating the Nash equilibrium point in Example 8 of the present invention;

[0052] Figure 9 This is a process diagram for automatically deploying a microservice image to a specified edge computing node in Example 9 of the present invention;

[0053] Figure 10 This is a process diagram for remote configuration and management in Example 10 of the present invention. DETAILED DESCRIPTION

[0054] The preferred embodiments of the present invention are described below with reference to the accompanying drawings. It should be understood that the preferred embodiments described herein are only used to illustrate and explain the present invention, and are not used to limit the present invention.

[0055] The terms used in the embodiments of the present application are for the purpose of describing specific embodiments only and are not intended to limit the embodiments of the present application. The singular forms "a", "the" and "the" used in the embodiments of the present application are also intended to include plural forms unless the context clearly indicates otherwise. 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.

[0056] When the following description refers to the accompanying drawings, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present application. On the contrary, they are merely examples of devices and methods consistent with some aspects of the present application. In the description of the present application, it should be understood that the terms "first", "second", "third", etc. are only used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence, nor can they be understood as indicating or implying relative importance. For those of ordinary skill in the art, the specific meanings of the above terms in the present application can be understood according to the specific circumstances.

[0057] Example 1: Figure 1 As shown, an embodiment of the present invention provides a graphical construction and edge deployment method for microservice architecture using configuration software development, comprising the following steps:

[0058] S100: Uses a graphical interface to build the interface and logic of configuration software through operations such as drag-and-drop and connection. Builds a graphical component library containing a variety of predefined microservice components, including data collection, processing, storage, and display. Predefined microservice components support converting graphical components into executable microservice code to build configuration software.

[0059] S200: Combined with edge computing node deployment strategies, the configuration software's microservices are deployed close to the data source. The edge deployment framework automatically deploys and starts microservices based on configuration files, supporting automatic deployment, monitoring, and upgrades of microservices.

[0060] S300: Monitors the status of edge computing nodes through a graphical interface, and performs remote configuration and management; performs real-time viewing of node status, log analysis, and troubleshooting.

[0061] The working principle and beneficial effects of the above technical solution are as follows: This embodiment first adopts a graphical interface to build the interface and logic of the configuration software through operations such as drag and drop and connection; builds a graphical component library containing a variety of predefined microservice components, and the predefined microservice components include data collection, processing, storage and display, etc.; the predefined microservice components support converting graphical components into executable microservice codes to build configuration software; secondly, combined with the edge computing node deployment strategy, the microservices of the configuration software are deployed in a location close to the data source; the edge deployment framework (refers to a software platform or system that provides a series of tools, libraries and specifications for simplifying the development, deployment, management and monitoring of microservices) automatically completes the deployment and startup of microservices according to the configuration file, and supports automatic deployment, monitoring and upgrading of microservices; finally, the status of the edge computing node is monitored through a graphical interface, and remote configuration and management are performed; the node status is viewed in real time, log analysis and troubleshooting are performed, etc. Step S100 of the above scheme graphically constructs the configuration software system. Through the graphical interface, developers can intuitively build the interface and logic of the configuration software, avoiding the tedious code writing process and significantly improving development efficiency. The graphical component library contains a variety of predefined microservice components, such as data acquisition, processing, storage and display. Developers do not need to deeply understand the underlying technical details and can quickly assemble them into a complete software system, lowering the development threshold. The graphical programming environment supports the conversion of graphical components into executable microservice code. Developers can quickly develop and deploy business logic through simple drag and drop and configuration, enhancing the flexibility and scalability of the system. Significance: Through graphical construction, developers can quickly implement business logic, shorten the software development cycle, and enable products to be brought to market faster. Graphical construction lowers the development threshold, reduces the technical training costs of developers, and also reduces the time cost of code writing and debugging. Step S200 implements an edge computing node deployment strategy, deploying the configuration software's microservices close to the data source. This reduces data transmission latency and improves system responsiveness. The edge deployment framework supports automatic deployment, monitoring, and upgrades of microservices, ensuring system stability and maintainability. Automatic deployment and monitoring capabilities quickly restore services in the event of node failures, improving system reliability. The edge deployment framework enables automated operation and maintenance of microservices, reducing manual intervention and lowering operation and maintenance costs. Significance: By reducing data transmission latency, system responsiveness is improved, enhancing the user experience. Automatic deployment, monitoring, and upgrade capabilities ensure stable system operation and minimize service interruptions caused by node failures.Step S300 graphical monitoring and management: Through a graphical interface, administrators can monitor the status of edge computing nodes in real time and perform remote configuration and management, improving O&M efficiency. The graphical interface supports real-time viewing of node status, log analysis, and troubleshooting, helping administrators quickly locate and resolve issues, reducing troubleshooting time. Through the graphical interface, administrators can conveniently perform remote operations without having to visit the site, improving management convenience and efficiency. Significance: Graphical monitoring and management tools enable O&M personnel to quickly locate and resolve issues, improving O&M efficiency and reducing system downtime. Remote configuration and management capabilities reduce the need for on-site maintenance and lower O&M costs.

[0062] In summary, this embodiment not only improves development efficiency and operation and maintenance efficiency, reduces development and operation and maintenance costs, but also significantly improves the performance and reliability of the system. It provides a new solution for the development and deployment of industrial software, which has important technical significance and application value. The above three steps effectively solve the problems of insufficient flexibility, high development and maintenance costs, and performance and reliability in the existing technology. It not only improves development efficiency and reduces development and maintenance costs, but also significantly improves the performance and reliability of the system, providing a new solution for the development and deployment of industrial software. This embodiment provides a graphical interface, allowing developers to intuitively build the interface and logic of the configuration software through operations such as drag and drop and connection. A graphical component library is built, which contains a variety of predefined microservice components, such as data acquisition, processing, storage and display, to facilitate rapid assembly into a complete software system. Through the graphical programming environment, it supports the conversion of graphical components into executable microservice code, realizing the rapid development and deployment of business logic. Combined with the edge computing node deployment strategy, the microservices of the configuration software are deployed close to the data source to reduce latency and improve response speed. The edge deployment framework supports automatic deployment, monitoring, and upgrades of microservices, ensuring system stability and maintainability. A graphical deployment management tool allows administrators to monitor the status of edge nodes through a graphical interface and perform remote configuration and management.

[0063] Example 2: Figure 2 As shown, based on Example 1, the process of constructing the interface and logic of the configuration software provided by the embodiment of the present invention includes the following steps:

[0064] S101: Use the logic editor to manage the logic flow and provide logic nodes. Each node represents a logic operation or control structure, such as conditional judgment, loop, and trigger. Build the logic flow by dragging and connecting nodes.

[0065] Among them, the condition judgment node and microservice are used to implement conditional routing and traffic control between services. Each condition corresponds to a microservice instance or a group of instances;

[0066] Loop control nodes and microservices are used to implement batch processing and retry mechanisms between microservices. Multiple loop types are supported, such as batch requests, retry logic, etc.

[0067] Function call nodes and microservices are used to call specific functional modules in microservices, support parameter passing and return value processing, and realize functional reuse between microservices;

[0068] Data processing nodes and microservices are used to process and convert data between microservices, supporting operations such as data filtering, sorting, aggregation, and format conversion to achieve data consistency and standardization;

[0069] Event trigger nodes and microservices are used to respond to specific events in microservices, such as timer events, user operation events, and data change events. When an event is triggered, the corresponding microservice call is executed;

[0070] S102: inserting code logic into the logic flow in the graphical interface, embedding the custom code snippet, and inserting the custom code;

[0071] S103: Build a graphical component library that includes various predefined microservice components such as data collection, processing, storage and display; at the same time, support the import and export of user-defined components, and the integration of custom components with predefined components.

[0072] The working principle and beneficial effects of the above technical solution are as follows: This embodiment first uses a logic editor to manage the logic flow and provides logic nodes, each node representing a logic operation or control structure, such as conditional judgment, loop and trigger, etc.; the logic flow is constructed by dragging and connecting nodes; among them, the conditional judgment node and microservice are used to implement conditional routing and flow control between services, and each condition corresponds to a microservice instance or a group of instances; the loop control node and microservice are used to implement batch processing and retry mechanism between microservices. It supports multiple loop types, such as batch requests, retry logic, etc.; function call nodes and microservices are used to call specific functional modules in microservices, support parameter passing and return value processing, and realize functional reuse between microservices; data processing nodes and microservices are used to process and convert data between microservices, support data filtering, sorting, aggregation and format conversion and other operations, to achieve data consistency and standardization; event triggering nodes and microservices are used to respond to specific events in microservices, such as timer events, user operation events and data change events, etc. When the event is triggered, the corresponding microservice call is executed; secondly, code logic is inserted into the logical flow in the graphical interface, custom code snippets are embedded, and custom code is inserted; finally, a graphical component library is built that includes a variety of predefined microservice components such as data collection, processing, storage and display; at the same time, it supports the import and export of user-defined components, and the integration of custom components and predefined components. In step S101 of the above scheme, a logic editor is used to manage the logic flow. Through logic nodes, users can intuitively build complex logic flows. Each node represents a logical operation or control structure, such as conditional judgment, loop, and trigger. This visual approach greatly reduces the difficulty of understanding and maintaining complex logic. The conditional judgment node is integrated with microservices to implement conditional routing and flow control between services. Each condition corresponds to a microservice instance or a group of instances, ensuring the flexibility and efficiency of the service. The loop control node is integrated with microservices to support multiple loop types, such as batch requests and retry logic, ensuring batch processing and retry mechanisms between microservices and improving the stability and reliability of the system. The function call node is integrated with microservices to support parameter passing and return value processing, enabling functional reuse between microservices and reducing the workload of repeated development. The data processing node is integrated with microservices to support operations such as data filtering, sorting, aggregation, and format conversion, ensuring data consistency and standardization, and improving the efficiency and accuracy of data processing. The event trigger node is integrated with microservices to respond to specific events in the microservice, such as timer events, user operation events, and data change events, enhancing the real-time and interactivity of the system.Significance: Through the visual logic editor, developers can quickly build complex logic processes, reducing the time for writing and debugging code; functions such as conditional routing and flow control, batch processing and retry mechanisms enable the system to flexibly respond to various complex business scenarios; through function reuse and data standardization, redundant code and errors in the system are reduced, and the stability and reliability of the system are improved; the event response mechanism enables the system to respond to user operations and data changes in real time, improving the user experience. Step S102 inserts code logic into the logic process in the graphical interface, allowing custom code snippets to be embedded in the graphical interface, so that developers can flexibly adjust the logic process according to specific needs; by inserting custom code, more complex and personalized logic processing can be achieved, enhancing the scalability of the system. Significance: The insertion of custom code enables the system to better meet the personalized needs of different users and improves the adaptability of the system; developers can directly insert code in the graphical interface, reducing the trouble of switching tools and environments, and improving development efficiency. Step S103 builds a graphical component library that includes various predefined microservice components for data collection, processing, storage, and display. Using predefined microservice components, developers can quickly build the system, reducing the workload of developing from scratch. Support for the import and export of user-defined components allows developers to customize components according to specific needs, enhancing the flexibility and scalability of the system. The integration of custom components with predefined components enables the system to better adapt to complex business scenarios. Significance: The construction of a predefined component library allows developers to quickly select and use appropriate components, reducing development time. Support for custom components allows the system to better adapt to the personalized needs of different users. Through component integration and standardization, the maintainability and scalability of the system are improved, promoting system standardization and normalization.

[0073] In summary, the interface and logic of the configuration software constructed in this embodiment not only improves development efficiency and enhances the flexibility and stability of the system, but also enhances the user experience and promotes the standardization and regularization of the system. This enables the configuration software to better cope with complex business scenarios and meet the needs of different users.

[0074] Example 3: Figure 3 As shown, based on Example 1, the process of automatically completing the deployment and startup of microservices according to the configuration file provided by the embodiment of the present invention includes the following steps:

[0075] S201: Select edge computing nodes based on factors such as the geographic location of the data source, network latency, and computing resource requirements. The nodes can be industrial social security, IoT devices, or dedicated edge servers. Before deployment, configure the edge computing nodes, including network settings, storage space allocation, and computing resource reservation.

[0076] S202: Design an automated deployment framework to automatically deploy and start microservices based on predefined configuration files. The configuration files contain deployment information for the microservices, including service names, dependencies, resource requirements, and startup parameters. Through the configuration files, the deployment framework automatically identifies and deploys the corresponding microservices.

[0077] S203: Distribute the packaged microservice image to each edge computing node through the image repository; the deployment framework automatically deploys the microservice image to the specified edge computing node according to the configuration file and starts the service.

[0078] The working principle and beneficial effects of the above technical solution are as follows: This embodiment first selects edge computing nodes based on factors such as the geographical location of the data source, network latency, and computing resource requirements. The nodes are industrial social security, Internet of Things devices, or dedicated edge servers. Before deployment, the edge computing nodes are configured, including network settings, storage space allocation, and computing resource reservation. Secondly, an automated deployment framework is designed to automatically complete the deployment and startup of microservices according to a predefined configuration file. The configuration file contains the deployment information of the microservice, including the service name, dependencies, resource requirements, and startup parameters. Through the configuration file, the deployment framework automatically identifies and deploys the corresponding microservice. Finally, the packaged microservice image is distributed to each edge computing node through the image repository. The deployment framework automatically deploys the microservice image to the designated edge computing node according to the configuration file and starts the service. Step S201 of the above solution selects the most suitable edge computing node based on the geographical location of the data source and network latency to ensure high efficiency and low latency of data processing. Before deployment, the edge computing node is configured with network settings, storage space allocation, and computing resource reservation to ensure that the node can meet the operating requirements of the microservice and avoid insufficient or wasted resources. Significance achieved: By rationally selecting and configuring edge computing nodes, microservices can be guaranteed to run in the optimal environment, improving the performance and response speed of the overall system; by optimizing resource allocation, unnecessary resource waste can be avoided and the operating cost of the system can be reduced. Step S202 designs an automated deployment framework. Through predefined configuration files, the automated deployment framework can automatically identify and deploy corresponding microservices, reduce manual intervention, and improve deployment efficiency; the configuration file contains detailed deployment information of the microservices, ensuring the standardization and consistency of the deployment process, facilitating management and maintenance. Significance achieved: The automated deployment framework significantly reduces deployment time and improves deployment efficiency, allowing the development team to focus more on the development of business logic; standardized deployment processes and configuration file management make system maintenance and upgrades easier and reduce the possibility of human error. Step S203: Image distribution and automatic deployment. Through the image repository, microservice images can be quickly and securely distributed to each edge computing node, ensuring a fast and efficient deployment process; the deployment framework automatically deploys the microservice image to the specified edge computing node according to the configuration file and starts the service, reducing the complexity and error rate of manual operations. Significance achieved: Rapid distribution and automatic deployment significantly shorten the time it takes for microservices to go online, enabling new features and updates to be put into use more quickly; the automated deployment and startup process reduces human errors, improves system reliability and stability, and ensures the continuous and stable operation of microservices.

[0079] In summary, the entire microservice deployment and startup process in this embodiment achieves a high degree of automation and standardization, significantly improving system performance, efficiency, and reliability. Specifically, by optimizing node selection and configuration, microservices are ensured to operate in the optimal environment, improving system performance. The automated deployment framework and rapid distribution mechanism significantly reduce deployment time and improve development and operation efficiency. The automated deployment and startup process reduces human error and improves system reliability and stability. This enables the microservice architecture to operate efficiently and stably in an edge computing environment, meeting the requirements of real-time data processing and low-latency response.

[0080] Example 4: Figure 4 As shown, based on Example 3, the process of automatically identifying and deploying corresponding microservices in the deployment framework provided by the embodiment of the present invention includes the following steps:

[0081] S2021: Before parsing the configuration file, the framework analyzes and recommends it. Based on historical deployment data and current environmental conditions, it automatically recommends resource allocation solutions, node selection strategies, and startup parameters. For example, based on historical network latency and node load data, it predicts the optimal edge computing node and automatically adjusts the resource allocation strategy.

[0082] S2022: The framework uses an adaptive dependency graph to build an initial dependency graph based on the configuration file. During the deployment process, the running status of each microservice is monitored in real time and dependencies are adjusted dynamically. If a microservice encounters an exception during startup, the framework automatically adjusts the dependency graph and re-plans the startup order.

[0083] S2023: During the resource demand assessment and allocation phase, the framework uses real-time monitoring data from edge computing nodes to detect node resource usage and dynamically adjust resource allocation strategies based on this data. When a node's CPU usage suddenly increases, the framework automatically migrates some microservices to other nodes with sufficient resources. Each microservice image generates a unique hash value when it is generated and is recorded on the blockchain. During the image pull process, the framework automatically verifies the image's hash value.

[0084] S2024: During the service startup and monitoring phase, when the number of requests for a microservice increases, the framework automatically calls computing resources to cope with high-concurrency requests, and automatically releases resources after the number of requests decreases to achieve elastic scaling; the framework monitors the running status of the microservice in real time, and automatically triggers operation and maintenance operations in an event-driven manner.

[0085] The working principle and beneficial effects of the above technical solution are as follows: First, in this embodiment, before parsing the configuration file, the framework analyzes and recommends the configuration file, and automatically recommends resource allocation solutions, node selection strategies, and startup parameters based on historical deployment data and current environmental conditions. For example, based on network latency and node load historical data, the optimal edge computing node is predicted, and the resource allocation strategy is automatically adjusted; secondly, the framework uses an adaptive dependency graph to build an initial dependency graph based on the configuration file, monitors the operating status of each microservice in real time during the deployment process, and dynamically adjusts the dependency relationship. If a microservice encounters an abnormality during the startup process, the framework automatically adjusts the dependency graph and replans the startup order; then, in the resource demand assessment and allocation stage, the framework Through the real-time monitoring data of the edge computing nodes, the resource usage of the nodes is perceived, and the resource allocation strategy is dynamically adjusted according to the real-time data; when the CPU usage of a node suddenly increases, the framework automatically migrates some microservices to other nodes with sufficient resources; each microservice image generates a unique hash value when it is generated and recorded on the blockchain; during the image pulling process, the framework automatically verifies the hash value of the image; finally, in the service startup and monitoring phase, when the number of requests for a certain microservice increases, the framework automatically calls computing resources to cope with high-concurrency requests, and automatically releases resources after the number of requests decreases to achieve elastic scaling; the framework monitors the running status of microservices in real time and automatically triggers operation and maintenance operations in an event-driven manner. Step S2021 of the above scheme is based on AI-based intelligent configuration recommendation. By analyzing historical deployment data and current environmental conditions, the AI model can automatically recommend the best resource allocation plan to ensure maximum resource utilization; based on network delay and node load historical data, the best edge computing node is predicted to reduce network delay and improve response speed; startup parameters are automatically adjusted to ensure that microservices are started in the best state, reducing startup time and resource consumption. Significance achieved: Through intelligent recommendations, manual intervention is reduced, and deployment efficiency and accuracy are improved; through dynamic resource allocation, resource waste is avoided, and the performance and stability of the overall system are improved; network latency and response time are reduced, and the user experience is enhanced. Step S2022 adaptive dependency graph construction and dynamic adjustment: real-time monitoring of the operating status of microservices during the deployment process, dynamic adjustment of dependencies, and ensuring system stability; when a microservice has an exception, the framework automatically adjusts the dependency graph, re-plans the startup sequence, and reduces the impact of the failure on the system. Significance achieved: By dynamically adjusting dependencies, the occurrence of system failures is reduced, and the stability and reliability of the system are improved; automated exception handling reduces manual intervention and reduces operation and maintenance costs; dynamic adjustment of dependencies enables the system to better adapt to different deployment environments and requirements.Step S2023: Resource awareness and dynamic scheduling: This involves real-time monitoring of edge computing node resource usage to detect node load. Resource allocation strategies are dynamically adjusted based on real-time data to avoid resource bottlenecks and ensure efficient resource utilization. Blockchain technology is leveraged to ensure image integrity and security, preventing man-in-the-middle attacks and image tampering. The implications of this approach are: Dynamic scheduling avoids resource bottlenecks, improves resource utilization and system performance; blockchain technology ensures image security and reduces security risks; and real-time monitoring and dynamic scheduling ensure stable system operation under high load. Step S2024: Service startup and elastic scaling based on the serverless architecture dynamically allocates computing resources based on microservice request volume to cope with high concurrency and automatically releases resources when the number of requests decreases. An event-driven approach monitors the operational status of microservices in real time, automatically triggering operations and maintenance to ensure system stability and reliability. The implications of this approach are: Elastic scaling ensures system responsiveness under high concurrency; dynamic resource allocation based on actual demand avoids resource waste and reduces operating costs; and real-time monitoring and automated operations and maintenance reduce system failures and improve system stability and reliability.

[0086] In summary, the automated deployment framework of this embodiment offers significant advantages in improving deployment efficiency, optimizing resource utilization, enhancing system security, increasing system response speed, and reducing operation and maintenance costs. This not only enhances the overall performance and stability of the system but also provides a better user experience, bringing a new technological experience to microservice management in edge computing environments.

[0087] Example 5: Figure 5 As shown, based on Example 4, the process of the resource demand assessment and allocation stage provided by this embodiment of the present invention includes the following steps:

[0088] S20231: The framework integrates multiple sensors to collect multi-dimensional resource data from edge computing nodes in real time, including CPU usage, memory usage, network bandwidth, and storage I / O. Through high-frequency sampling and real-time analysis, it forms a dynamic resource usage map and predicts the resource demand trend of nodes over a period of time.

[0089] S20232: Based on real-time monitoring of multi-dimensional resource data and resource demand trends, the framework dynamically adjusts resource allocation strategies. When a node's CPU usage exceeds a preset threshold, the framework automatically identifies and migrates some microservices to other nodes. By introducing an intelligent load balancing algorithm, the framework dynamically distributes microservice requests across multiple nodes.

[0090] The expression of the intelligent load balancing algorithm is:

[0091]

[0092] Where LB(t) represents the load balancing decision result at time t, i represents the node index, Represents the set of all nodes, j represents the resource dimension index, Represents the set of all resource dimensions, R i,j (t) represents the utilization rate of node i in resource dimension j at time t, represents the global average utilization rate of resource dimension j, w j represents the weight of resource dimension j, α j represents the adjustment coefficient of resource dimension j, Di(t) represents the delay of node i at time t, represents the global average delay, β represents the weight of the delay, γ represents the adjustment coefficient of the delay, and C i (t) represents the CPU usage of node i at time t, represents the global average CPU usage, δ represents the weight of the CPU usage, and ∈ represents the adjustment coefficient of the CPU usage. This expression dynamically adjusts the load balancing strategy by comprehensively considering the usage, latency, and CPU usage of multiple resource dimensions to ensure efficient system operation and optimal resource allocation.

[0093] S20233: The generated hash value is recorded on the blockchain, forming an unalterable image identity. The framework automatically obtains the image's hash value from the blockchain and compares it with the locally calculated hash value. If the hash values do not match, the framework will refuse to pull the image and trigger a security alert.

[0094] The working principle and beneficial effects of the above technical solution are as follows: First, in this embodiment, the framework integrates multiple sensors to collect multi-dimensional resource data of edge computing nodes in real time, including CPU usage, memory usage, network bandwidth and storage I / O, etc., and forms a dynamic resource usage map through high-frequency sampling and real-time analysis; predicts the resource demand trend of nodes in the future; secondly, based on the results of real-time monitoring of multi-dimensional resource data and resource demand trends, the framework dynamically adjusts the resource allocation strategy; when the CPU usage of a node exceeds the preset threshold, the framework automatically identifies and migrates some microservices to other nodes; by introducing an intelligent load balancing algorithm, the framework dynamically distributes microservice requests among multiple nodes; finally, the generated hash value is recorded on the blockchain to form an unalterable image identity; the framework automatically obtains the hash value of the image from the blockchain and compares it with the locally calculated hash value; if the hash value does not match, the framework will refuse to pull the image and trigger a security alarm. Step S20231 of the above solution integrates multiple sensors to collect multi-dimensional resource data such as CPU usage, memory usage, network bandwidth, and storage I / O of edge computing nodes in real time, ensuring the comprehensiveness and accuracy of the data. Through high-frequency sampling and real-time analysis, a dynamic resource usage map is formed, which can quickly capture subtle changes in resource usage and provide a data basis for resource demand forecasting. Based on historical data and real-time data, the resource demand trend of nodes in the future is predicted, providing a basis for dynamic adjustment of resource allocation strategies. The significance achieved: Through real-time monitoring and trend forecasting, resource demand peaks can be predicted in advance, avoiding resource shortages or waste and improving resource utilization. The dynamic resource map can promptly identify resource bottlenecks, take measures in advance, and enhance the stability and reliability of the system. Step S20232 dynamically adjusts the resource allocation strategy. Based on the results of real-time monitoring of multi-dimensional resource data and resource demand trends, the framework can dynamically adjust the resource allocation strategy to ensure the rational distribution of resources among various nodes. By introducing an intelligent load balancing algorithm, the framework can dynamically allocate microservice requests among multiple nodes to ensure load balancing of each node and avoid single-point overload. When the CPU usage of a node exceeds the preset threshold, the framework automatically identifies and migrates some microservices to other nodes to avoid node overload and ensure service continuity. Significance achieved: By dynamically adjusting the resource allocation strategy, resource configuration can be optimized according to actual needs, improving resource utilization efficiency. Through intelligent load balancing and automatic migration of microservices, service stability and continuity can be guaranteed, improving user experience.In step S20233, blockchain recording and security verification are performed. The generated hash value is recorded on the blockchain, forming an unalterable image identity, ensuring the image's uniqueness and security. The framework automatically obtains the image's hash value from the blockchain and compares it with the locally calculated hash value to ensure the image's integrity and security. If the hash values do not match, the framework will refuse to pull the image and trigger a security alert to promptly identify and address potential security threats. Significance: By comparing blockchain records and hash values, we can effectively prevent image tampering or malicious replacement, enhancing data security. The security alert mechanism can promptly identify and address potential security threats, ensuring system security and stability.

[0095] In summary, the steps of this embodiment jointly realize intelligent evaluation and allocation of resource requirements, which not only improves resource utilization and system stability, but also enhances data and system security.

[0096] Example 6: Figure 6 As shown, based on Example 5, the process of dynamically adjusting the resource allocation strategy of the framework provided by the embodiment of the present invention includes the following steps:

[0097] S202321: Dynamically adjust thresholds based on historical data and real-time fluctuations. When a node's CPU usage exceeds the dynamic threshold, the framework identifies the node as a high-load node and triggers an early warning mechanism. The decision engine makes microservice migration decisions.

[0098] S202322: Using multi-dimensional resource data collected in real time, the framework predicts the load change trend of each node over a period of time. By simulating the migration process, the adaptability of different nodes is evaluated, and the node with the lowest load and the best resource utilization is selected as the migration target.

[0099] S202323: By calculating the Nash equilibrium point, the framework dynamically adjusts the migration strategy between multiple nodes. After the migration decision is made, the framework automatically executes the microservice migration operation. After the migration is completed, the framework records the migration results and continuously optimizes the migration strategy.

[0100] The working principle and beneficial effects of the above technical solution are as follows: This embodiment first dynamically adjusts the threshold based on historical data and real-time fluctuations. When the CPU usage of a node exceeds the dynamic threshold, the framework identifies the node as a high-load node and triggers an early warning mechanism; the decision engine makes microservice migration decisions; secondly, using multi-dimensional resource data collected in real time, the framework predicts the load change trend of each node in the future, evaluates the adaptability of different nodes by simulating the migration process, and selects the node with the lowest load and the best resource utilization as the migration target; finally, by calculating the Nash equilibrium point, the framework dynamically adjusts the migration strategy between multiple nodes; after the migration decision is completed, the framework automatically executes the microservice migration operation; after the migration is completed, the framework records the migration effect and continuously optimizes the migration strategy. Step S202321 of the above solution dynamically adjusts the threshold and early warning mechanism, dynamically adjusts the threshold based on historical data and real-time fluctuations, so that the threshold is closer to the actual load situation, improving the system's adaptability; when the CPU usage of a node exceeds the dynamic threshold, the framework can promptly identify the high-load node and trigger an early warning to prevent the system from crashing due to excessive load. Significance achieved: By dynamically adjusting the threshold and early warning mechanism, the system can take timely measures when the load is too high to avoid system crashes or performance degradation caused by resource overload; dynamic threshold adjustment enables the system to better adapt to load fluctuations, improving the flexibility and robustness of the system. Step S202322 Resource data prediction and migration decision-making, using multi-dimensional resource data collected in real time, the framework can predict the load change trend of each node in the future period, and provide data support for migration decisions; by simulating the migration process, the framework can evaluate the adaptability of different nodes, select the node with the lowest load and the best resource utilization as the migration target, and ensure the optimal system performance after migration. Significance achieved: Through load prediction and simulation evaluation, the system can migrate microservices to the most suitable node, maximize resource utilization, and reduce resource waste; selecting the node with the lowest load and the best resource utilization as the migration target can significantly improve the overall performance and response speed of the system. Step S202323: Nash equilibrium point calculation and automatic migration. By calculating the Nash equilibrium point, the framework can dynamically adjust the migration strategy between multiple nodes to ensure the fairness and optimality of resource allocation. After the migration decision is completed, the framework automatically executes the microservice migration operation, reducing manual intervention and improving migration efficiency. The framework records the migration results and continuously optimizes the migration strategy, allowing the system to continuously improve and enhance long-term stability. Significance achieved: Automatic execution of migration operations reduces manual intervention, improves migration efficiency, and reduces operation and maintenance costs. By recording migration results and continuously optimizing migration strategies, the system can continuously improve and enhance long-term stability and performance. Nash equilibrium point calculation ensures fair distribution of resources between multiple nodes, avoiding the situation where some nodes are overloaded while others are idle.

[0101] In summary, the framework of this embodiment can dynamically adjust resource allocation strategies, achieving the following benefits: Through dynamic threshold adjustment, load prediction, and automatic migration, the system can maintain stability during load fluctuations, optimize resource utilization, and improve overall performance. Automated migration and optimization processes reduce manual intervention and lower operation and maintenance costs. By recording and analyzing migration results, the system can continuously improve, enhancing long-term stability and performance. This makes the microservice architecture more efficient, stable, and reliable in edge computing environments.

[0102] Example 7: Figure 7 As shown, based on Example 6, the process of selecting the node with the lowest load and the best resource utilization as the migration target provided by the embodiment of the present invention includes the following steps:

[0103] S2023221: Automatically generates multiple migration scenarios based on real-time load data and resource status, generating diverse migration combinations and paths to cover different load and resource conditions. Optimizes the use of resources such as bandwidth, CPU, and memory through linear programming and integer programming.

[0104] S2023222: Leverage a virtualized migration engine to perform migration operations in a virtual environment, simulating resource changes and performance indicators in a real environment. Simultaneously simulate multiple migration scenarios, accelerating the simulation process through distributed computing and parallel processing.

[0105] S2023223: Introduce a dynamic load balancing indicator to evaluate the load distribution of each node after migration in real time; adaptive weighted load balancing to balance the load of each node; calculate the load difference coefficient to quantify the load difference between each node, and use the load difference coefficient to evaluate the uniformity of the load distribution after migration.

[0106] The working principle and beneficial effects of the above technical solution are as follows: First, this embodiment automatically generates multiple migration scenarios based on real-time load data and resource status, generates diversified migration combinations and paths, and covers different load and resource conditions; optimizes the use of resources such as bandwidth, CPU and memory through linear programming and integer programming; secondly, utilizes the virtualization migration engine to perform migration operations in a virtual environment, simulating resource changes and performance indicators in a real environment; simulates multiple migration scenarios at the same time, and accelerates the simulation process through distributed computing and parallel processing; finally, introduces a dynamic load balancing index to evaluate the load distribution of each node after migration in real time; adaptive weighted load balancing, load balancing of each node; calculates the load difference coefficient, quantifies the load difference between each node, and evaluates the uniformity of the load distribution after migration through the load difference coefficient. Step S2023221 of the above solution is migration scenario generation and resource optimization. By automatically generating multiple migration scenarios, the system can cover different load and resource conditions and ensure that the optimal migration path can be found in various situations; utilizes linear programming and integer programming techniques to optimize the use of resources such as bandwidth, CPU and memory, ensuring efficient resource utilization during the migration process and avoiding resource waste and bottlenecks. Significance: Through diversified migration combinations and resource optimization, the system can find the optimal migration plan in a short time and improve migration efficiency; resource optimization ensures load balancing and efficient resource utilization of each node during the migration process, reduces the risk of system overload and resource bottlenecks, and enhances system stability. Step S2023222 Virtualization migration engine and simulation execution, using the virtualization migration engine to perform migration operations in a virtual environment, can simulate resource changes and performance indicators in a real environment to ensure the feasibility and effectiveness of the migration plan; through distributed computing and parallel processing, the simulation process of multiple migration scenarios is accelerated, the simulation time is shortened, and the decision-making efficiency is improved. Significance: Through simulation execution in a virtual environment, the system can verify the feasibility and effectiveness of the migration plan before the actual migration, reducing the risk in the actual migration process; the accelerated simulation process enables the system to generate and verify the migration plan more quickly, improving decision-making efficiency and response speed. Step S2023223 introduces the dynamic load balancing degree and load variation coefficient, which allows for real-time evaluation of the load distribution of each node after migration, ensuring load balancing and avoiding single-point overload. Adaptive weighted load balancing allows the system to dynamically adjust the load balancing strategy based on real-time load conditions to ensure load balancing across nodes. The load variation coefficient is calculated to quantify the load differences between nodes, assess the uniformity of the load distribution after migration, and optimize the load balancing strategy. Significance: Through real-time load evaluation and adaptive load balancing, the system can optimize the load distribution of each node, ensuring load balancing and improving overall system performance. Quantitative evaluation of the load variation coefficient helps the system identify load imbalances, optimize load balancing strategies, improve resource utilization, and reduce resource waste.

[0107] In summary, this embodiment achieves load balancing, resource optimization, and performance improvement during the migration process, ensuring the feasibility and effectiveness of the migration solution. This not only improves migration efficiency and system stability, but also optimizes resource utilization and load distribution, providing a strong guarantee for the continued efficient operation of the system.

[0108] Example 8: Figure 8 As shown, based on Example 6, the process of calculating the Nash equilibrium point provided by the embodiment of the present invention includes the following steps:

[0109] S2023231: In the resource allocation scenario, participants are nodes or microservices. Each participant can choose different resource allocation strategies or migration paths. For each participant, a benefit function is defined to represent the benefits or costs of each participant under different strategy combinations. The benefit function is a mathematical expression of indicators such as resource utilization, load balancing, and migration cost. The benefit function can be expressed as a weighted sum of the indicators.

[0110] S2023232: For each participant, calculate the payoff of each strategy chosen by that participant when other participants choose a specific strategy, and find the optimal strategy. Among all participants, find a strategy combination such that the strategy chosen by each participant is optimal under this combination, that is, no participant can achieve a better outcome by unilaterally changing its strategy.

[0111] S2023233: Through iterative calculation, the strategy of each participant is gradually adjusted until a stable strategy combination, namely the Nash equilibrium point, is found.

[0112] The working principle and beneficial effects of the above technical solution are as follows: First, in the resource allocation scenario, the participants are nodes or microservices, and the strategies that each participant can choose are different resource allocation schemes or migration paths. For each participant, a benefit function is defined, which represents the benefits or costs of each participant under different strategy combinations. The benefit function is a mathematical expression of indicators such as resource utilization, load balancing, and migration cost. Secondly, for each participant, the benefits of each strategy selected by the participant are calculated when other participants select a specific strategy, and the optimal strategy is found. Among all participants, a strategy combination is found such that the strategy selected by each participant under this combination is optimal, that is, no participant can obtain a better result by unilaterally changing its strategy. Finally, through iterative calculation, the strategy of each participant is gradually adjusted until a stable strategy combination is found, namely the Nash equilibrium point. Step S2023231 of the above solution defines the benefit function. By defining the benefit function, the complex decision problem of resource allocation is converted into a mathematical expression, so that the benefits of different strategies can be quantified and compared. The benefit function usually contains multiple indicators (such as resource utilization, load balancing, migration cost, etc.), which can comprehensively evaluate the effectiveness of different strategies. Significance: The payoff function provides participants with a clear basis for decision-making, helping them select the optimal resource allocation solution from among numerous strategies. By over-quantifying the payoff, participants can clearly define their optimization goals and thus pursue maximum benefits during the resource allocation process. Step S2023232 calculates the optimal strategy. By calculating each participant's payoff under different strategy combinations, participants can compare the pros and cons of different strategies and select the optimal one. Finding a strategy combination among all participants that ensures that each participant's strategy is optimal helps achieve a global optimal solution. Significance: Finding a strategy combination where no participant can achieve a better outcome by unilaterally changing their strategy indicates that the system has reached a Nash equilibrium, the optimal and stable state for resource allocation. The existence of a Nash equilibrium indicates that the system has reached a stable state in resource allocation, reducing resource conflicts and waste. Step S2023233 performs iterative calculations. Through iterative calculations, each participant's strategy is gradually adjusted, allowing the system to gradually approach the optimal strategy combination. Iterative calculations can help the system converge to a stable strategy combination, known as a Nash equilibrium, after multiple adjustments. Significance: Iterative computing allows the system to dynamically adjust strategies during resource allocation to adapt to changing environments and demands. Through continuous iteration, the system can maintain the optimal state of resource allocation in the long term, improving resource utilization efficiency and overall system performance.

[0113] In summary, the Nash equilibrium calculation process in this embodiment not only quantifies and optimizes resource allocation but also helps the system achieve a stable and optimal resource allocation state in a dynamic environment. This not only improves resource utilization efficiency but also reduces resource conflicts and waste, ensuring the long-term stable operation of the system.

[0114] Example 9: Figure 9 As shown, based on Example 3, the process of automatically deploying a microservice image to a specified edge computing node provided by the embodiment of the present invention includes the following steps:

[0115] S2031: The deployment framework parses the configuration file and extracts the deployment information of the microservice. The parsing process includes verifying the integrity and correctness of the configuration file. The deployment framework checks the resource status of the target edge computing node. Based on the resource requirements in the configuration file, the deployment framework reserves the corresponding resources on the target node.

[0116] S2032: The deployment framework pulls the microservice image from the image repository based on the image information in the configuration file. After the pull is complete, the deployment framework verifies the image.

[0117] S2033: The deployment framework deploys the verified microservice image to the designated edge computing node. The deployment process includes decompressing the image, mounting the file system, and injecting the configuration file. After the deployment is completed, the deployment framework executes the microservice startup command according to the startup parameters in the configuration file.

[0118] The working principle and beneficial effects of the above technical solution are as follows: In this embodiment, the deployment framework first parses the configuration file and extracts the deployment information of the microservice. The parsing process includes verifying the integrity and correctness of the configuration file; the deployment framework checks the resource status of the target edge computing node; according to the resource requirements in the configuration file, the deployment framework reserves corresponding resources on the target node; secondly, the deployment framework pulls the microservice image from the image repository according to the image information in the configuration file; after the pulling is completed, the deployment framework will verify the image; finally, the deployment framework deploys the verified microservice image to the specified edge computing node. The deployment process includes decompression of the image, mounting of the file system, and injection of the configuration file, etc.; after the deployment is completed, the deployment framework executes the startup command of the microservice according to the startup parameters in the configuration file. In step S2031 of the above solution, configuration file parsing and resource reservation are performed. By parsing the configuration file, the deployment framework can automatically obtain detailed deployment information for the microservice, ensuring the automation and standardization of the deployment process. The framework also checks the resource status of the target edge computing node to ensure that the node has sufficient resources to run the microservice, avoiding deployment failures due to insufficient resources. Based on the resource requirements in the configuration file, the framework reserves corresponding resources on the target node to ensure that the microservice has the required resources upon startup, avoiding resource competition and performance degradation. The significance achieved is that configuration file parsing automates and standardizes the deployment process, reducing manual intervention and improving deployment efficiency and consistency. Resource status checking and reservation ensure the rational allocation and utilization of resources, avoiding resource waste and performance bottlenecks, and improving system stability and reliability. Step S2032, image pulling and verification, pulls the microservice image from the image repository, ensuring the image's freshness and integrity, supporting breakpoint resuming and multi-threaded downloading, and improving pull efficiency. The pulled image is verified to ensure its integrity and security, including checksum calculation, signature verification, and vulnerability scanning, to prevent the deployment of malicious images. Significance achieved: Through image pulling and verification, centralized management and security of images are achieved, ensuring the reliability and security of microservices; through efficient image pulling and verification mechanisms, deployment time is reduced, deployment efficiency is improved, and rapid launch of microservices is guaranteed. Step S2033: Image deployment and service startup, deploying the verified microservice image to the designated edge computing node, including image decompression, file system mounting, and configuration file injection, to ensure the correct deployment of the image; executing the startup command of the microservice according to the startup parameters in the configuration file to ensure that the service can start and run correctly. Significance achieved: Through image deployment and automatic startup, automated deployment and startup of microservices are achieved, reducing manual operations and improving deployment efficiency and consistency; through the automated deployment and startup process, the reliability and stability of microservices are guaranteed, human errors and failures are reduced, and the overall performance and availability of the system are improved.

[0119] In summary, the automated deployment and startup process in this embodiment achieves automation, standardization, and efficiency for microservices, ensuring the rational allocation and utilization of resources and improving system stability and reliability. Furthermore, through image management and verification, the reliability and security of microservices are ensured, deployment time and human error are reduced, and overall deployment efficiency and consistency are improved.

[0120] Example 10: Figure 10 As shown, based on Example 1, the process of remote configuration and management provided by the embodiment of the present invention includes the following steps:

[0121] S301: Through a graphical interface, users can view the operating status of edge computing nodes in real time, including key indicators such as CPU usage, memory usage, network traffic, and disk usage. Visualization tools are used to display the operating status of nodes to users.

[0122] S302: Remotely adjust the configuration parameters of the edge computing node through a graphical interface; support remote upload and download of configuration files;

[0123] S303: Remotely execute node management operations such as restarting nodes, stopping services, and updating software through a graphical interface; support remote execution of automated scripts, allowing users to implement batch management of nodes by writing scripts; and automatically collect operation logs of edge computing nodes.

[0124] The working principle and beneficial effects of the above technical solution are as follows: First, in this embodiment, through a graphical interface, users can view the operating status of edge computing nodes in real time, including key indicators such as CPU usage, memory usage, network traffic and disk usage; use visualization tools to display the operating status of the node to the user; secondly, through the graphical interface, remotely adjust the configuration parameters of the edge computing node; support remote upload and download of configuration files; finally, through the graphical interface, remotely execute node management operations, such as restarting the node, stopping the service and updating the software; support remote execution of automated scripts, and users can implement batch management of nodes by writing scripts; automatically collect the operation logs of edge computing nodes. This embodiment realizes real-time monitoring, remote configuration and management of edge computing nodes, as well as log analysis and troubleshooting through graphical interface monitoring and remote management. Through these functions, users can promptly discover abnormal conditions of nodes, flexibly adjust the configuration of nodes, conveniently operate and manage nodes, quickly locate and solve faults, improve the stability and reliability of the system, reduce maintenance costs and time, and improve overall management efficiency and consistency.

[0125] Obviously, those skilled in the art can make various changes and modifications to the present invention without departing from the spirit and scope of the present invention. Thus, if these modifications and variations of the present invention fall within the scope of the present invention's equivalent technologies, the present invention is also intended to include these modifications and variations.

Claims

1. A graphical construction and edge deployment method for microservice architecture using configuration software development, characterized in that: The following steps are involved: Use a graphical interface to build a graphical component library and construct configuration software; Combined with the edge computing node deployment strategy, the microservices of the configuration software are deployed close to the data source; Edge deployment framework, which automatically deploys and starts microservices based on configuration files; Monitor the status of edge computing nodes through a graphical interface and perform remote configuration and management; The process of automatically identifying and deploying the corresponding microservices by the deployment framework includes the following steps: Before parsing the configuration file, the framework analyzes and recommends it, automatically recommending resource allocation plans, node selection strategies, and startup parameters based on historical deployment data and current environmental conditions. The framework is built using an adaptive dependency graph. It builds an initial dependency graph based on the configuration file, monitors the running status of each microservice in real time during the deployment process, and dynamically adjusts the dependency relationships. During the resource demand assessment and allocation phase, the framework uses real-time monitoring data from edge computing nodes to detect resource usage and dynamically adjust resource allocation strategies based on this real-time data. Each microservice image generates a unique hash value when it is generated and is recorded on the blockchain. During the image pull process, the framework automatically verifies the image hash value; During the service startup and monitoring phase, when the number of requests to a microservice increases, the framework automatically calls computing resources to handle high-concurrency requests, and automatically releases resources when the number of requests decreases, achieving elastic scaling. The framework monitors the running status of microservices in real time and automatically triggers operation and maintenance operations in an event-driven manner; If a microservice encounters an exception during startup, the framework automatically adjusts the dependency graph and re-plans the startup order; The resource needs assessment and allocation phase includes the following steps: The framework integrates multiple sensors to collect multi-dimensional resource data of edge computing nodes in real time. Through high-frequency sampling and real-time analysis, it forms a dynamic resource usage map and predicts the resource demand trend of nodes in the future. Weight, multi-dimensional resource data including CPU usage, memory usage, network bandwidth and storage I / O; Based on the results of real-time monitoring of multi-dimensional resource data and resource demand trends, the framework dynamically adjusts resource allocation strategies; By introducing an intelligent load balancing algorithm, the framework dynamically distributes microservice requests among multiple nodes; The generated hash value is recorded on the blockchain, forming an unalterable image identity. The framework automatically obtains the hash value of the image from the blockchain and compares it with the locally calculated hash value. If the hash values do not match, the framework will refuse to pull the image and trigger a security alert.

2. The graphical construction and edge deployment method for developing microservice architecture using configuration software according to claim 1, characterized in that: The process of dynamically adjusting resource allocation strategies in the framework includes the following steps: The threshold is dynamically adjusted based on historical data and real-time fluctuations. When the CPU usage of a node exceeds the dynamic threshold, the framework identifies the node as a high-load node and triggers an early warning mechanism. The decision engine makes microservice migration decisions. Using multi-dimensional resource data collected in real time, the framework predicts the load change trend of each node over the next period of time. By simulating the migration process, it evaluates the adaptability of different nodes and selects the node with the lowest load and the best resource utilization as the migration target. By calculating Nash equilibrium points, the framework dynamically adjusts migration strategies between multiple nodes; After the migration decision is made, the framework automatically performs the microservice migration operation; After the migration is completed, the framework records the migration results and continuously optimizes the migration strategy.

3. The graphical construction and edge deployment method for developing microservice architecture using configuration software according to claim 2, characterized in that: The process of selecting the node with the lowest load and the best resource utilization as the migration target includes the following steps: Based on real-time load data and resource status, it automatically generates multiple migration scenarios, diverse migration combinations, and paths to cover different load and resource conditions. It also optimizes the use of bandwidth, CPU, and memory resources through linear programming and integer programming. Utilize the virtualization migration engine to perform migration operations in a virtual environment, simulating resource changes and performance indicators in a real environment. Simultaneously simulate multiple migration scenarios, accelerating the simulation process through distributed computing and parallel processing. Introducing dynamic load balancing indicators to evaluate the load distribution of each node after migration in real time; adaptive weighted load balancing to ensure load balancing of each node.

4. The graphical construction and edge deployment method for developing microservice architecture using configuration software according to claim 3, characterized in that: The load difference coefficient is calculated to quantify the load difference between nodes. The load difference coefficient is used to evaluate the uniformity of load distribution after migration.

5. The graphical construction and edge deployment method for developing microservice architecture using configuration software according to claim 3, characterized in that: The process of calculating the Nash equilibrium point includes the following steps: In the resource allocation scenario, the participants are individual nodes or microservices, and the strategy selected by each participant is a different resource allocation scheme or migration path; For each participant, calculate the benefits of each strategy when other participants choose a specific strategy, and find the optimal strategy; among all participants, find a strategy combination such that the strategy selected by each participant under this combination is the optimal one; Through iterative calculation, the strategy of each participant is gradually adjusted until a stable strategy combination, namely the Nash equilibrium point, is found.

6. The graphical construction and edge deployment method for developing microservice architecture using configuration software according to claim 5, characterized in that: For each participant, a profit function is defined, which represents the profit or cost of each participant under different strategy combinations.

7. The graphical construction and edge deployment method for developing microservice architecture using configuration software according to claim 1, characterized in that: The process of automatically deploying microservice images to specified edge computing nodes in conjunction with edge computing node deployment strategies includes the following steps: The deployment framework parses the configuration file and extracts the deployment information of the microservice. The parsing process includes verifying the integrity and correctness of the configuration file. The deployment framework checks the resource status of the target edge computing node. Based on the resource requirements in the configuration file, the deployment framework reserves the corresponding resources on the target node. The deployment framework pulls the microservice image from the image repository based on the image information in the configuration file; After the pull is complete, the deployment framework will verify the image; The deployment framework deploys the verified microservice image to the designated edge computing node. The deployment process includes image decompression, file system mounting, and configuration file injection. After the deployment is complete, the deployment framework executes the startup command of the microservice according to the startup parameters in the configuration file.

Images