Container technology under intelligent fusion terminal cloud edge integrated management method and system

Abstract

The application provides a container technology intelligent fusion terminal cloud edge integrated management method and system, relates to the cloud edge cooperation technical field, and the method comprises the following steps: adaptively sharding the container architecture stored in the cloud; constructing a hash index table, and performing parallel prediction based on time sequence and semantics; constructing a weighted undirected graph, and iteratively optimizing and distributing container slice scheduling according to a consistent hash link; periodically collecting and state migration prediction based on a network fingerprint vector, and dynamically updating a network tunnel; using a container slice scheduling scheme to perform distributed container slice calling based on a neighborhood edge node and the cloud in parallel, and executing local edge business driving management. The application solves the technical problem that in the prior art, due to the coupling effect of limited edge node resources and high dynamic uncertainty of a network environment, container scheduling is rigid, and data transmission efficiency is affected, and achieves smooth operation and low-latency response of edge business in a weak network environment.

Description

Technical Field

[0001] This application relates to the field of cloud-edge collaboration technology, and in particular to a cloud-edge integrated management method and system for intelligent converged terminals under containerization technology. Background Technology

[0002] With the explosive growth of industrial internet and edge intelligence services, cloud-edge integrated architecture has become the mainstream paradigm supporting intelligent converged terminals. However, in practical applications, edge nodes generally face objective constraints due to limited computing and storage resources. Simultaneously, the network links between the cloud and the edge exhibit strong dynamic uncertainties, such as high latency, high packet loss, frequent bandwidth fluctuations, and intermittent disconnections. Under this coupling effect, traditional cloud-centralized container scheduling methods heavily rely on real-time and reliable network communication. The cloud scheduler struggles to accurately determine the true status of edge nodes in weak network environments, leading to delayed scheduling instructions and rigid task allocation. Furthermore, edge nodes, due to limited resources, cannot support a complete scheduling control plane, further exacerbating the discrepancy between scheduling decisions and actual conditions. This rigid scheduling mechanism directly triggers container slice transmission timeouts, retransmission storms, and link congestion, severely restricting the data transmission efficiency and service responsiveness of cloud-edge integrated management.

[0003] In summary, existing technologies suffer from the technical problem of rigid container scheduling due to the coupling effect of limited edge node resources and the highly dynamic uncertainty of the network environment, which further affects data transmission efficiency. Summary of the Invention

[0004] The purpose of this application is to provide a cloud-edge integrated management method and system for intelligent converged terminals under containerization technology, in order to solve the technical problem in the prior art that the coupling effect of limited edge node resources and highly dynamic uncertainty of the network environment leads to rigid container scheduling, which further affects the data transmission efficiency.

[0005] In view of the above problems, this application provides a method and system for integrated cloud-edge management of intelligent converged terminals under containerization technology.

[0006] Firstly, this application provides a cloud-edge integrated management method for intelligent converged terminals under containerization technology. This method is implemented through a cloud-edge integrated management system for intelligent converged terminals under containerization technology. The method includes: adaptively sharding the container architecture stored in the cloud to obtain clustered container slices; constructing a hash index table based on the container slice mapping, distributing it to each edge node and embedding it in a dual-mode predictor; each edge node, based on its local edge service scenario and network status, performing parallel prediction based on time sequence and semantics according to the dual-mode predictor to obtain a consistent hash link; determining a container slice scheduling scheme by constructing a weighted undirected graph based on the edge node set and iteratively optimizing the allocation of container slice scheduling according to the consistent hash link; dynamically updating the network tunnel using periodic collection and state transition prediction based on network fingerprint vectors; and, based on the dynamically updated network tunnel, using the container slice scheduling scheme to perform distributed container slice invocation based on parallel operations between neighboring edge nodes and the cloud, executing local edge service-driven management.

[0007] Optionally, for the container architecture of cloud storage, a dynamic sliding window is used to adaptively shard the container to determine the container slice; wherein, the adaptive sharding includes: performing first-order sharding on the container using a greedy aggregation method based on access frequency and local time features to determine the first sharding result; performing second-order sharding on the container based on business relevance to determine the second sharding result; taking the intersection of the first sharding result and the second sharding result to determine the first container slice set, taking the union of the first sharding result and the second sharding result to determine the second container slice set, and integrating them as the container slice.

[0008] Optionally, for the container slice, a hash fingerprint is generated and a hash index table is constructed; the edge node obtains the hash index table from the cloud, initializes the dual-mode predictor, determines the sharding granularity constraint based on the network bandwidth and latency characteristics of the edge node, and determines the consistent hash link in combination with the edge service scenario.

[0009] Optionally, a dual-mode predictor is constructed, comprising a temporal prediction unit and a semantic prediction unit, and embedding a dynamically updated hash index table. The edge service scenario and the sharding granularity constraints are input into the dual-mode predictor. The temporal prediction unit dynamically adjusts the longest matching order based on a variable-order Markov model to predict the access data block sequence. The semantic prediction unit uses executable reasoning based on semantic dependencies to determine the function call graph and the control flow graph. The consistent hash link is generated by weighted reconstruction of the access data block sequence, the function call graph, and the control flow graph.

[0010] Optionally, for the set of edge nodes, a weighted undirected graph is constructed, wherein the edge weight is the transmission cost, which is obtained by normalizing and weighting bandwidth, latency, packet loss rate and node load; based on the weighted undirected graph, a first initial particle based on the consistent hash link is determined; based on the first initial particle, an optimization guide is determined with load balancing and transmission efficiency, and iterative optimization is performed to determine a second set of optimized particles; through optimization with a preset number of iterations, a container slicing scheduling scheme is selected.

[0011] Optionally, the first initial particle is any neighbor connection scheme based on task edge nodes, the particle position is encoded as a neighbor allocation matrix, the velocity represents the adjustment direction of the neighbor relationship, and the fitness function is an estimate of the container slice distribution completion time based on consistent hash links; wherein, the neighbor allocation matrix includes first-order call node allocation and second-order container slice allocation.

[0012] Optionally, edge nodes periodically collect network fingerprint vectors and determine the optimal network fingerprint for the next moment through state transition probability measurement; the difference between the network fingerprint vector and the optimal network fingerprint is calculated, and if a preset threshold is met, it is determined that the network environment has changed and a tunnel reconstruction instruction is generated; according to the tunnel reconstruction instruction, a matching is performed in the tunnel parameter template library maintained in the cloud, and tunnel reconstruction management is executed.

[0013] Optionally, based on the tunnel parameter template library, after objective weighting using the entropy weight method, a multi-dimensional comprehensive sorting is performed to determine the matching result. The matching result includes the optimal tunnel type and parameter combination. The comprehensive sorting dimensions include bandwidth matching degree, latency constraint satisfaction degree, packet loss rate tolerance, and encryption computation overhead. By maintaining a shared memory queue in the kernel network stack, unacknowledged data packets in the original tunnel are taken over according to the shared memory queue. The tunnel reconstruction is completed by performing new tunnel reconstruction based on the matching result and lossless migration of unacknowledged data packets. The edge node establishes a control plane connection with the cloud and restores configuration synchronization and status reporting.

