Graphical construction and edge deployment method developed by configuration software for micro-service architecture

Abstract

The invention provides a graphical construction and edge deployment method for configuration software development for a micro-service architecture, which comprises the following steps of: constructing an interface and logic of configuration software by adopting a graphical interface through operations such as drag-drop, connection and the like; establishing a graphical component library comprising a plurality of predefined micro-service components, wherein the predefined micro-service components comprise data acquisition, processing, storage, display and the like; the predefined micro-service component supports conversion of the graphical component into an executable micro-service code, and configuration software is constructed; deploying the micro-service of the configuration software at a position close to a data source in combination with an edge computing node deployment strategy; the edge deployment framework automatically completes deployment and starting of the micro-service according to the configuration file and supports automatic deployment, monitoring and upgrading of the micro-service; the states of the edge computing nodes are monitored through a graphical interface, and remote configuration and management are carried out; and performing real-time viewing, log analysis, troubleshooting and the like on the node state. The development efficiency is improved.

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 intelligent manufacturing, the demand and complexity of industrial software are 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. In order to improve development efficiency and system flexibility, microservice architecture has gradually become the mainstream choice for industrial software development. Microservice architecture greatly improves the maintainability and scalability of the system by splitting complex systems into multiple independent services, each of which can be independently developed, deployed, and expanded. The traditional microservice development method still requires developers to have high programming skills, which to a certain extent limits the rapid development and deployment of industrial software. In order to solve this problem, graphical construction technology came into being; through a graphical interface, developers can In addition, with the rise of edge computing technology, more and more industrial applications need to deploy computing resources close to the data source to reduce latency and improve response speed.

[0003] Prior art 1, application number: CN 202410293026.3 discloses a method, device, equipment 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 difficulties. 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, and it is 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 to form a single Jar package; storing the formed multiple single Jar packages in a single warehouse; responding to external service requests, determining the required microservice type and quantity; calling the single Jar package corresponding to the microservice from the single warehouse through the base application for combination, and merging the configuration of the microservice 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 codes, 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 configuration of multiple microservices into a configuration file, as the number of microservices increases, the complexity of the configuration file will also increase significantly, which may make the management and maintenance of the configuration file difficult, and prone to configuration errors or conflicts.

[0005] Prior art 3, application number: CN202310901638.1 discloses a method for modeling industrial components in the OT domain based on a microservice architecture and generating codes therefor. SpringCloudAlibaba is used as a specific implementation of the microservice architecture. The message queue component and the 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: OT domain industrial software component modeling; Step 2: Microservice program code generation; Step 3: Microservice program operation. Although a set of efficient and flexible general models of OT domain industrial software components is proposed by combining the microservice technology of the IT domain with the IEC61499 standard of the OT domain, and using the code generator, the route from the OT domain model to the IT domain program implementation is opened up, forming an efficient and low-learning cost development environment. However, in actual applications, the mapping relationship between the industrial software component model of the OT domain and the microservice program of the IT domain may be very complex; information loss or inconsistency may occur during the model conversion process, making it difficult for the generated code to fully meet expectations.

[0007] At present, the existing technologies 1, 2 and 3 have insufficient flexibility and adaptability, and the industrial software performance and reliability are poor. Therefore, the present invention provides a graphical construction and edge deployment method for configuration software development of 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; 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 microservices according to the configuration file;

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

[0012] Optionally, the process of automatically identifying and deploying the corresponding microservices by the deployment framework includes the following steps:

[0013] Before parsing the configuration file, the framework analyzes and recommends the configuration file, automatically recommending resource allocation solutions, 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 relationship.

[0015] In the resource demand assessment and allocation stage, the framework perceives the resource usage of the nodes through the real-time monitoring data of the edge computing nodes, and dynamically adjusts the resource allocation strategy according to the real-time data; 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;