[0014] Optionally, a dynamically updated network tunnel is used to execute the first container slice priority call based on the neighboring edge nodes and the second container slice call based on the cloud based on the container slice scheduling scheme. Reorganization and business-driven processes are performed locally on the edge nodes. As the business-driven process progresses, each edge node continuously monitors the page fault frequency of the slices. When the page fault frequency of any container slice exceeds a first preset threshold, a split is triggered. Binary rewriting is used to identify the high-frequency accessed continuous sub-blocks in the corresponding container slice as independent new container slices. The new slice fingerprint is registered in the hash index table, and the original container slice is marked as incomplete. When the page fault frequencies of adjacent container slices are all below a second preset threshold, a merge is triggered, and the slice content is reorganized and updated to the hash index table.

[0015] Secondly, this application also provides a cloud-edge integrated management system for intelligent converged terminals under containerization technology, used to execute the cloud-edge integrated management method for intelligent converged terminals under containerization technology as described in the first aspect. The system includes: an adaptive sharding module for adaptively sharding the container architecture stored in the cloud to obtain cluster-distributed container slices; and a dual-mode prediction module for constructing a hash index table based on the container slice mapping, distributing it to each edge node and embedding it in the dual-mode predictor. Each edge node, based on its local edge service scenario and network status, determines the optimal configuration based on the dual-mode prediction. The detector performs parallel prediction based on time and semantics to obtain consistent hash links; the iterative optimization allocation module is used to construct a weighted undirected graph based on the edge node set and perform iterative optimization allocation of container slice scheduling according to the consistent hash links to determine the container slice scheduling scheme; the dynamic network tunnel update module is used to dynamically update the network tunnel by periodic collection and state transition prediction based on network fingerprint vectors; the distributed invocation module is used to perform distributed container slice invocation based on the dynamically updated network tunnel and the container slice scheduling scheme, based on the parallel operation of neighboring edge nodes and the cloud, to execute local edge service driven management.

[0016] One or more technical solutions provided in this application have at least the following beneficial effects:

[0017] By adaptively sharding the container architecture stored in the cloud, cluster-distributed container slices are obtained. A hash index table is constructed based on the container slice mapping, distributed to each edge node, and embedded in a dual-mode predictor. Each edge node performs parallel prediction based on time sequence and semantics according to its local edge service scenario and network status, obtaining a consistent hash link. By constructing a weighted undirected graph based on the edge node set, the container slice scheduling is iteratively optimized and allocated according to the consistent hash link to determine the container slice scheduling scheme. The network tunnel is dynamically updated by periodically collecting and predicting state transitions based on network fingerprint vectors. Based on the dynamically updated network tunnel, the container slice scheduling scheme is used to perform distributed container slice invocation based on the parallel operation of neighboring edge nodes and the cloud, executing local edge service-driven management. In other words, by generating consistent hash links for pre-scheduling through a dual-mode predictor, allocating slices through iterative optimization using a weighted undirected graph and particle swarm optimization, and dynamically reconstructing lossless tunnels based on network fingerprint vectors, seamless and smooth operation and low-latency response of edge services in weak network environments are achieved, improving data transmission efficiency.

[0018] The above description is merely an overview of the technical solution of this application. To better understand the technical means of this application and to facilitate its implementation according to the description, and to make the above and other objects, features, and advantages of this application more apparent, specific embodiments of this application are described below. It should be understood that the content described in this section is not intended to identify key or important features of the embodiments of this application, nor is it intended to limit the scope of this application. Other features of this application will become readily apparent through the following description. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are merely exemplary. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0020] Figure 1 This is a flowchart illustrating the cloud-edge integrated management method for intelligent converged terminals under the containerization technology of this application.

[0021] Figure 2 This is a schematic diagram of the structure of the intelligent converged terminal cloud-edge integrated management system under the containerization technology of this application.

[0022] Figure labeling: Adaptive sharding module 11, dual-mode prediction module 12, iterative optimization allocation module 13, dynamic network tunnel update module 14, distributed call module 15. Detailed Implementation

[0023] This application provides a cloud-edge integrated management method and system for intelligent converged terminals under containerization technology. It addresses the technical problem in existing technologies where the coupling effect of limited edge node resources and the highly dynamic uncertainty of the network environment leads to rigid container scheduling, further impacting data transmission efficiency. By generating consistent hash links using a dual-mode predictor for pre-scheduling, it iteratively optimizing slice allocation using weighted undirected graphs and particle swarm optimization, and dynamically reconstructing lossless tunnels based on network fingerprint vectors, it achieves seamless and smooth operation and low-latency response for edge services in weak network environments, thereby improving data transmission efficiency.

[0024] The technical solutions of this application will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. It should be understood that this application is not limited to the exemplary embodiments described herein. All other embodiments obtained by those skilled in the art based on the embodiments of this application without creative effort are within the scope of protection of this application. It should also be noted that, for ease of description, only the parts related to this application are shown in the accompanying drawings, not all of them.

[0025] Example 1, please refer to the appendix. Figure 1 This application provides a cloud-edge integrated management method for intelligent converged terminals under containerization technology. The method is executed through a cloud-edge integrated management system for intelligent converged terminals under containerization technology. The specific steps of the cloud-edge integrated management method for intelligent converged terminals under containerization technology are as follows: Adaptive sharding is performed on the container architecture stored in the cloud to obtain container slices distributed across the cluster.

[0026] Furthermore, this application also includes the following steps: for the container architecture of cloud storage, adaptive sharding of containers is performed using a dynamic sliding window to determine container slices; wherein, adaptive sharding includes: performing first-order sharding of containers using a greedy aggregation method based on access frequency and local time features to determine the first sharding result; performing second-order sharding of containers based on business relevance to determine the second sharding result; taking the intersection of the first sharding result and the second sharding result to determine the first container slice set, taking the union of the first sharding result and the second sharding result to determine the second container slice set, and integrating them as the container slice.

[0027] Specifically, the container architecture deployed in the cloud is first loaded into the sharding processing module. A dynamic sliding window is started, with an initial length of 10 minutes, and slides forward continuously in 1-minute increments. At each window position, the access frequency and temporal local characteristics of all container modules within the window are statistically analyzed. Specifically, for each separable granular unit, the number of calls within the most recent window is recorded, and the time interval between adjacent calls is marked. Then, first-order sharding is performed, starting from the smallest unit and scanning from left to right. For two adjacent units, if the difference in their access frequencies is less than a preset first relative threshold, such as 20%, and their access time series overlap within the time window (i.e., one is accessed while the other is also accessed), a greedy strategy is used to merge them into a candidate slice. The merged new slice continues to be compared with the units to its right until no further merging is possible. After the scan is completed, the first sharding result is obtained, where each slice contains a group of units with highly similar access behaviors.

[0028] Simultaneously, static code analysis is performed on the container architecture to extract function call graphs and control flow graphs, and the business relevance coefficient between each unit is calculated. The relevance coefficient is obtained by weighted summation based on the normalized number of direct calls and the depth of indirect dependencies. Second-order sharding is performed, with each function unit as a node. If the business relevance coefficient between two units is greater than a second preset threshold, such as 0.7, they must be assigned to the same slice. According to this constraint, a connected component algorithm is used to aggregate strongly related units into the second sharding result.

[0029] The intersection of the first and second sharding results is taken. Each slice in the first sharding result is traversed, and its internal cell set is compared with each slice in the second sharding result. If a cell block appears in the same aggregate in both sharding results, that cell block is added to the first container slice set, and the entire aggregate remains intact. Next, a union operation is performed, merging all slices from the first and second sharding results into a single set, removing duplicate cell blocks to obtain the second container slice set.

[0030] The first set of container slices is designated as the core slices that are forcibly retained. For the remaining units not in the first set, they are organized into slices according to the partition boundaries of the second set of container slices. The integrated set of container slices is stored in a distributed object store, and an index mapping from slice identifiers to storage locations is established. Each slice includes metadata recording its original list of units, dependencies, and estimated computational load.

[0031] First-order sharding leverages access frequency and temporal locality to aggregate frequently related modules within the same shard, reducing cross-shard call latency. Second-order sharding, based on business relevance, avoids distributed transaction overhead caused by splitting logical dependencies. The intersection and union integration mechanism ensures the integrity of core tightly coupled modules while providing flexible multi-granularity scheduling options.

[0032] A hash index table is constructed based on the container slice mapping, distributed to each edge node and embedded in the dual-mode predictor. Each edge node performs parallel prediction based on time sequence and semantics according to its local edge business scenario and network status, and obtains a consistent hash link.

[0033] Furthermore, this application also includes the following steps: generating hash fingerprints and constructing hash index tables for the container slices; the edge nodes obtain the hash index tables from the cloud, initialize the dual-mode predictor, determine the sharding granularity constraints based on the network bandwidth and latency characteristics of the edge nodes, and determine the consistent hash links in combination with the edge service scenarios.

[0034] Furthermore, this application also includes the following steps: constructing a dual-mode predictor, wherein the dual-mode predictor includes a temporal prediction unit and a semantic prediction unit, and embeds the dynamically updated hash index table; inputting the edge service scenario and the sharding granularity constraint into the dual-mode predictor, wherein the temporal prediction unit uses a variable-order Markov longest matching order for dynamic adjustment to predict the access data block sequence; the semantic prediction unit uses executable reasoning based on semantic dependencies to determine the function call graph and the control flow graph; and generating the consistent hash link by weighted reconstruction of the access data block sequence, the function call graph, and the control flow graph.

[0035] Specifically, a hash fingerprint is calculated for each container slice using the SHA-256 algorithm, outputting a 256-bit binary string, which is then converted to a hexadecimal string for storage. The hash fingerprint is a fixed-length digest value calculated from the contents of the container slice using a hash function, used to uniquely identify a slice for quick lookup and comparison. A hash index table is constructed, where each row records the slice's hash fingerprint, the slice's access path in cloud object storage, and the slice's size, and is versioned as the slice version is updated.

[0036] When each edge node starts up, it sends a GET request to the configuration management service in the cloud, carrying its own node identifier and the current hash index table version number. Upon receiving the request, the cloud compares the node version number with the latest version number. If the node version number is less than the latest version number, it returns the contents of the latest hash index table and the new version number; if they are equal, it only returns a no-update flag. Upon receiving the response, if the edge node contains a new table, it stores it in local persistent storage and replaces the old table in memory. Simultaneously, the edge node starts the dual-mode predictor process, loading the hash index table into the predictor's memory-mapped structure. If hash mapping is used, the key is a fingerprint string, and the value is a slice metadata pointer.

[0037] The dual-mode predictor reads the configuration file and initializes the parameters of the variable-order Markov model of its temporal prediction unit, such as setting the maximum order to 10, the minimum order to 1, the matching threshold to 3, the dependency depth of the semantic prediction unit to 3 layers, and the attenuation coefficient to 0.7. After the predictor initialization is complete, the edge nodes begin measuring their own network bandwidth and latency characteristics.

[0038] A network probing task is run, sending a fixed-size set of probe packets to a test endpoint in the cloud every 60 seconds. Sending and receiving times are recorded, and the average round-trip time (RTT) is calculated, typically the median of the last three measurements. The downlink bandwidth is calculated by downloading a test file of known size and measuring the download completion time; similarly, the uplink bandwidth is calculated by uploading the test file. The node inputs the measured downlink bandwidth and RTT into the fragmentation granularity decision module. If the downlink bandwidth is greater than or equal to 20Mbps and the RTT is less than or equal to 50ms, it is classified as a high-bandwidth, low-latency node, and the fragmentation granularity constraint is set to coarse-grained, meaning the minimum size of a single fragment is 40MB and the maximum size is 100MB. Subsequent scheduling will prioritize fragments within this size range. If the downlink bandwidth is less than 5Mbps or the RTT is greater than 200ms, it is classified as a low-bandwidth, high-latency node, and fine-grained constraints are set, with a lower limit of 2MB and an upper limit of 15MB for the fragment size. Otherwise, medium-grained constraints are set, with the fragment size ranging from 15MB to 40MB. The node saves the determined sharding granularity constraints as local configuration parameters for use by subsequent shard requests and transport modules. The node continues to periodically repeat network measurements and dynamically adjusts the sharding granularity constraints to adapt to network changes.

[0039] Fragmentation granularity constraints determine the upper and lower limits of the size of a single container fragment based on the network conditions (bandwidth and latency) of the edge nodes. Coarse-grained fragmentation allows for larger fragments to reduce the total number of requests, making it suitable for high-bandwidth, low-latency nodes; fine-grained fragmentation limits fragments to smaller ones to avoid excessive retransmission costs in case of a single transmission failure, making it suitable for low-bandwidth, high-latency, or high-packet-loss nodes.

[0040] The dual-mode predictor runs as a resident process on the node, internally using two threads for the computation of the time-series prediction unit and the semantic prediction unit, respectively. Both threads share a memory copy of the same hash index table and dynamically update by periodically requesting incremental updates from the cloud via a background thread. The dual-mode predictor can accept edge business scenarios and sharding granularity constraints as input and output a consistent hash chain.

[0041] Edge business scenarios and sharding granularity constraints are input into the dual-mode predictor. The time-series prediction unit then starts, reading the sequence records of recently accessed data blocks and dynamically adjusting the longest matching order using a variable-order Markov algorithm. If the recent access pattern shows strong regularity, the order is increased to capture longer-term dependencies; conversely, the order is decreased to adapt to the current randomness, thus outputting the sequence of data blocks most likely to be accessed in the future. Simultaneously, the semantic prediction unit begins working, performing lightweight static analysis on the currently running executable file or utilizing pre-built metadata to reverse-engineer the function call graph and control flow graph, identify dependency paths, and increase the prefetch weight of the callee. For example, if function A calls function B, then the prefetch weight of B increases after A is accessed. Sharding granularity constraints are used to filter candidate shards during the link generation stage: if the size of a shard exceeds the granularity range allowed by the current node, it will not appear in the final link or will be replaced by a finer-grained equivalent shard.

[0042] The Time Series Prediction Unit is a submodule of the dual-mode predictor, focusing on analyzing the historical access time series of container slices. It uses a variable-order Markov model to predict the next most likely sequence of data blocks to be accessed, focusing on when and in what order they are accessed. The Time Series Prediction Unit works as follows: it maintains a fixed-length historical access queue, storing the hash fingerprints of recently accessed slices. The queue length is equal to the maximum order, such as 10. Each time an application issues a slice access request, the unit records the slice's fingerprint and timestamp and pushes it into the queue. When prediction is needed, the unit starts from the end of the current queue and attempts to determine the order k, decreasing from the maximum to the minimum. For each k, it extracts the sequence of the last k fingerprints as the query key and matches it against the historical pattern database. The historical pattern database is a dictionary where the key is a sequence and the values ​​are statistics on the occurrences of its subsequent fingerprints. During matching, the total number of occurrences of the sequence and the conditional probability distribution of its subsequent fingerprints are calculated. If the sequence appears more than or equal to a preset hit threshold (e.g., 3 times) and the maximum conditional probability is greater than 0.5, then the order k is adopted, and the top 3 most probable subsequent fingerprints are used as the prediction output, sorted from highest to lowest probability to form the access data block sequence. If no matching condition is found until k=1, a default sequence is output, with the slice with the highest current access frequency used as the single-element sequence. After prediction, the temporal prediction unit outputs the sequence along with the temporal probability score corresponding to each slice. The access data block sequence is a list of slice hash fingerprints arranged in chronological order output by the temporal prediction unit, where each fingerprint represents a slice expected to be accessed soon.