[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 the startup process, the framework automatically adjusts the dependency graph and re-plans the startup order.

[0018] Optionally, the process of resource requirements 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, and forms a dynamic resource usage map through high-frequency sampling and real-time analysis; it also predicts the resource demand trend of nodes in the future.

[0020] 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 intelligent load balancing algorithms, the framework dynamically allocates microservice requests among multiple nodes;

[0021] 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 values ​​do not match, the framework will refuse to pull the image and trigger a security alert.

[0022] Optionally, the process of the framework dynamically adjusting the resource allocation strategy includes the following steps:

[0023] The threshold is adjusted dynamically 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 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;

[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 effect and continuously optimizes the migration strategy.

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

[0027] Automatically generate multiple migration scenarios based on real-time load data and resource status, generate diverse migration combinations and paths to cover different load and resource conditions; optimize the use of bandwidth, CPU and memory resources through linear programming and integer programming;

[0028] Use the virtualization migration engine to perform migration operations in a virtual environment to simulate resource changes and performance indicators in a real environment; simulate multiple migration scenarios at the same time, and accelerate the simulation process through distributed computing and parallel processing;

[0029] Introduce dynamic load balancing indicators to evaluate the load distribution of each node after migration in real time; adaptive weighted load balancing to balance the load 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 chosen by the participant when other participants choose a specific strategy, and find the optimal strategy; among all participants, find a strategy combination so that the strategy chosen by each participant under this combination is the best;

[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 the 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. According to 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 image decompression, file system mounting, and configuration file injection. 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 the graphical interface, developers can intuitively construct the interface and logic of the configuration software, avoiding the tedious code writing process and significantly improving the development efficiency; the graphical component library contains a variety of predefined microservice components, such as data acquisition, processing, storage and display, etc., and developers can quickly assemble into a complete software system without in-depth understanding of the underlying technical details, which reduces the development threshold; the graphical programming environment supports the conversion of graphical components into executable microservice codes, and developers can quickly implement the development and deployment of business logic through simple drag and drop and configuration, which enhances 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 microservices of the configuration software close to the data source, reducing the delay of data transmission and improving the response speed of the system; the edge deployment framework supports the automatic deployment, monitoring and upgrading of microservices to ensure the stability and maintainability of the system; the automatic deployment and monitoring functions can quickly restore services when the node fails, improving the reliability of the system; through the edge deployment framework, the automatic operation and maintenance of microservices is realized, reducing manual intervention and reducing the operation and maintenance costs. Significance: By reducing the delay of data transmission, the response speed of the system is improved, and the user experience is improved; the automatic deployment, monitoring and upgrading functions ensure the stable operation of the system and reduce the business interruption caused by node failure. Graphical monitoring and management, through the graphical interface, the administrator can monitor the status of the edge computing node in real time, perform remote configuration and management, and improve the operation and maintenance efficiency; the graphical interface supports real-time viewing of node status, log analysis and troubleshooting, helping administrators to quickly locate and solve problems and reduce the time for troubleshooting; through the graphical interface, administrators can easily perform remote operations without going to the site in person, improving the convenience and efficiency of management. Significance: Graphical monitoring and management tools enable operation and maintenance personnel to quickly locate and solve problems, improve operation and maintenance efficiency, and reduce system downtime; remote configuration and management functions reduce the need for on-site maintenance and reduce operation and maintenance costs.

[0041] Other features and advantages of the present invention will be described in the following description, and partly become apparent from the description, or 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 of automatically completing the deployment and startup of microservices according to the configuration file in Example 3 of the present invention;

[0047] Figure 4 A process diagram of automatically identifying and deploying corresponding microservices in the deployment framework in Embodiment 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 A process diagram of dynamically adjusting resource allocation strategies of the framework in Embodiment 6 of the present invention;

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

[0051] Figure 8 A process diagram of calculating a Nash equilibrium point in Embodiment 8 of the present invention;

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

[0053] Fig.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 in conjunction with 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 only for the purpose of describing specific embodiments, and are not intended to limit the embodiments of the present application. The singular forms of "a", "said" and "the" used in the embodiments of the present application are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and / or" used in this article refers to and includes any or all possible combinations of one or more associated listed items.

[0056] When the following description relates 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 only 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 do not have to be 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: Use a graphical interface to build the interface and logic of the configuration software through operations such as drag and drop and connection; build a graphical component library containing a variety of predefined microservice components, which include data collection, processing, storage and display; predefined microservice components support the conversion of graphical components into executable microservice codes to build configuration software;

[0059] S200: 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 microservices according to the configuration file, and supports the automatic deployment, monitoring and upgrading of microservices;

[0060] S300: Monitor the status of edge computing nodes through a graphical interface, and perform remote configuration and management; perform 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 the conversion of 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 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 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. Developers can quickly assemble a complete software system without in-depth understanding of the underlying technical details, which reduces the development threshold; the graphical programming environment supports the conversion of graphical components into executable microservice codes, and developers can quickly implement the development and deployment of 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 Edge computing node deployment strategy deploys the microservices of the configuration software close to the data source, reducing the delay in data transmission and improving the response speed of the system; the edge deployment framework supports the automatic deployment, monitoring and upgrading of microservices to ensure the stability and maintainability of the system; the automatic deployment and monitoring functions can quickly restore services when a node fails, improving the reliability of the system; through the edge deployment framework, the automatic operation and maintenance of microservices is realized, reducing manual intervention and reducing operation and maintenance costs. Significance: By reducing the delay in data transmission, the response speed of the system is improved, and the user experience is improved; the automatic deployment, monitoring and upgrading functions ensure the stable operation of the system and reduce business interruptions caused by node failures.Step S300 Graphical monitoring and management: Through the graphical interface, administrators can monitor the status of edge computing nodes in real time, perform remote configuration and management, and improve operation and maintenance efficiency; the graphical interface supports real-time viewing of node status, log analysis, and troubleshooting, helping administrators quickly locate and solve problems, reducing troubleshooting time; through the graphical interface, administrators can easily perform remote operations without having to visit the site, improving the convenience and efficiency of management. Significance: Graphical monitoring and management tools enable operation and maintenance personnel to quickly locate and solve problems, improve operation and maintenance efficiency, and reduce system downtime; remote configuration and management functions reduce the need for on-site maintenance and reduce operation and maintenance costs.

[0062] In summary, this embodiment not only improves the development efficiency and operation and maintenance efficiency, reduces the 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, performance and reliability in the prior art. It not only improves the development efficiency, reduces the 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 sets 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. Build a graphical component library, which contains a variety of predefined microservice components, such as data acquisition, processing, storage and display, etc., to facilitate rapid assembly into a complete software system. Through the graphical programming environment, it supports the conversion of graphical components into executable microservice codes to achieve 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 upgrading of microservices to ensure system stability and maintainability. A graphical deployment management tool is set up to allow 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] The loop control node and microservices are used to implement batch processing and retry mechanisms between microservices. It supports multiple loop types, 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 function 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 a variety of 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 integrate 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, and realize data consistency and standardization; 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, etc. When an 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 containing various predefined microservice components such as data collection, processing, storage and display is built; at the same time, it supports the import and export of user-defined components, and the integration of custom components with predefined components. Step S101 of the above scheme uses a logic editor to manage the logic flow. Through the logic nodes, users can intuitively build complex logic flows. Each node represents a logic operation or control structure, such as conditional judgment, loop and trigger, etc. The visualization method greatly reduces the difficulty of understanding and maintaining complex logic; the conditional judgment node is combined with the microservice to realize conditional routing and flow control between services. Each condition corresponds to a microservice instance or a group of instances, which ensures the flexibility and efficiency of the service; the loop control node is combined with the microservice to support multiple loop types, such as batch requests, retry logic, etc., to ensure batch processing and retry mechanism between microservices, and improve the stability and reliability of the system; the function call node is combined with the microservice to support parameter passing and return value processing, to realize function reuse between microservices, and reduce the workload of repeated development; the data processing node is combined with the microservice to support operations such as data filtering, sorting, aggregation and format conversion, to ensure data consistency and standardization, and to improve the efficiency and accuracy of data processing; the event trigger node is combined with the microservice to respond to specific events in the microservice, such as timer events, user operation events and data change events, etc., to enhance 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 mechanism 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 flow in the graphical interface, allowing custom code snippets to be embedded in the graphical interface, so that developers can flexibly adjust the logic flow 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 a variety of predefined microservice components such as data collection, processing, storage and display. Through the predefined microservice components, developers can quickly build the system, reducing the workload of development from scratch; support for the import and export of user-defined components, so that developers can customize components according to specific needs, enhancing the flexibility and scalability of the system; the integration of custom components and 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; the support of custom components enables the system to better adapt to the personalized needs of different users; through the integration and standardization of components, the maintainability and scalability of the system are improved, and the standardization and normalization of the system are promoted.

[0073] In summary, the interface and logic of the configuration software constructed in this embodiment not only improves development efficiency, enhances the flexibility and stability of the system, but also improves user experience and promotes the standardization and normalization of the system, so that the configuration software can 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 geographical location of the data source, network latency, and computing resource requirements. The nodes are 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 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;

[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 according to factors such as the geographical location of the data source, network delay and computing resource requirements. The nodes are industrial social security, Internet of Things devices or special edge servers, etc.; before deployment, the edge computing nodes are configured, including network settings, storage space allocation and computing resource reservation, etc.; secondly, an automated deployment framework is designed to automatically complete the deployment and startup of microservices according to predefined configuration files; the configuration file contains the deployment information of the microservice, including service name, dependency, resource requirements and startup parameters, etc.; through the configuration file, the deployment framework automatically identifies and deploys the corresponding microservices; finally, the packaged microservice images are distributed to each edge computing node through the image warehouse; the deployment framework automatically deploys the microservice image to the specified edge computing node according to the configuration file, and starts the service. Step S201 of the above scheme selects the most suitable edge computing node according to the geographical location and network delay of the data source to ensure the efficiency and low latency of data processing; before deployment, the edge computing node is network set up, storage space allocation and computing resource reservation are performed to ensure that the node can meet the operation requirements of the microservice and avoid insufficient or waste of resources. Significance achieved: By reasonably selecting and configuring edge computing nodes, it is ensured that microservices can run in the best environment, improving the performance and response speed of the overall system; by optimizing resource allocation, unnecessary resource waste is avoided and the operating cost of the system is 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, and 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 errors. Step S203: Image distribution and automatic deployment. Through the image warehouse, 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 to launch microservices, allowing 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 that microservices can continue to run stably.

[0079] In summary, the entire microservice deployment and startup process of this embodiment has achieved a high degree of automation and standardization, significantly improving the performance, efficiency and reliability of the system. Specifically: by optimizing node selection and configuration, the microservice is guaranteed to run in the best environment and improve 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 errors and improves the reliability and stability of the system. This enables the microservice architecture to run efficiently and stably in the edge computing environment, meeting the needs 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 provided by the deployment framework of the embodiment of the present invention includes the following steps:

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

[0082] S2022: The framework is built using an adaptive dependency graph. It builds an initial dependency graph based on the configuration file. During the deployment process, it monitors the running status of each microservice in real time and dynamically adjusts the dependency relationship. If a microservice encounters an exception during the startup process, the framework automatically adjusts the dependency graph and re-plans the startup order.

[0083] S2023: In the resource demand assessment and allocation stage, the framework uses the real-time monitoring data of edge computing nodes to perceive the resource usage of nodes and dynamically adjusts the resource allocation strategy based on 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 is recorded on the blockchain. During the image pulling process, the framework automatically verifies the hash value of the image.

[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 re-plans 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 microservice increases, the framework automatically calls computing resources to respond to high concurrent 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, predict the best edge computing node to reduce network delay and improve response speed; automatically adjust startup parameters to ensure that microservices start in the best state, reducing startup time and resource consumption. Significance achieved: Through intelligent recommendation, reduce manual intervention and improve deployment efficiency and accuracy; through dynamic resource allocation, avoid resource waste and improve the performance and stability of the overall system; reduce network delay and response time and enhance user experience. Step S2022 adaptive dependency graph construction and dynamic adjustment, real-time monitoring of the running status of microservices during the deployment process, dynamic adjustment of dependencies, and ensure system stability; when a microservice has an exception, the framework automatically adjusts the dependency graph and re-plans the startup sequence to reduce the impact of the failure on the system. Significance achieved: By dynamically adjusting dependencies, reduce the occurrence of system failures and improve system stability and reliability; automate exception handling, reduce manual intervention, and reduce operation and maintenance costs; dynamically adjust dependencies so that the system can better adapt to different deployment environments and requirements.Step S2023 Resource perception and dynamic scheduling: Real-time monitoring of the resource usage of edge computing nodes to perceive the load status of nodes; Dynamically adjust resource allocation strategies based on real-time data to avoid resource bottlenecks and ensure the rational use of resources; Use blockchain technology to ensure the integrity and security of images and prevent middleman attacks and image tampering. Significance achieved: Through dynamic scheduling, avoid resource bottlenecks, improve resource utilization and system performance; Through blockchain technology, ensure the security of images and reduce security risks; Through real-time monitoring and dynamic scheduling, ensure the stable operation of the system under high load. Step S2024 Service startup and elastic scaling based on Serverless architecture: Dynamically call computing resources according to the request volume of microservices to respond to high concurrent requests, and automatically release resources after the request volume decreases; Through event-driven methods, monitor the running status of microservices in real time, automatically trigger operation and maintenance operations, and ensure the stability and reliability of the system. Significance achieved: Through elastic scaling, ensure the response speed of the system under high concurrency; Dynamically allocate resources according to actual needs to avoid resource waste and reduce operating costs; Through real-time monitoring and automated operation and maintenance, reduce the occurrence of system failures and improve the stability and reliability of the system.

[0086] In summary, the automated deployment framework of this embodiment has significant advantages in improving deployment efficiency, optimizing resource utilization, enhancing system security, improving system response speed, and reducing operation and maintenance costs. It not only improves the overall performance and stability of the system, but also provides users with a better user experience, bringing a new technical 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 evaluation and allocation stage provided in this embodiment of the present invention includes the following steps:

[0088] S20231: 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. 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.

[0089] S20232: 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 allocates microservice requests among 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 delay weight, γ represents the delay adjustment coefficient, and C i (t) represents the CPU usage of node i at time t, represents the global average CPU usage, δ represents the weight of CPU usage, and ∈ represents the adjustment coefficient of 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 operation of the system and optimal allocation of resources.

[0093] S20233: 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 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 a variety of 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 allocates 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 scheme 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 to ensure the comprehensiveness and accuracy of the data; through high-frequency sampling and real-time analysis, a dynamic resource usage map is formed to 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 to provide a basis for the dynamic adjustment of resource allocation strategies. Significance achieved: Through real-time monitoring and trend forecasting, resource demand peaks can be predicted in advance, resource shortages or waste can be avoided, and resource utilization can be improved; through dynamic resource maps, resource bottlenecks can be discovered in a timely manner, measures can be taken in advance, and the stability and reliability of the system can be enhanced. Step S20232 Dynamic resource allocation strategy adjustment: 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 reasonable allocation 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 and resource utilization efficiency can be improved; through intelligent load balancing and automatic migration of microservices, service stability and continuity can be guaranteed, and user experience can be improved.Step S20233 Blockchain record and security verification, the generated hash value is recorded on the blockchain, forming an unalterable image identity to ensure the uniqueness and security of the image; the framework automatically obtains the hash value of the image from the blockchain and compares it with the locally calculated hash value to ensure the integrity and security of the image; if the hash value does not match, the framework will refuse to pull the image and trigger a security alarm to promptly discover and handle potential security threats. Significance achieved: Through blockchain records and hash value comparisons, it can effectively prevent the image from being tampered with or maliciously replaced, enhancing data security; through the security alarm mechanism, it can promptly discover and handle potential security threats to ensure the security and stability of the system.

[0095] In summary, the steps of this embodiment jointly realize the 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 in the embodiment of the present invention includes the following steps:

[0097] S202321: Dynamically adjust 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.

[0098] S202322: 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;

[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 effect and continuously optimizes the migration strategy.

[0100] The working principle and beneficial effects of the above technical solution are as follows: First, the present embodiment dynamically adjusts the threshold according to 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 the early warning mechanism; the decision engine makes microservice migration decisions; secondly, using the 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 scheme dynamically adjusts the threshold and the early warning mechanism, dynamically adjusts the threshold according to historical data and real-time fluctuations, so that the threshold is closer to the actual load situation, and improves the system's adaptive ability; when the CPU usage of a node exceeds the dynamic threshold, the framework can timely 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 and improves 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 of time, 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 nodes, 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 effect and continuously optimizes the migration strategy, so that the system can continue to improve and improve long-term stability. Significance achieved: Automatic execution of migration operations reduces manual intervention, improves migration efficiency, and reduces operation and maintenance costs. By recording the migration effect and continuously optimizing the migration strategy, the system can continue to improve and improve long-term stability and performance. Nash equilibrium point calculation ensures fair distribution of resources among multiple nodes, avoiding the situation where some nodes are overloaded and other nodes are idle.

[0101] In summary, the framework of this embodiment can dynamically adjust the resource allocation strategy, achieving the following significance: through dynamic threshold adjustment, load prediction and automatic migration, the system can remain stable when the load fluctuates, optimize resource utilization, and improve overall performance; the automated migration and optimization process reduces manual intervention and reduces operation and maintenance costs; by recording and analyzing the migration effect, the system can continuously improve and improve long-term stability and performance. This makes the microservice architecture more efficient, stable and reliable in the edge computing environment.

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

[0103] S2023221: Automatically generate multiple migration scenarios based on real-time load data and resource status, generate diversified migration combinations and paths, and cover different load and resource conditions; optimize the use of resources such as bandwidth, CPU, and memory through linear programming and integer programming;

[0104] S2023222: Use the virtualization migration engine to perform migration operations in a virtual environment to simulate resource changes and performance indicators in a real environment; simulate multiple migration scenarios at the same time and accelerate 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 evaluate the uniformity of the load distribution after migration through the load difference coefficient.

[0106] The working principle and beneficial effects of the above technical solution are as follows: First, this embodiment automatically generates multiple migration scenarios according to 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, uses the virtualization migration engine to perform migration operations in a virtual environment to simulate 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, ensuring that the optimal migration path can be found in various situations; uses linear programming and integer programming techniques to optimize the use of resources such as bandwidth, CPU and memory, ensuring efficient use of resources 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 bottleneck, 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, and 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 Dynamic load balancing and load difference coefficient, introduce dynamic load balancing index, evaluate the load distribution of each node after migration in real time, ensure load balance, and avoid single point overload; through adaptive weighted load balancing, the system can dynamically adjust the load balancing strategy according to the real-time load situation to ensure load balance of each node; calculate the load difference coefficient, quantify the load difference between each node, evaluate the uniformity of 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, ensure load balance, and improve the overall performance of the system; the quantitative evaluation of the load difference coefficient helps the system identify the problem of load imbalance, optimize the load balancing strategy, improve resource utilization, and reduce resource waste.

[0107] In summary, this embodiment can achieve load balancing, resource optimization and performance improvement during the migration process, ensuring the feasibility and effectiveness of the migration solution. It not only improves migration efficiency and system stability, but also optimizes resource utilization and load distribution, providing a strong guarantee for the continuous and 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 in the embodiment of the present invention includes the following steps:

[0109] S2023231: 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 to represent the benefit or cost 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 indicators.

[0110] S2023232: For each participant, calculate the benefits of each strategy chosen by the 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 under this combination is optimal, that is, no participant can obtain a better result by unilaterally changing the 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 scenario of resource allocation, the participants are various 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 to represent the benefit or cost of each participant under different strategy combinations, and the benefit function is a mathematical expression of indicators such as resource utilization, load balancing, and migration cost; secondly, for each participant, the benefit of each strategy selected by the participant is calculated when other participants select a specific strategy, and the optimal strategy is found; among all participants, a strategy combination is found so that the strategy selected by each participant under the combination is optimal, that is, no participant obtains a better result by unilaterally changing the strategy; finally, through iterative calculation, the strategy of each participant is gradually adjusted until a stable strategy combination, i.e., the Nash equilibrium point, is found. Step S2023231 of the above scheme defines the benefit function. By defining the benefit function, the complex decision-making 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 effects of different strategies. Significance: The profit function provides participants with a clear basis for decision-making, helping them to choose the best resource allocation plan among many strategies; by over-quantifying the benefits, participants can clarify their own optimization goals, so as to pursue the maximum benefit in the resource allocation process. Step S2023232 Calculate the optimal strategy. By calculating the benefits of each participant under different strategy combinations, participants can compare the advantages and disadvantages of different strategies and select the optimal strategy; find a strategy combination among all participants so that the strategy selected by each participant under this combination is the best, which helps to achieve the global optimal solution. Significance: Find a strategy combination so that each participant cannot obtain better results by unilaterally changing the strategy, which indicates that the system has reached a Nash equilibrium state, that is, the optimal stable state of resource allocation; the existence of the Nash equilibrium point means that the system has reached a stable state in resource allocation, reducing resource conflicts and waste. Step S2023233 Iterative calculation. Through iterative calculation, the strategy of each participant is gradually adjusted so that the system gradually approaches the optimal strategy combination; iterative calculation can help the system converge to a stable strategy combination, that is, the Nash equilibrium point, 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, improve resource utilization efficiency and overall system performance.

[0113] In summary, the process of calculating the Nash equilibrium point in this embodiment not only realizes the quantification and optimization of resource allocation, but also helps the system achieve a stable and optimal resource allocation state in a dynamic environment. It not only improves resource utilization efficiency, but also reduces resource conflicts and waste, providing a guarantee for the long-term stable operation of the system.

[0114] Example 9: Fig. 9 As shown, based on Example 3, the process of automatically deploying a microservice image to a specified edge computing node provided by an 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. According to the resource requirements in the configuration file, the deployment framework reserves corresponding resources on the target node.

[0116] S2032: The deployment framework pulls the microservice image from the image repository according to the image information in the configuration file; after the pull is completed, the deployment framework verifies the image;

[0117] S2033: The deployment framework deploys the verified microservice image to the specified edge computing node. The deployment process includes image decompression, file system mounting, and configuration file injection. 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 verifies 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; after the deployment is completed, the deployment framework executes the startup command of the microservice according to the startup parameters in the configuration file. The above scheme includes step S2031 configuration file parsing and resource reservation. By parsing the configuration file, the deployment framework can automatically obtain detailed deployment information of the microservice, ensuring the automation and standardization of the deployment process; checking the resource status of the target edge computing node to ensure that the node has sufficient resources to run the microservice, avoiding deployment failure due to insufficient resources; reserving corresponding resources on the target node according to the resource requirements in the configuration file to ensure that the microservice can obtain the required resources when it starts, avoiding resource competition and performance degradation. The significance achieved: through configuration file parsing, the automation and standardization of the deployment process are realized, manual intervention is reduced, and the deployment efficiency and consistency are improved; through resource status checking and reservation, the reasonable allocation and utilization of resources are guaranteed, resource waste and performance bottlenecks are avoided, and the stability and reliability of the system are improved. Step S2032 image pulling and verification, pulling the microservice image from the image warehouse, ensuring the latest and integrity of the image, supporting breakpoint resumption and multi-threaded downloading, and improving the pulling efficiency; verifying the pulled image to ensure the integrity and security of the image, including checksum calculation, signature verification and vulnerability scanning, etc., 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 ensured. Step S2033 Image deployment and service startup, deploy 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; according to the startup parameters in the configuration file, execute the startup command of the microservice to ensure that the service can start and run correctly. Significance achieved: Through image deployment and automatic startup, the automated deployment and startup of microservices are achieved, manual operations are reduced, and deployment efficiency and consistency are improved; 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 automatic deployment and startup process of this embodiment realizes the automation, standardization and efficiency of microservices, ensures the rational allocation and utilization of resources, and improves the stability and reliability of the system. At the same time, through image management and verification, the reliability and security of microservices are guaranteed, the deployment time and human errors are reduced, and the overall deployment efficiency and consistency are improved.

[0120] Example 10: Fig.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 the 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; and use visualization tools 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 through a graphical interface, such as restarting nodes, stopping services, and updating 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.

[0124] The working principle and beneficial effects of the above technical solution are as follows: First, through the graphical interface, the user can view the running status of the edge computing node in real time, including key indicators such as CPU usage, memory usage, network traffic and disk usage; use visualization tools to display the running 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 nodes, stopping services and updating software; support remote execution of automated scripts, and users can achieve batch management of nodes by writing scripts; automatically collect the running 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 belong to the scope of equivalent technologies of the present invention, the present invention is also intended to include these modifications and variations.

Claims

1. A graphical construction and edge deployment method for configuration software development of microservice architecture, characterized in that: The following steps are involved: Use a graphical interface to build a graphical component library; 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.

2. The graphical construction and edge deployment method for microservice architecture development using configuration software as claimed in claim 1, characterized in that: 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 the configuration file, automatically recommending resource allocation solutions, 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 relationship. In the resource demand assessment and allocation stage, the framework perceives the resource usage of the nodes through the real-time monitoring data of the edge computing nodes, and dynamically adjusts the resource allocation strategy according to the real-time data; each microservice image generates a unique hash value when it is generated and 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 for 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.

3. The graphical construction and edge deployment method for developing microservice architecture using configuration software as claimed in claim 2, characterized in that: If a microservice encounters an exception during the startup process, the framework automatically adjusts the dependency graph and replans the startup order.

4. The graphical construction and edge deployment method for microservice architecture development using configuration software as claimed in claim 2, characterized in that: The process of resource demand 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, and forms a dynamic resource usage map through high-frequency sampling and real-time analysis; it also predicts the resource demand trend of nodes in the future. 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 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 values ​​do not match, the framework will refuse to pull the image and trigger a security alert.

5. The graphical construction and edge deployment method for developing microservice architecture using configuration software as claimed in claim 4, characterized in that: The process of dynamically adjusting the resource allocation strategy of the framework includes the following steps: The threshold is adjusted dynamically 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 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; 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 performs the microservice migration operation; After the migration is completed, the framework records the migration results and continuously optimizes the migration strategy.

6. The graphical construction and edge deployment method for developing microservice architecture using configuration software as claimed in claim 5, 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: Automatically generate multiple migration scenarios based on real-time load data and resource status, generate diverse migration combinations and paths to cover different load and resource conditions; optimize the use of bandwidth, CPU and memory resources through linear programming and integer programming; Use the virtualization migration engine to perform migration operations in a virtual environment to simulate resource changes and performance indicators in a real environment; simulate multiple migration scenarios at the same time, and accelerate the simulation process through distributed computing and parallel processing; Introduce dynamic load balancing indicators to evaluate the load distribution of each node after migration in real time; adaptive weighted load balancing to balance the load of each node.

7. The graphical construction and edge deployment method for microservice architecture development using configuration software as claimed in claim 6, 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.

8. The graphical construction and edge deployment method for microservice architecture development using configuration software as claimed in claim 6, 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 chosen by the participant when other participants choose a specific strategy, and find the optimal strategy; among all participants, find a strategy combination so that the strategy chosen by each participant under this combination is the best; Through iterative calculation, the strategy of each participant is gradually adjusted until a stable strategy combination, namely the Nash equilibrium point, is found.

9. The graphical construction and edge deployment method for microservice architecture development using configuration software as claimed in claim 8, characterized in that: For each participant, a profit function is defined, which represents the profit or cost of each participant under different strategy combinations.

10. The graphical construction and edge deployment method for microservice architecture configuration software development as claimed in claim 1, characterized in that: The process of automatically deploying the microservice image to the specified edge computing node in combination with the edge computing node deployment strategy 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. According to 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 specified 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