[0043] The semantic prediction unit is another submodule of the bimodal predictor. It does not rely on temporal order but infers future call requirements based on business dependencies by performing static or runtime analysis of function call relationships and control flow logic within the container. It focuses on what must be accessed due to business logic. The semantic prediction unit first loads pre-generated function call graphs and control flow graphs. These graphs are extracted from the original container image during the container sharding phase and stored as metadata in the cloud. Edge nodes are downloaded locally during initialization. Nodes in the graph are represented by module identifiers. Each module uses a hash index table to look up the container slice containing it. The semantic prediction unit uses the currently executing function as the starting node and performs a breadth-first search, traversing all reachable nodes in the call graph whose depth from the starting node does not exceed a preset dependency depth. The weight of each traversal edge is pre-set based on the number of calls or branch probability. During traversal, for each function node encountered, its corresponding semantic score is calculated: the initial node score is 1.0, multiplied by the weight of the edge above each time it propagates along an edge (i.e., a decay coefficient). If multiple paths reach the same node, the scores are accumulated. After traversal, the scores of all visited function nodes are normalized and mapped to the 0-1 range. Then, these function nodes are mapped to the container slices containing them using a hash index table. A single slice may contain multiple functions; the highest score among them is taken as the semantic score for that slice. Finally, the semantic prediction unit outputs a list of slices sorted from highest to lowest semantic score. A function call graph is a directed graph where nodes represent functions or modules, directed edges represent call relationships, and edges have weights, such as call frequency. A control flow graph is a directed graph describing the execution flow between basic blocks in a program; nodes are basic blocks, and edges represent conditional jumps, loop backward edges, or sequential execution.

[0044] The access data block sequence output by the timing prediction unit is fused with the function call graph and control flow graph output by the semantic prediction unit. Candidate slices are sorted based on their comprehensive score, and the sorting result is combined with the storage address mapping in the hash index table to reconstruct a consistent hash link pointing to a specific physical storage location. A comprehensive score calculation formula is defined as: Comprehensive Score = α × Timing Score + β × Semantic Score, where α and β are configurable weight coefficients, typically dynamically adjusted according to the business scenario; for example, α is increased for streaming processing scenarios, and β is increased for highly dependent businesses. For slices appearing in the timing prediction output, their timing score is the probability value of that slice in the access data block sequence; for slices appearing in the semantic prediction output, their semantic score is the normalized value. The comprehensive score of all candidate slices is calculated, and the top K slices are selected from highest to lowest, arranged into an ordered linked list according to their natural order in the business logic. Each element in the linked list is the hash fingerprint of the slice and its corresponding storage location hint, generating a consistent hash link, which is a linked list composed of multiple slice hash fingerprints in sequence. Consistent hashing links predict the same link for the same business scenario and network state across different edge nodes.

[0045] For example, the parameters for business scenario mapping are configured as follows: maximum temporal order 10, hit threshold 3 times, α=0.4, β=0.6; semantic dependency depth 3 layers, attenuation coefficient 0.7. The historical access queue records the hash fingerprints of the most recent 10 slices (in order of time): S12(w3x4), S4(g7h8), S5(i9j0), S13(y5z6), S4(g7h8), S11(u1v2), S4(g7h8), S5(i9j0), S13(y5z6), S4(g7h8), where S4 is the main module for illumination acquisition, S5 is for brightness calculation, S13 is for dimming command generation, and S11 is for data reporting. The last 10 fingerprints in the current queue are as shown above. Trying a maximum order k=10, extract the last 10 sequences, search for the occurrence frequency of each sequence in the historical pattern database, and predict two possible access data blocks: S5 and S11. Sort the sequences S5 and S11 by probability, assigning temporal scores of 0.5 and 0.25 respectively. After semantic prediction unit normalization, S5=0.5, S13=0.35, and S11=0.15. Semantic scores are retained. Weighted reconstruction: α=0.4, β=0.6. Calculate the comprehensive score for each slice: S5 has a temporal score of 0.5 and a semantic score of 0.5, resulting in a comprehensive score of 0.5; S11 has a temporal score of 0.25 and a semantic score of 0.15, resulting in a comprehensive score of 0.19; S13 has a temporal score of 0 and a semantic score of 0.35, resulting in a comprehensive score of 0.21; S4 has a temporal score of 0 and a semantic score of 0, resulting in a comprehensive score of 0. Sort by comprehensive score as S5, S13, and S11. S5 should precede S13 because S5 calls S13. S11 has no direct dependency on S5 or S13, but it can be placed last according to its score. Therefore, the eventually consistent hash chain is determined as follows: first, the fingerprint of S5 (i9j0), then the fingerprint of S13 (y5z6), and finally the fingerprint of S11 (u1v2). Each element in the chain is accompanied by a storage location found in the hash index table.

[0046] By constructing a dual-mode predictor and fusing temporal and semantic predictions, the temporal prediction unit utilizes a variable-order Markov model to dynamically adjust its order. When access patterns are stable, it can accurately capture patterns through high-order matching; when patterns are chaotic, it automatically reduces the order to avoid misjudgments, thus providing reasonable temporal predictions under various access patterns. The semantic prediction unit analyzes function call graphs and control flow graphs to identify slices that will inevitably be called due to dependencies from the business logic level, compensating for the deficiency of pure temporal models in predicting long-range or aperiodic dependencies. Weighted refactoring organically combines the two types of prediction results, generating a consistent hash chain that reflects both temporal proximity and ensures the necessity of business logic.

[0047] By constructing a weighted undirected graph based on the set of edge nodes, and iteratively optimizing the allocation of container slice scheduling according to the consistent hashing link, a container slice scheduling scheme is determined.

[0048] Furthermore, this application also includes the following steps: for the set of edge nodes, construct a weighted undirected graph, wherein the edge weight is the transmission cost, which is obtained by normalizing and weighting bandwidth, latency, packet loss rate and node load; determine a first initial particle based on the consistent hash link according to the weighted undirected graph; based on the first initial particle, determine the optimization direction with load balancing and transmission efficiency, perform iterative optimization to determine a second set of optimized particles, and select a container slicing scheduling scheme through optimization of a preset number of iterations.

[0049] Furthermore, this application also includes the following steps: the first initial particle is any neighbor connection scheme based on task edge nodes, the particle position is encoded as a neighbor allocation matrix, the velocity represents the adjustment direction of the neighbor relationship, and the fitness function is an estimate of the container slice distribution completion time based on consistent hash links; wherein, the neighbor allocation matrix includes first-order call node allocation and second-order container slice allocation.

[0050] Specifically, information on all edge nodes participating in the scheduling is collected to construct a weighted undirected graph. The set of edge nodes is obtained, including the current task's edge node and other edge nodes within one or two hops, plus cloud nodes, which are treated as special nodes. For each pair of nodes in the graph that can communicate directly, the current available bandwidth, average one-way latency, packet loss rate, and the target node's current load are measured in real time. Each metric is normalized: bandwidth uses a reciprocal mapping, where higher bandwidth results in lower costs; the normalization formula is: bandwidth cost = reference bandwidth / actual bandwidth, truncated to the range of 0-1; latency is normalized to the actual latency divided by the maximum allowable latency; packet loss rate uses the actual value directly; load is normalized to the ratio of current load to maximum load. Weights are assigned to each edge, such as bandwidth weight 0.4, latency 0.3, packet loss rate 0.2, and load 0.1, and a weighted sum is performed to obtain the transmission cost of each edge. If there is no direct link between two nodes, and multi-hop routing is required, the transmission cost is set to infinity.

[0051] The initial particle swarm for particle swarm optimization (PSO) is determined based on consistent hashing links and a weighted undirected graph. Each particle corresponds to a neighbor allocation scheme; that is, for each slice in the consistent hashing links, a node is selected from all reachable neighbor nodes as the provider of that slice. To generate diverse initial particles, a random allocation strategy is adopted. For each slice, a neighbor node is randomly selected, forming a neighbor allocation matrix. The matrix is ​​M rows and N columns, where N is the total number of neighbor nodes, and each row has exactly one element of 1, with the rest being 0. In addition to position, each particle also has a velocity matrix, with the same dimension as the position matrix, representing the probability or direction of adjustment. The velocity is usually initialized to 0. The first initial particle is the initial individual in the PSO algorithm. Each particle represents a feasible scheduling scheme, i.e., a neighbor connection scheme, describing how to obtain the required container slice from each edge node. Particles have position and velocity attributes.

[0052] Given a particle's neighbor assignment matrix, estimate the completion time of all slices in a consistent hashing link distributed according to this scheme. Assume slices in the link must be processed sequentially; that is, a next slice can only be requested after the previous slice has arrived and been loaded. For each slice, the transmission time required to obtain the slice from its assigned neighbor nodes = slice size / effective transmission rate from that node to the task edge node. The effective transmission rate is directly calculated by multiplying the actual bandwidth between nodes by a factor of (1 - packet loss rate). Considering concurrent requests, different slices may be obtained from different nodes simultaneously, but this is limited by the receiving window of the task edge node. In practice, the estimation can be simplified to: Total completion time = sum of all slice transmission times + queuing delay for each slice. The function takes the particle position matrix as input and outputs a floating-point number representing the total time. The smaller this value, the better the particle.

[0053] The optimization focuses on load balancing and transmission efficiency. Load balancing is reflected in the fitness function by adding a penalty term: if some neighboring nodes are assigned a total slice size much larger than the average, additional time overhead is incurred. Transmission efficiency is achieved by prioritizing edges with lower transmission costs.

[0054] Set the particle swarm size to P and the maximum number of iterations to T. Initialize the positions and velocities of P particles. Enter the iteration loop. For each generation, calculate the fitness value based on the current particle position; if the particle's fitness is better than its historical best fitness, update its best position; find the particle with the best fitness among all particles and set it as the global best position. Update the velocity of each particle: velocity = inertia weight × old velocity + cognitive coefficient × random number × (individual best position - current position) + social coefficient × random number × (global best position - current position). The inertia weight typically decreases linearly from 0.9 to 0.4. Update the position: new position = old position + velocity. Since the position must be discrete 0 / 1 with only one 1 per row, continuous velocities need to be mapped to discrete adjustment operations. Typically, a sigmoid function is used to convert the velocity value into a probability, and this probability is used to determine whether to switch the current row's assignment node to another candidate node. Ensure that each row still contains only one 1. After iteration, the position matrix of the globally optimal particle is selected from the final particle swarm as the container slice scheduling scheme. This clarifies which neighbor node should be obtained from for each slice in the consistent hashing link. The container slice scheduling scheme explicitly specifies which edge node to obtain the slice from for each slice in the consistent hashing link, as well as possible multi-path allocation strategies.

[0055] This step quantifies the communication quality between edge nodes into transmission cost by constructing a weighted undirected graph. It integrates four key factors: bandwidth, latency, packet loss rate, and node load, making the cost function more closely resemble the highly dynamic characteristics of real edge networks. The iterative allocation algorithm based on particle swarm optimization can solve the combinatorial explosion scheduling problem in polynomial time, avoiding exhaustive search. The fitness function is based on the sequential dependencies of consistent hash links, ensuring that the scheduling scheme conforms to the actual execution flow of the business. The optimization orientation simultaneously considers load balancing and transmission efficiency, preventing single-node overload from causing overall performance degradation.

[0056] The network tunnel is dynamically updated by periodically collecting data based on network fingerprint vectors and predicting state transitions.

[0057] Furthermore, this application also includes the following steps: edge nodes periodically collect network fingerprint vectors, and determine the optimal network fingerprint for the next moment through state transition probability measurement; calculate the difference between the network fingerprint vector and the optimal network fingerprint, and if a preset threshold is met, determine that the network environment has changed and generate a tunnel reconstruction instruction; according to the tunnel reconstruction instruction, match it in the tunnel parameter template library maintained in the cloud, and perform tunnel reconstruction management.

[0058] Furthermore, this application also includes the following steps: Based on the tunnel parameter template library, after objective weighting using the entropy weight method, a multi-dimensional comprehensive sorting is performed to determine the matching result, wherein the matching result includes the optimal tunnel type and parameter combination, and the comprehensive sorting dimensions include bandwidth matching degree, latency constraint satisfaction degree, packet loss rate tolerance, and encryption computation overhead; by maintaining a shared memory queue in the kernel network stack, unacknowledged data packets in the original tunnel are taken over according to the shared memory queue; tunnel reconstruction is completed by performing new tunnel reconstruction based on the matching result and lossless migration of unacknowledged data packets; the edge node establishes a control plane connection with the cloud to restore configuration synchronization and status reporting.

[0059] Specifically, a network monitoring daemon runs on the edge node, collecting network fingerprint vectors between the current node and the cloud and neighboring nodes at preset intervals. It measures latency and packet loss rate by sending ICMP probe requests, estimates available bandwidth through TCP throughput tests, and reads real-time jitter and error packet statistics from the network interface card (NIC) driver. Each collection yields a multi-dimensional vector, such as bandwidth, latency, packet loss rate, and jitter. A statistical Markov chain is built based on historical fingerprint sequences to calculate the state transition probability matrix. For the measured fingerprint at the current moment, the Markov chain is used to predict several candidate fingerprints and their probabilities for the next moment. Based on the type of service currently running on the edge node, the most suitable candidate fingerprint for the business requirements is selected as the optimal network fingerprint. For example, real-time video services prioritize fingerprints with high bandwidth and low latency; control services prioritize fingerprints with low packet loss rate and low jitter.

[0060] The difference between the network fingerprint vector and the optimal network fingerprint is calculated, and the square root of the sum of the squares of the differences in each dimension is calculated. If the difference exceeds a preset threshold, it is considered that the current network environment has changed significantly and the existing tunnel parameters are no longer suitable. Therefore, a tunnel reconstruction command is generated and sent to the tunnel management module along with the current measured fingerprint.

[0061] Based on the tunnel reconstruction command, a tunnel parameter template library is retrieved from the cloud. This library contains various predefined tunnel configuration templates, each recording a combination of parameters such as tunnel protocol type, maximum transmission unit size, encryption algorithm, heartbeat interval, congestion control algorithm, and retransmission timeout. An entropy weighting method is used to objectively assign weights to the evaluation dimensions. Using several historical fingerprints collected at the moment as samples, the degree of variation for each dimension is calculated. The higher the variation, the more sensitive the dimension is to network changes, and the higher its weight should be assigned. Based on the determined weights for each dimension, each template in the library is comprehensively ranked in multiple dimensions. Based on the currently measured fingerprints, the bandwidth matching degree, latency constraint satisfaction, packet loss rate tolerance, and encryption computation overhead of each template under the current network condition are calculated. A weighted sum is used to obtain a comprehensive score for each template. Templates are then sorted from highest to lowest score, and the template with the highest score is selected as the matching result, containing the optimal tunnel type and specific parameter combination.

[0062] A shared memory queue is pre-maintained in the kernel network stack. While the original tunnel is still running, all sent data packets, awaiting acknowledgment, are copied and placed into this shared memory queue. The queue stores the complete content and sequence number of unacknowledged data packets in the order they were sent. When the new tunnel parameters are selected, data transmission from the original tunnel is paused, but it is not immediately destroyed. A new tunnel interface is created in the operating system kernel based on the parameters of the new template. After the new tunnel is established, data is retransmitted through the new tunnel. Meanwhile, the original tunnel continues to receive acknowledgments for sent data packets, but no longer sends new data. Once all unacknowledged data packets in the original tunnel have received acknowledgments or timed out, the original tunnel is finally dismantled, completing the reconstruction of the new tunnel based on the matching results and the lossless migration of unacknowledged data packets.

[0063] After establishing the data path through the new tunnel, edge nodes need to re-establish their control plane connection with the cloud. Since tunnel reconstruction may cause changes in node IP addresses or security key updates, the existing control plane connection may become invalid. The node initiates a new TCP connection to the cloud's control plane service and performs a TLS handshake and authentication. Once the connection is established, the node synchronizes its latest configuration to the cloud; the cloud then issues global configuration updates and tasks to be executed. The node resumes periodic status reporting, such as sending heartbeat and load information every 10 seconds, ensuring the cloud can monitor the health status of edge nodes in real time. By periodically collecting network fingerprint vectors and combining them with state transition probability metrics, proactive awareness of dynamic changes in the edge network is achieved, improving the continuity and reliability of edge services in weak network environments.

[0064] Based on the dynamically updated network tunnel, the container slicing scheduling scheme is used to perform distributed container slicing calls based on the parallel operation of neighboring edge nodes and the cloud, and to execute local edge service-driven management.

[0065] Furthermore, this application also includes the following steps: using a dynamically updated network tunnel, executing a first container slice priority call based on neighboring edge nodes and a second container slice call based on the cloud based on the container slice scheduling scheme, and performing reorganization and business-driven operations locally on the edge nodes; as the business-driven process progresses, each edge node continuously monitors the slice page fault frequency, and triggers a split when the page fault frequency of any container slice exceeds a first preset threshold, using binary rewriting to identify high-frequency accessed continuous sub-blocks in the corresponding container slice as independent new container slices, registering the new slice fingerprint in the hash index table, and marking the original container slice as incomplete; when the page fault frequencies of adjacent container slices are all below a second preset threshold, triggering a merge, performing slice content reorganization and updating the hash index table.

[0066] Specifically, after the dynamically updated network tunnel is successfully established and operational, the edge nodes begin executing the specific slice invocation process according to the container slice scheduling scheme. The container slice scheduling scheme divides each slice in the consistent hashing link into two categories: the first container slice refers to slices that can be directly obtained from neighboring edge nodes, and the second container slice refers to slices that need to be obtained from the cloud. Edge nodes prioritize initiating transmission requests for the first container slice to neighboring nodes via the dynamic network tunnel, utilizing multi-path parallel downloading to reduce the overall completion time; for the second container slice, requests are made from the cloud via the tunnel. Once all slices arrive, the edge nodes reassemble them in local storage, piecing together the slices into a complete runtime environment according to the original container image layout and dependencies, and starting the corresponding business processes.

[0067] After the service begins operation, the monitoring agent on the edge node continuously tracks page fault events for each container slice. A page fault event occurs when a business thread accesses the code or data of a slice, but the slice has not yet been effectively resided in the node's memory or local cache, requiring it to be retrieved from the remote cache again. The node maintains a page fault counter for each slice within a sliding time window and calculates the page fault frequency by dividing the number of page faults by the window duration. When the page fault frequency of any container slice exceeds a first preset threshold, it indicates that the slice is being accessed remotely very frequently, its granularity may be too coarse, and high-frequency access parts are mixed with low-frequency parts, resulting in a large amount of useless data being fetched with each access. At this point, a splitting process is triggered. The first preset threshold is a pre-set upper limit for the page fault frequency, such as 5 times / minute. When the page fault frequency of a slice exceeds this value, it indicates that the slice is being accessed remotely frequently, its granularity may be too coarse, and it needs to be split into finer-grained hotspot sub-blocks.

[0068] The slice with excessively high page fault frequency is located, and its complete binary content is retrieved from local cache or distributed storage. Binary rewriting techniques are used to analyze the slice's runtime access history over a recent period. By sampling and recording the access timestamps and frequencies of various address ranges within the slice during business execution, a continuous range of address segments with access frequencies exceeding a preset popularity threshold is identified as the core of high-frequency access. These sub-blocks are copied to generate a new, independent container slice containing the binary code and data of these continuous sub-blocks. The hash fingerprint of the new slice is calculated using SHA-256 and registered in the global hash index table, recording its storage location, typically stored locally on the current node. Simultaneously, the original slice is marked as incomplete, and its content description is updated in the index table, subtracting the removed sub-blocks. After splitting, the original slice is no longer complete, missing the split sub-blocks, but retains the remaining portion, marked as incomplete in the metadata to distinguish it from the complete slice. When the business accesses the new slice again, it directly pulls this small, frequently accessed data block without loading the entire original slice, significantly reducing transmission overhead.

[0069] When the page fault frequency of adjacent container slices is below a second preset threshold, it indicates that these slices are rarely accessed due to page faults, meaning they reside in the local cache most of the time. However, existing as independent slices would incur excessive metadata maintenance costs and scheduling overhead. A merge process is triggered, retrieving the binary content of these adjacent slices and concatenating them according to their original order within the container to form a larger new slice. The hash fingerprint of this new slice is recalculated, registered in the hash index table, and the old adjacent slices are marked as invalid or deleted. After merging, business calls only require a single index lookup to obtain the entire large slice, reducing the number of scheduling and query operations. The second preset threshold is a pre-defined lower limit for page fault frequency, such as 1 time per minute. When the page fault frequency of adjacent slices is below this value, a merge is triggered.

[0070] The entire splitting and merging process is continuous at runtime. Nodes periodically reassess the page fault frequency of each slice and dynamically adjust accordingly. All these changes are synchronized to the cloud and other edge nodes through dynamically updated network tunnels, ensuring consistency of the slice view across the entire system.

[0071] In summary, in business-driven management, edge nodes continuously monitor the actual access of business processes to each slice. If a business process needs to access a slice that has not yet been fully loaded, a page fault will be triggered. The node then obtains the slice through dynamic tunneling based on the source node information of that slice in the scheduling scheme. Simultaneously, the node records the page fault frequency of each slice and dynamically executes slice splitting or merging according to preorder rules to optimize the efficiency of subsequent calls. Prioritizing calls to the first container slice from neighboring nodes significantly reduces cross-WAN traffic and latency; parallel calls to multiple slices reduce overall completion time and allow partially ready slices to be reassembled and executed ahead of time; dynamic tunneling ensures robustness to network fluctuations during transmission. Page fault handling and dynamic splitting / merging in business-driven management further enhance adaptability.

[0072] In summary, the intelligent converged terminal cloud-edge integrated management method under containerization technology provided in this application has the following beneficial effects: By adaptively sharding the container architecture stored in the cloud, cluster-distributed container slices are obtained; a hash index table is constructed based on the container slice mapping, distributed to each edge node and embedded in a dual-mode predictor; each edge node, based on its local edge service scenario and network status, performs parallel prediction based on time sequence and semantics according to the dual-mode predictor to obtain a consistent hash link; by constructing a weighted undirected graph based on the edge node set, iterative optimization allocation of container slice scheduling is performed based on the consistent hash link to determine the container slice scheduling scheme; the network tunnel is dynamically updated using periodic collection and state transition prediction based on network fingerprint vectors; based on the dynamically updated network tunnel, the container slice scheduling scheme is used to perform distributed container slice invocation based on parallel execution of neighboring edge nodes and the cloud, executing local edge service-driven management. In other words, by generating consistent hash links through a dual-mode predictor for pre-scheduling, allocating slices through weighted undirected graphs and particle swarm optimization, and dynamically reconstructing lossless tunnels based on network fingerprint vectors, we can achieve seamless and smooth operation and low-latency response of edge services in weak network environments, thereby improving data transmission efficiency.

[0073] Example 2: Based on the same inventive concept as the containerized intelligent converged terminal cloud-edge integrated management method in Example 1, this application also provides a containerized intelligent converged terminal cloud-edge integrated management system. Please refer to the appendix. Figure 2The intelligent converged terminal cloud-edge integrated management system under containerization technology includes: an adaptive sharding module 11, used to adaptively shard the container architecture stored in the cloud to obtain cluster-distributed container slices; a dual-mode prediction module 12, used to construct a hash index table based on the container slice mapping, distribute it to each edge node and embed it in the dual-mode predictor, each edge node performs parallel prediction based on time sequence and semantics according to the local edge service scenario and network status, and obtains a consistent hash link; an iterative optimization allocation module 13, used to construct a weighted undirected graph based on the edge node set, and perform iterative optimization allocation of container slice scheduling according to the consistent hash link to determine the container slice scheduling scheme; a dynamic network tunnel update module 14, used to dynamically update the network tunnel by periodic collection and state transition prediction based on network fingerprint vectors; and a distributed call module 15, used to perform distributed container slice calls based on the container slice scheduling scheme in parallel between neighboring edge nodes and the cloud according to the dynamically updated network tunnel, and execute local edge service driven management.

[0074] Furthermore, the adaptive sharding module 11 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used to: adaptively shard the container using a dynamic sliding window to determine the container slice for the container architecture of cloud storage; wherein, the adaptive sharding includes: performing first-order sharding on the container using a greedy aggregation method based on access frequency and local time characteristics to determine the first sharding result; performing second-order sharding on the container based on business relevance to determine the second sharding result; taking the intersection of the first sharding result and the second sharding result to determine the first container slice set, taking the union to determine the second container slice set, and integrating them as the container slice.

[0075] Furthermore, the dual-mode prediction module 12 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used to: generate hash fingerprints and construct hash index tables for the container slices; the edge nodes obtain the hash index tables from the cloud, initialize the dual-mode predictor, determine the granularity constraints of the slices based on the network bandwidth and latency characteristics of the edge nodes, and determine the consistent hash links in combination with the edge service scenarios.

[0076] Furthermore, the dual-mode prediction module 12 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used for: constructing a dual-mode predictor, wherein the dual-mode predictor includes a temporal prediction unit and a semantic prediction unit, and has an embedded dynamically updated hash index table; inputting the edge service scenario and the sharding granularity constraint into the dual-mode predictor, the temporal prediction unit dynamically adjusts the longest matching order based on variable-order Markov to predict the access data block sequence; the semantic prediction unit uses executable reasoning based on semantic dependencies to determine the function call graph and the control flow graph; and generating the consistent hash link by weighted reconstruction of the access data block sequence, the function call graph, and the control flow graph.

[0077] Furthermore, the iterative optimization allocation module 13 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used for: constructing a weighted undirected graph for the set of edge nodes, wherein the edge weight is the transmission cost, and the transmission cost is obtained by normalizing and weighting bandwidth, latency, packet loss rate and node load; determining a first initial particle based on the consistent hash link according to the weighted undirected graph; determining the optimization direction based on the first initial particle with load balancing and transmission efficiency, performing iterative optimization to determine a second set of optimized particles, and selecting a container slice scheduling scheme through optimization of a preset number of iterations.

[0078] Furthermore, the iterative optimization allocation module 13 in the intelligent fusion terminal cloud-edge integrated management system under the containerization technology is also used for: the first initial particle is any neighbor connection scheme based on the task edge node, the particle position is encoded as a neighbor allocation matrix, the velocity represents the adjustment direction of the neighbor relationship, and the fitness function is an estimated value of the container slice distribution completion time based on the consistent hash link; wherein, the neighbor allocation matrix includes first-order call node allocation and second-order container slice allocation.

[0079] Furthermore, the dynamic network tunnel update module 14 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used for: periodically collecting network fingerprint vectors at the edge nodes, determining the optimal network fingerprint at the next moment through state transition probability measurement; calculating the difference between the network fingerprint vector and the optimal network fingerprint, and if a preset threshold is met, determining that the network environment has changed and generating a tunnel reconstruction instruction; and matching the tunnel parameter template library maintained in the cloud according to the tunnel reconstruction instruction, and performing tunnel reconstruction management.

[0080] Furthermore, the dynamic network tunnel update module 14 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used for: performing multi-dimensional comprehensive sorting after objective weighting using the entropy weight method according to the tunnel parameter template library to determine the matching result, wherein the matching result includes the optimal tunnel type and parameter combination, and the comprehensive sorting dimension includes bandwidth matching degree, latency constraint satisfaction degree, packet loss rate tolerance and encryption computation overhead; maintaining a shared memory queue in the kernel network stack, taking over unconfirmed data packets in the original tunnel according to the shared memory queue, and completing tunnel reconstruction by performing new tunnel reconstruction based on the matching result and lossless migration of unconfirmed data packets; and establishing a control plane connection between the edge node and the cloud to restore configuration synchronization and status reporting.

[0081] Furthermore, the distributed invocation module 15 in the intelligent converged terminal cloud-edge integrated management system under the containerization technology is also used to: employ a dynamically updated network tunnel to execute a first container slice priority invocation based on neighboring edge nodes and a second container slice invocation based on the cloud, based on the container slice scheduling scheme, and perform reorganization and business-driven operations locally on the edge nodes; as the business-driven process progresses, each edge node continuously monitors the slice page fault frequency, and triggers a split when the page fault frequency of any container slice exceeds a first preset threshold, using binary rewriting to identify high-frequency accessed continuous sub-blocks in the corresponding container slice as independent new container slices, registering the new slice fingerprint in the hash index table, and marking the original container slice as incomplete; when the page fault frequencies of adjacent container slices are all lower than a second preset threshold, a merge is triggered, and the slice content is reorganized and updated to the hash index table.

[0082] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Figure 1 The containerization technology-based intelligent converged terminal cloud-edge integrated management method and specific examples in Example 1 are also applicable to the containerization technology-based intelligent converged terminal cloud-edge integrated management system in this example. Through the foregoing detailed description of the containerization technology-based intelligent converged terminal cloud-edge integrated management method, those skilled in the art can clearly understand the containerization technology-based intelligent converged terminal cloud-edge integrated management system in this example. Therefore, for the sake of brevity, it will not be described in detail here.

[0083] The above description of the disclosed embodiments enables those skilled in the art to make or use this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

[0084] Obviously, those skilled in the art can make several improvements and modifications to this application without departing from the principles of this application, and these improvements and modifications also fall within the protection scope of this application.

Claims

1. A cloud-edge integrated management method for intelligent converged terminals under containerization technology, characterized in that: include: Adaptive sharding is performed on the container architecture stored in the cloud to obtain container slices distributed across the cluster; A hash index table is constructed based on the container slice mapping, distributed to each edge node and embedded in the dual-mode predictor. Each edge node performs parallel prediction based on time sequence and semantics according to its local edge business scenario and network status, and obtains a consistent hash link. By constructing a weighted undirected graph based on the set of edge nodes, and iteratively optimizing the allocation of container slice scheduling according to the consistent hashing link, a container slice scheduling scheme is determined. The network tunnel is dynamically updated by periodic collection and state transition prediction based on network fingerprint vectors; Based on the dynamically updated network tunnel, the container slicing scheduling scheme is used to perform distributed container slicing calls based on the parallel operation of neighboring edge nodes and the cloud, and to execute local edge service-driven management.

2. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 1, characterized in that, For container architectures in cloud storage, a dynamic sliding window is used to adaptively shard containers and determine container slices; Adaptive sharding includes: Based on access frequency and local time characteristics, a greedy aggregation method is used to perform first-order partitioning of the container to determine the first partitioning result. Perform second-order sharding on the container based on business relevance to determine the second sharding result; The intersection of the first sharding result and the second sharding result is used to determine the first container slice set, and the union of the first and second sharding results is used to determine the second container slice set. The combined set is used as the container slice.

3. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 1, characterized in that, The dual-mode predictor performs parallel prediction based on time and semantics to obtain a consistent hashing link, including: For the container slice, generate a hash fingerprint and construct a hash index table; The edge node obtains the hash index table from the cloud, initializes the dual-mode predictor, determines the sharding granularity constraint based on the network bandwidth and latency characteristics of the edge node, and determines the consistent hash link in combination with the edge business scenario.

4. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 3, characterized in that, Determine the consistent hashing link, including: Construct a dual-mode predictor, wherein the dual-mode predictor includes a temporal prediction unit and a semantic prediction unit, and has an embedded dynamically updated hash index table; The edge service scenario and the sharding granularity constraint are input into the dual-mode predictor. The time-series prediction unit dynamically adjusts the longest matching order based on variable-order Markov to predict the access data block sequence. The semantic prediction unit uses executable reasoning based on semantic dependencies to determine the function call graph and control flow graph; The consistent hashing link is generated by weighting and reconstructing the access data block sequence, function call graph, and control flow graph.

5. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 1, characterized in that, Determine the container slicing scheduling scheme, including: For the set of edge nodes, a weighted undirected graph is constructed, where the edge weight is the transmission cost, which is obtained by normalizing and weighting bandwidth, latency, packet loss rate and node load. Based on the weighted undirected graph, determine the first initial particle based on the consistent hashing link; Based on the first initial particle, the optimization direction is determined by load balancing and transmission efficiency. Iterative optimization is performed to determine the second set of optimized particles. Through optimization of a preset number of iterations, a container slicing scheduling scheme is selected.

6. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 5, characterized in that, The first initial particle is any neighbor connection scheme based on the task edge node, the particle position is encoded as a neighbor allocation matrix, the velocity represents the adjustment direction of the neighbor relationship, and the fitness function is an estimate of the container slice distribution completion time based on the consistent hash link. The neighbor allocation matrix includes first-order retrieval node allocation and second-order container slice allocation.

7. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 1, characterized in that, The network tunnel is dynamically updated using periodic data collection and state transition prediction based on network fingerprint vectors, including: Edge nodes periodically collect network fingerprint vectors and determine the optimal network fingerprint for the next time step by measuring the state transition probability. The difference between the network fingerprint vector and the optimal network fingerprint is calculated. If the difference meets a preset threshold, it is determined that the network environment has changed and a tunnel reconstruction command is generated. Based on the tunnel reconstruction instruction, a matching process is performed in the tunnel parameter template library maintained in the cloud to execute tunnel reconstruction management.

8. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 7, characterized in that, Matching is performed in the tunnel parameter template library maintained in the cloud to execute tunnel reconstruction management, including: Based on the tunnel parameter template library, after objective weighting using the entropy weight method, a multi-dimensional comprehensive sorting is performed to determine the matching result. The matching result includes the optimal tunnel type and parameter combination. The comprehensive sorting dimensions include bandwidth matching degree, latency constraint satisfaction degree, packet loss rate tolerance, and encryption computation overhead. By maintaining a shared memory queue in the kernel network stack, unacknowledged data packets in the original tunnel are taken over according to the shared memory queue, and tunnel reconstruction is completed by performing new tunnel reconstruction based on the matching results and lossless migration of unacknowledged data packets. Edge nodes establish control plane connections with the cloud to restore configuration synchronization and status reporting.

9. The intelligent converged terminal cloud-edge integrated management method under containerization technology as described in claim 1, characterized in that, Perform local edge service-driven management, including: A dynamically updated network tunnel is used to execute the first container slice priority call based on the neighboring edge node and the second container slice call based on the cloud based on the container slice scheduling scheme, and the reorganization and business drive are performed locally on the edge node. As the business progresses, each edge node continuously monitors the page fault frequency of the slice. When the page fault frequency of any container slice exceeds the first preset threshold, a split is triggered. Binary rewriting is used to identify the high-frequency accessed continuous sub-blocks in the corresponding container slice as independent new container slices. The fingerprint of the new slice is registered in the hash index table, and the original container slice is marked as incomplete. When the page fault frequency of adjacent container slices is lower than the second preset threshold, a merge is triggered, the slice content is reorganized, and the hash index table is updated.

10. A cloud-edge integrated management system for intelligent converged terminals based on containerization technology, characterized in that: The steps for implementing the containerization technology-based intelligent converged terminal cloud-edge integrated management method according to any one of claims 1 to 9, wherein the containerization technology-based intelligent converged terminal cloud-edge integrated management system comprises: The adaptive sharding module is used to adaptively shard the container architecture stored in the cloud to obtain container slices distributed across the cluster. The dual-mode prediction module is used to construct a hash index table based on the container slice mapping, distribute it to each edge node and embed it in the dual-mode predictor. Each edge node performs parallel prediction based on time sequence and semantics according to the local edge service scenario and network status, and obtains a consistent hash link. The iterative optimization allocation module is used to construct a weighted undirected graph based on the edge node set, and perform iterative optimization allocation of container slice scheduling according to the consistent hash link to determine the container slice scheduling scheme. The dynamic network tunnel update module is used to dynamically update the network tunnel based on periodic collection and state transition prediction of network fingerprint vectors. The distributed invocation module is used to perform distributed container slice invocation based on the dynamically updated network tunnel and the container slice scheduling scheme, which is based on the parallel operation of neighboring edge nodes and the cloud, and to execute local edge service-driven management.

Images