Container access traffic management methods and electronic devices

By bypassing container status monitoring and dynamically adjusting traffic weights, the problem of containers being unable to handle large-scale requests in the early stages of startup is solved, achieving secure and smooth traffic access and reducing development and operation costs.

CN123123264APending Publication Date: 2026-11-17TP-LINK
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611170455.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-03
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In microservices and cloud-native architectures, if containers are not fully prepared at the initial startup stage, directly receiving large-scale concurrent network service requests can easily lead to processing timeouts, resource exhaustion, or crashes. Existing solutions that modify the business application layer code or the underlying network distribution components have problems such as high development costs or wide impact.

Method used

By bypassing the container's running status, a baseline time is obtained, and network service weights are dynamically adjusted based on runtime. Configuration instructions are then generated to gradually adapt to traffic, avoiding direct modification of the source code and underlying network components.

Benefits of technology

It improves the security and smoothness of the container preheating process, reduces the risk of crashes, ensures a smooth transition of business traffic, and reduces development and operation costs.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123123264A_ABST
    Figure CN123123264A_ABST
Patent Text Reader

Abstract

This application provides a container access traffic management method and electronic device. The method includes: when a target running container carrying a preheating identifier is detected, bypassing and monitoring the running status of the target running container; when the running status of the target running container is ready to provide external services, obtaining a reference time; determining the runtime between the current time and the reference time according to a preset adjustment period; after each determination of the runtime, updating the network service weight allocated to the target running container according to the runtime, and generating a configuration instruction based on the network service weight, wherein the configuration instruction is used to cause a network request distribution node to release network service traffic to the target running container according to the network service weight. Through this application, it is possible to manage the traffic accessing the container without modifying the existing source code, enabling the container to gradually adapt to accessing complete network service traffic.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a container access traffic management method and electronic device. Background Technology

[0002] In microservices and cloud-native architectures, applications are typically packaged and deployed in containers. During the initial startup phase, although the basic processes are established, the internal runtime environment of a container is not yet fully prepared to handle large volumes of traffic. If a gateway directly releases a large number of concurrent network requests to the container at this time, it can easily lead to processing timeouts, exhaustion of system resources, or even container crashes due to sudden overload. Summary of the Invention

[0003] This application provides a container access traffic management method and electronic device, which can manage the traffic accessing the container without modifying the existing source code, enabling the container to gradually adapt to accessing the full network service traffic.

[0004] The technical solution of this application embodiment is implemented as follows: This application provides a container access traffic management method, the method comprising: When a target running container carrying a preheating flag is detected, the operating status of the target running container is monitored in bypass mode. When the target running container is in the running state of ready to provide external services, the baseline time is obtained; According to the preset adjustment period, the runtime between the current time and the reference time is determined. After each determination of the runtime, the network service weight allocated to the target running container is updated according to the runtime, and a configuration instruction is generated according to the network service weight. The configuration instruction is used to enable the network request distribution node to release network service traffic to the target running container according to the network service weight.

[0005] This application provides an electronic device, the electronic device comprising: Memory is used to store executable instructions or computer programs. When a processor executes computer-executable instructions or computer programs stored in the memory, it implements the container access traffic management method provided in the embodiments of this application.

[0006] The embodiments of this application have the following beneficial effects: This application embodiment improves access security during container warm-up and achieves independent management by bypassing the monitoring of the target container's running status and generating configuration instructions. This prevents traffic management control logic from directly intruding into or modifying the actual traffic distribution link, thus avoiding strong coupling between the warm-up function and the basic network execution steps. Furthermore, by updating the network service weights allocated to the target container based on runtime, the original single ready state switching is transformed into a control mechanism that dynamically adjusts the state cyclically based on runtime. This ensures that the traffic allocated to the target container gradually increases over time, improving the smoothness and resilience of the container warm-up process. It also reduces the risk of the container crashing due to a sudden surge in concurrent requests at the moment of readiness, ensuring a smooth transition of service traffic access during the cold start phase of the target container. Attached Figure Description

[0007] Figure 1 This is a schematic diagram of the container access traffic management system architecture provided in an embodiment of this application; Figure 2 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application; Figure 3 This is a schematic diagram of the first process of the container access traffic management method provided in the embodiments of this application; Figure 4 This is a schematic diagram of the second process of the container access traffic management method provided in the embodiments of this application; Figure 5 This is a schematic diagram of the third process of the container access traffic management method provided in the embodiments of this application; Figure 6 This is a schematic diagram of the fourth process of the container access traffic management method provided in the embodiments of this application; Figure 7 This is a schematic diagram of the fifth process of the container access traffic management method provided in the embodiments of this application; Figure 8 This is a schematic diagram of the sixth process of the container access traffic management method provided in the embodiments of this application; Figure 9 This is a schematic diagram of the seventh process of the container access traffic management method provided in the embodiments of this application; Figure 10 This is a schematic diagram of the eighth process of the container access traffic management method provided in the embodiments of this application; Figure 11 This is a schematic diagram of the ninth process of the container access traffic management method provided in the embodiments of this application; Figure 12 This is a schematic diagram of the architecture of the container orchestration system provided in the embodiments of this application; Figure 13This is a flowchart illustrating the container access traffic management method provided in this application embodiment in an application scenario.

[0008] It should be noted that the terms "first" and "second" mentioned above are only used to distinguish between different options and do not represent the degree of superiority or inferiority of the options or their priority in the implementation process. Detailed Implementation

[0009] To make the objectives, technical solutions, and advantages of this application clearer, the application will be further described in detail below with reference to the accompanying drawings. The described embodiments should not be regarded as limitations on this application. All other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0010] In the following description, references are made to “some embodiments,” which describe a subset of all possible embodiments. However, it is understood that “some embodiments” may be the same subset or different subsets of all possible embodiments and may be combined with each other without conflict.

[0011] Unless otherwise defined, all technical and scientific terms used in the embodiments of this application have the same meaning as commonly understood by one of ordinary skill in the art. The terminology used in the embodiments of this application is for the purpose of describing the embodiments of this application only and is not intended to limit this application.

[0012] In microservices and cloud-native architectures, such as container orchestration systems (Kubernetes, K8s) clusters, applications are typically packaged and deployed in container groups. A container group can include at least one container; for improved stability and ease of maintenance, a container group usually contains only one container. In related technologies, although the underlying operating system processes are started during the initial scheduling and startup of a container, the internal business runtime environment, such as Just-In-Time (JIT) compilation of the Java Virtual Machine (JVM), initialization of the Transmission Control Protocol (TCP) connection pool, and caching of hot data, typically takes a considerable amount of time to become fully ready. If a container's liveness is determined solely by a simple underlying health probe, and a network gateway or load balancer directly releases large-scale concurrent online network service requests (traffic) to that container, the instantaneous load can easily exceed the container's current processing baseline, leading to CPU resource exhaustion, thread pool overload, widespread request timeouts, and even causing newly started containers to crash. To avoid errors caused by cold starts (i.e., relying solely on health probes for judgment), a container preheating mechanism is typically introduced. Container preheating usually involves two methods: one is modifying the application layer code to add preheating detection logic within the application startup and actively registering initial weights with the load balancer; the other is a "low-level intrusion" approach, which directly modifies the underlying cluster network distribution components, such as the core source code of the Load Balancer (LB Service) controller, directly coupling the preheating logic into the main traffic scheduling process. The specific execution steps are typically as follows: after detecting container readiness, a fixed delay is forcibly set for a certain period. After this delay, all traffic is released at once, or traffic is switched in stages according to a few preset static thresholds (e.g., releasing 50% after 20 seconds).

[0013] However, modifying the application layer code is not friendly to existing legacy services, requiring the embedding of specific software development kits in each business project, incurring high development costs for modifying legacy code. Furthermore, this low-level intrusion approach deeply binds the preheating logic to the system's native container creation and basic network links. If the control module controlling the preheating logic malfunctions or experiences a brief network outage, it typically directly blocks the normal operation of the basic network, causing newly created containers to be stuck indefinitely at the creation node, resulting in a wide-ranging impact. Secondly, the existing traffic control mechanism is too rigid. Whether it's full access after a fixed delay or timed switching between a few levels, both are coarse-grained, step-like traffic releases. When the fixed delay node arrives, the sudden surge of concurrent traffic can easily overwhelm containers that are not yet fully prepared.

[0014] Based on the problems existing in related technologies, this application provides a container access traffic management method and electronic device. Without modifying existing source code, it manages the traffic accessing containers, enabling the containers to gradually adapt to accessing complete network service traffic. The following describes an exemplary application of the server provided in this application. The device provided in this application can be implemented as various types of terminals such as laptops, tablets, desktop computers, smartphones, and switches, or it can be implemented as a server. The following will describe an exemplary application when the device is implemented as a server.

[0015] See Figure 1 , Figure 1 This is a schematic diagram of the architecture of the container access traffic management system provided in this application embodiment. To support a container access traffic management operation, a container access traffic management application can be provided. For example, the container access management application can be an application dedicated to container access traffic management, or it can be a functional module in other applications (such as a traffic management module in a container orchestration system). The container access traffic management system 100 in this application embodiment includes at least a server 200 and may also include a terminal 400. The server 200 is the server for the container access traffic management application, that is, the container access traffic management method of this application embodiment is implemented through the server 200. The terminal 400 is connected to the server 200 through a network 300, which can be a wide area network (WAN), a local area network (LAN), or a combination of both. The terminal 400 can be a device that sends concurrent network service requests (traffic) to the server 200.

[0016] In some embodiments, the electronic device may be Figure 1 Server 200, see [link / reference] Figure 2 , Figure 2 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Figure 2The illustrated electronic device includes at least one processor 210, a memory 250, at least one network interface 220, and a user interface 230. The various components of the electronic device are coupled together via a bus system 240. It is understood that the bus system 240 is used to implement communication between these components. In addition to a data bus, the bus system 240 also includes a power bus, a control bus, and a status signal bus. However, for clarity, ... Figure 2 The general labeled all buses as Bus System 240.

[0017] Processor 210 can be an integrated circuit chip with signal processing capabilities, such as a general-purpose processor, a digital signal processor (DSP), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Among them, the general-purpose processor can be a microprocessor or any conventional processor, etc.

[0018] User interface 230 includes one or more output devices 231 that enable the presentation of media content, including one or more speakers and / or one or more visual displays. User interface 230 also includes one or more input devices 232, including user interface components that facilitate user input, such as a keyboard, mouse, touch screen display, other input buttons and controls.

[0019] The memory 250 can be removable, non-removable, or a combination thereof. Exemplary hardware devices include solid-state storage, hard disk drives, optical disk drives, etc.

[0020] The memory 250 may include volatile memory or non-volatile memory, or both.

[0021] In some embodiments, memory 250 is capable of storing data to support various operations, examples of which include programs, modules, and data structures or subsets or supersets thereof, as illustrated below.

[0022] Operating system 251 includes system programs for handling various basic system services and performing hardware-related tasks, such as the framework layer, core library layer, driver layer, etc., for implementing various basic business functions and handling hardware-based tasks; The network communication module 252 is used to reach other electronic devices via one or more (wired or wireless) network interfaces 220, exemplary network interfaces 220 including: Bluetooth, WiFi, and Universal Serial Bus (USB), etc. The presentation module 253 enables the presentation of information (e.g., a user interface for operating peripheral devices and displaying content and information) via one or more output devices 231 associated with the user interface 230 (e.g., a display screen, a speaker, etc.). The input processing module 254 is used to detect and translate one or more user inputs or interactions from one or more input devices 232.

[0023] In some embodiments, the apparatus provided in this application can be implemented in software. Figure 2 A container access traffic management device 255 stored in memory 250 is shown. This device can be software in the form of programs and plug-ins, and includes the following software modules: a bypass monitoring module 2551, a reference time acquisition module 2552, and a weight adjustment module 2553. These modules are logically linked and can therefore be arbitrarily combined or further separated depending on the functions they implement. The functions of each module will be described below.

[0024] See Figure 3 , Figure 3 This is a first flowchart illustrating the container access traffic management method provided in this application embodiment, which will be combined with... Figure 3 The steps shown are explained as follows: Figure 3 As shown, the implementation subject of the container access traffic management method is a server as an example. The server 200 is a server with a container orchestration system. In this embodiment of the application, the container group includes a container as an example. The method includes the following steps 101 to 103.

[0025] In step 101, when a target running container carrying a preheating flag is detected, the running status of the target running container is monitored by bypass.

[0026] Here, bypass monitoring refers to the process of independently obtaining system state change information through an asynchronous event subscription mechanism, without directly blocking or modifying the original basic creation link of the main control system, by acting as an external observer.

[0027] In some embodiments, during the container creation or instantiation phase, relevant identification information is pre-configured or dynamically assigned to the container's attribute area in conjunction with specific strategies. Therefore, the system only needs to identify and filter objects carrying the corresponding identification information from the global runtime objects as target runtime containers.

[0028] In some embodiments, bypassing the monitoring of the target running container's running status can be achieved by establishing an asynchronous data acquisition pipeline with the underlying cluster state management components. For example, the latest lifecycle and health status updates of the target running container can be continuously and non-intrusively obtained through the container orchestration system's native list / watch mechanism, message callbacks, or independent polling interfaces.

[0029] In microservice architectures and container orchestration systems, container instances are often highly dynamic and volatile. As business traffic fluctuates, the system automatically triggers elastic scaling of a large number of containers. Requiring developers to hard-code preheating configurations into the image environment or business code of each specific container is not only highly intrusive and requires significant modification work, but also extremely unfriendly to existing legacy services. Furthermore, directly issuing configurations to individual containers is difficult to handle new instances generated by automatic cluster scaling. To achieve zero-intrusion preheating control over legacy services and ensure that preheating attributes automatically cover all new instances, this application proposes the following steps.

[0030] In some embodiments, see Figure 4 Before detecting a target operating container carrying a preheating identifier, steps 107 to 109 may also be performed.

[0031] In step 107, the container creation request is intercepted.

[0032] Here, interception refers to the intermediate layer capture action performed on the instantiation instruction after the application programming interface (API) server of the container orchestration system receives the instantiation instruction and before the container node is actually created and stored persistently in the container orchestration system.

[0033] In some embodiments, intercepting container creation requests can be achieved by leveraging native admission control plugins of the cluster system, such as webhooks in container orchestration systems. When the container orchestration system issues an API request message for scaling up or creating a new container, the interceptor suspends the message before it takes effect and reads the resource manifest (such as metadata in YAML or JavaScript Object Notation, JSON) contained in the creation request to obtain the expected resource attributes of the container.

[0034] In step 108, the target warm-up duration pre-configured for the container is read from the deployment object based on the creation request.

[0035] Here, a Deployment refers to a high-level control component at the cluster or even the entire application level that is responsible for the overall management and maintenance of a set of identical container replicas in the desired state. The target warm-up duration is a configuration parameter declared upfront at the application level.

[0036] In some embodiments, tracing the creation request and retrieving information can be achieved as follows: Parse the intercepted creation request message, extract the OwnerReference field, and trace back layer by layer upwards according to the hierarchical pointer of this reference field until the specific deployment object controlling the container is located. Then, read the declarative configuration record of the deployment object (e.g., the Metadata Annotation area) and check whether the target warmup duration (e.g., warmup-seconds: "300") declared by the user through a simple configuration command has been pre-filled.

[0037] In step 109, after reading the target preheating duration, a container is created according to the creation request, and a preheating flag is added to the container by writing the configuration, thus obtaining the target running container.

[0038] Here, writing configuration refers to dynamically patching specific fields in the original request message without disrupting the original main creation chain of the container orchestration system.

[0039] In some embodiments, this step can be implemented as follows: When the target warm-up duration is successfully retrieved in the traced deployment object, it indicates that the application has actively enabled the warm-up function. At this time, the system will modify the original container creation request, dynamically writing a specific warm-up identifier (e.g., injecting Label: warmUp: true) into the label or metadata of the container to be built. After injection, the system will allow the modified message to the underlying creation component to continue the physical container startup instantiation operation. Containers with these specific injected identifiers become the "target running containers" that the subsequent bypass listening process seeks. Conversely, if the target warm-up duration is not read, it will be allowed to start normally as is. In addition, a count field (i.e., the initial count threshold previous-restart) will also be written in this step to record the container restart history.

[0040] This application's embodiment achieves declarative, zero-intrusion preheating configuration distribution by intercepting requests during container creation, tracing back to the advanced deployment object to read the duration configuration, and dynamically dispatching preheating flags to container instances via patch writing. This operation allows subsequent containers to automatically access and inherit preheating management by simply adding a single line of declaration to the global application-level deployment object, without modifying the underlying image or application source code. This reduces the cost of modifying existing services to integrate preheating functionality and the complexity of operation and maintenance management.

[0041] In step 102, when the target running container is in the state of ready to provide external services, the baseline time is obtained.

[0042] Here, "ready to serve externally" means that the basic processes inside the target container have been started and passed the corresponding runtime environment considerations, and are ready to receive and process external real network service requests.

[0043] In some embodiments, the running status of the target running container can be constructed and determined in the following way: The underlying cluster management mechanism of the container orchestration system usually sends specific instructions to the application inside the container to evaluate its health. When the determination result meets the set conditions, the underlying probe will automatically mark the container's status parameter from the Unready state to the Ready state. In this case, the status change signal can be directly obtained, thereby determining that the running status of the target running container is ready to provide external services.

[0044] In some embodiments, the baseline time can be obtained as follows: once the target running container is detected to have switched to a service-ready state, a timestamp extraction operation is performed immediately. For example, this can be done by calling the system clock function of the environment where the executor resides, or by directly extracting the occurrence timestamp from the system state switching event message, which can then be used as the baseline time starting point for the container to begin subsequent traffic allocation processes.

[0045] In some embodiments, within a microservice cluster environment (container orchestration system), the internal runtime environment is still in a fragile initial construction phase. At this time, containers are prone to crashing due to sudden failures such as internal program initialization failures or resource overflows. In such cases, the underlying infrastructure of the container orchestration system typically automatically restarts the container's core process. Without independent intervention for such abnormal interruptions, the internal resources of a newly restarted container are already zeroed out, but the system may have a time lag in status determination, leading to the container being incorrectly allowed to proceed and directly judged as ready to provide external services, thus prematurely triggering the process of obtaining baseline time and allocating network service weights. Unprepared containers, once allocated traffic prematurely, are highly susceptible to instantaneous breakdowns and secondary crashes. Therefore, to strictly control the security threshold of traffic scheduling and ensure that only containers truly free from abnormal interruptions can enter the subsequent weight adjustment phase, this application proposes the following steps.

[0046] In some embodiments, see Figure 5 Before the target running container is ready to provide external services, steps 104 to 105 can be executed.

[0047] In step 104, the restart count value of the target running container is recorded, where the restart count value is the number of times the target running container is restarted after a failure.

[0048] Here, the restart count refers to the cumulative number of times a container instance crashes due to an internal process error or other underlying anomalies during the initial stage of its lifecycle, and is automatically restarted in situ by the container cluster management system (e.g., the restart count field recorded in the container's underlying properties).

[0049] In some embodiments, recording the restart count of the target running container can be achieved as follows: Utilizing the aforementioned asynchronous listening pipe connected to the cluster's underlying layer, the latest running status message of the target running container is read cyclically during the waiting period before the container is ready. The specific numbers representing the container's restart history are parsed and extracted from the messages, serving as the current objective restart count. Furthermore, the system can continuously write the obtained numbers as configuration patches into the configuration attribute comment fields of the target running container (e.g., a custom tag "previous-restart"), saving them as baseline data to facilitate observation of the container's status trend.

[0050] In step 105, if the restart count value is greater than a preset count threshold, the running state of the target running container is set to the reset state.

[0051] Here, the preset count threshold (previous-restart) refers to the acceptable number of restarts for the target running container. This number can be a preset value or a value that changes dynamically according to a set pattern. The reset state means reversing the logical progress of the container towards the external service ready state, forcibly reverting it to the most original suspended or ready state.

[0052] In some embodiments, setting the running state of the target container to a reset state can be achieved by comparing the current restart count value with a preset count threshold during each monitoring poll. Once it is confirmed that the current restart count value is greater than the preset count threshold, it indicates that the container has just experienced a hidden crash and restart during this period. Since the newly restarted container does not have the conditions to take over the flow, the system immediately generates a state overwrite instruction to intercept the "ready" flag that the container may have previously retained or was about to become, and forcibly rewrites and downgrades the fields used to characterize the warm-up process to a reset state (e.g., "pending" state). This cuts off the abnormal container from directly entering the subsequent steps of obtaining the baseline time and adjusting the weights.

[0053] This application embodiment continuously compares the restart count value with the count threshold before the target running container is ready to provide external services. This can accurately identify abnormal containers that have experienced underlying crashes before they are truly ready. By using a forced reset callback, it blocks the risk of abnormal containers obtaining a base time and being incorrectly allowed to pass traffic in the early stages. This ensures that the traffic preheating logic is not interfered with by abnormal containers and improves the system's resistance to avalanche accidents caused by abnormal cold starts.

[0054] In some embodiments, when a target running container is intercepted by the system and set to a reset state due to an abnormal restart, the container orchestration system will still continue to drive the container to re-initialize its internal processes. However, if in subsequent state checks, the container orchestration system still relies on the old count threshold before the interception as a comparison reference, then in each subsequent comparison, the currently increased restart count value will be greater than the old threshold. This will cause the system to incorrectly determine that a single historical restart of the container has occurred as countless new restarts, causing the container to fall into an endless detection loop of forced resets, never progressing to a true service-ready state. Therefore, this application proposes the following steps.

[0055] In some embodiments, see Figure 6 If the restart count value is greater than the preset count threshold, the following step 106 can also be performed.

[0056] In step 106, the counting threshold is updated to the restart count value recorded before the running state was set to the reset state.

[0057] Here, updating the counting threshold refers to refreshing and synchronizing the underlying baseline used by the system to determine whether a container has experienced a new round of abnormal interruption, so that the system's error-proof monitoring logic can adapt to container processes that have been stably restarted.

[0058] In some embodiments, updating the counting threshold can be achieved as follows: Upon triggering a reset action for an abnormal container state, the system synchronously extracts the latest restart count value that caused this over-limit interception, and writes this latest restart count value back to the physical annotation field used to store the comparison baseline through an overwrite operation, upgrading it to a new counting threshold. For example, if the system originally recorded a counting threshold of 0, and after a container crashes and is restarted by the underlying layer, the restart count value read by the system becomes 1; at this time, while intercepting its traffic ready state, the system synchronously updates the saved counting threshold from 0 to 1. When the next polling cycle arrives, the system compares the new threshold (1) with the current count value (1), and finds that they are equal, indicating that the container has not crashed again during this period, thus allowing the container to legally and smoothly proceed to the determination of external service readiness and subsequent warm-up process.

[0059] This application embodiment updates the counting threshold to the latest restart count value recorded before the state reset is triggered. This avoids the infinite loop caused by the container orchestration system continuously using old baseline values ​​for state comparison, which would result in the target running container being reset indefinitely. It ensures that after the target running container undergoes a restart and the process stabilizes again, it can normally proceed to the determination stage of service readiness and the subsequent warm-up process. This guarantees the consistency and robustness of the overall traffic management and state detection logic throughout the container's lifecycle.

[0060] In step 103, the runtime between the current time and the base time is determined according to the preset adjustment period. After each determination of the runtime, the network service weights allocated to the target running container are updated according to the runtime, and configuration instructions are generated according to the network service weights. The configuration instructions are used to enable the network request distribution node to release network service traffic to the target running container according to the network service weights.

[0061] Here, network service weight refers to a scheduling parameter used to measure and characterize the proportion or limit of traffic that the target running container can receive in the context of concurrent network request allocation.

[0062] In some embodiments, the preset adjustment period can be a constant time interval (such as 10 seconds) pre-designed by the system, or a period parameter configured based on hardware load. Whenever the period interval is reached to trigger calculation, the system can directly read the latest system timestamp to obtain the current time.

[0063] In some embodiments, updating the network service weights allocated to the target runtime container based on runtime and generating configuration instructions based on these weights can be achieved as follows: Using pre-defined mapping rules or mathematical models, runtime is converted into corresponding quota values, with the quota value evolving accordingly for longer time spans. Subsequently, this quota value is encapsulated into a control message (configuration instruction). For example, a specific incremental function can be used to map the time difference to progressively increasing weight values, and according to a communication protocol format recognizable by the network request distribution node, this weight value is packaged to generate a corresponding control message and sent to the distribution node, thereby enabling the distribution node to physically control the inflow of concurrent traffic.

[0064] In some embodiments, see Figure 7 The network service weights assigned to the target running container based on runtime can be updated through the following steps 1031 to 1032.

[0065] In step 1031, the target preheating time, weight lower limit, and weight upper limit of the target running container are obtained.

[0066] Here, the target warm-up time refers to the total time span required for a container to go from initially entering the traffic scheduling queue to fully being able to handle peak traffic allocation, as set by the system; while the lower limit and upper limit of the weight refer to the minimum and maximum extreme values ​​of the traffic allocation ratio boundary during the control process.

[0067] In some embodiments, the target warm-up duration, weight lower limit, and weight upper limit can be persistently entered in advance as specific parameter attributes in the cluster's declarative deployment script (such as the application's configuration file) or global configuration center, serving as preset boundary conditions for the system's initial scheduling.

[0068] In step 1032, the network service weight is calculated based on the runtime, target warm-up time, lower weight limit, and upper weight limit.

[0069] In some embodiments, a dynamic adjustment operator that is correlated with time progress and weight capacity can be constructed, so that the calculated network service weight value continuously approaches the upper limit of the weight as the runtime increases, thereby enabling the network service weight to gradually move from the lower limit of the weight to the upper limit of the weight.

[0070] This application embodiment obtains the pre-configured target warm-up time of the target running container and the extreme value of the weight value as the physical boundary, and calculates the final network weight by combining it with the actual running time, thereby constructing a dynamic traffic weight adjustment mechanism at the control layer. By intervening in the distribution logic according to the constraints of upper and lower limits, containers with different carrying capacities can be quota-managed according to specific warm-up time standards. This improves the adaptive adjustment capability of traffic management strategies for different service characteristics and avoids the proportional allocation deviation caused by coarse-grained fixed-level configuration or static script-written weights.

[0071] In some embodiments, see Figure 8 Step 1032 can be achieved through the following steps 10321 to 10323.

[0072] In step 10321, the difference between the upper limit of the weight and the lower limit of the weight is calculated, as well as the ratio between the running time and the target preheating time is calculated.

[0073] Here, the difference refers to the maximum adjustable span of network traffic weights that the system allows to allocate; while the ratio refers to the percentage or relative coefficient of the progress that the target running container has already experienced in terms of the original total warm-up time span.

[0074] In some embodiments, subtraction and division can be performed by calling the processor's basic arithmetic unit to obtain the difference and ratio, respectively. For example, by executing the formula Difference = Upper Weight Limit - Lower Weight Limit, the difference reflecting the maximum adjustable span is obtained. By executing the formula Ratio = Runtime / Target Warm-up Time for normalization, the ratio representing the processing progress is obtained.

[0075] In step 10322, the asymptotic weight change is calculated based on the product of the difference and the ratio.

[0076] Here, the incremental weight change refers to the amount of traffic quota that the target container should add or increase relative to its basic capacity at the current specific runtime point in time.

[0077] In some embodiments, the asymptotic weight change can be determined by executing the formula asymptotic weight change = difference × ratio through a basic arithmetic unit, thereby utilizing the characteristics of linear mapping to convert the shift ratio on the time axis into the corresponding incremental expectation on the flow allocation dimension.

[0078] In step 10323, the sum of the asymptotic weight change and the lower limit of the weight is calculated to obtain the network service weight.

[0079] Here, the final network service weight refers to the comprehensive traffic access assessment value that the target running container should possess at this current moment. This value is also the absolute target value that is ultimately sent to the load balancing gateway to perform physical actions.

[0080] In some embodiments, the network service weight is obtained by summing the incremental weight change and the weight lower limit. This can be achieved by directly adding the incremental weight change calculated using the time factor, while ensuring the system has a minimum fallback traffic allocation. For example, the expression can be executed by the basic arithmetic unit: Network Service Weight = Weight Lower Limit + Incremental Weight Change. That is, Network Service Weight = Weight Lower Limit + (Current Time - Base Time) × (Weight Upper Limit - Weight Lower Limit) / Target Warm-up Duration. Here, the weight lower limit can be set to 1, and the weight upper limit can be set to 10. The determined network service weight is then packaged and distributed to the network request distribution node that performs network traffic release, such as the Load Balancer Gateway.

[0081] It should be noted that the load balancer (LB) gateway that performs traffic scheduling can be deployed as an internal component within a container orchestration system (Kubernetes, K8s) cluster, or as a standalone hardware or software infrastructure deployed outside of a container orchestration system (Kubernetes, K8s) cluster.

[0082] This application embodiment generates an asymptotic weight change by solving the product of the weight interval difference and the time transition ratio, and then superimposes the weight lower limit to obtain a determined network service weight, thereby constructing a stable linear normalization operator (asymptotic weight change). This operator can smoothly convert discrete time ticks into a linear ramp curve of the actual traffic release progress, avoiding the impact of traffic surges from direct jump switching on the target running container.

[0083] In some embodiments, during the actual periodic polling execution process, the runtime dynamically obtained by the container orchestration system may jump directly beyond the preset target warm-up time due to the existence of discrete periodic step size. If the aforementioned formula is used to forcibly calculate this time, the output network service weight will overflow, thereby breaking the traffic safety tolerance limit of the target running container. Therefore, in order to ensure the accurate allocation of traffic quota for the target running container, the embodiments of this application propose the following steps.

[0084] In some embodiments, see Figure 9 After obtaining the reference time, the following steps 1033 can also be performed.

[0085] In step 1033, if it is determined that the runtime is greater than or equal to the target warm-up time, the network service weight is updated to the upper limit value of the weight.

[0086] In some embodiments, the current dynamic linear calculation logic can be bypassed by introducing month-end convergence and forced coverage logic into the code control flow. For example, a basic comparison defense instruction (e.g., a conditional control statement) can be introduced before each action is executed. When the runtime is found to be greater than or equal to the target warm-up duration, the logic of obtaining the network service weight by summing the progressive weight change and the weight lower limit is directly intercepted and blocked, so as to safely switch the underlying container from the progressive warm-up state to the normal full-capacity service state.

[0087] This application embodiment directly replaces and updates the dynamic operator output with the static weight upper limit value when it is determined that the runtime of the target running container exceeds the target preheating time. This avoids the risk of mathematical overflow caused by the gradual accumulation of runtime and also eliminates redundant back-and-forth time comparison calculations for the target running container, ensuring that the target running container can stably complete the preheating.

[0088] It should be noted that, in order to achieve deep decoupling between the control logic and the basic system link, the bypass monitoring and traffic management process described in the above embodiments of this application actually relies on a two-layer asynchronous control loop built within the bypass controller for collaborative execution. Specifically, steps 104 to 106 constitute the first-layer loop of the controller (anomaly prevention layer). This layer independently performs polling detection of restart events. By continuously comparing the restart count value with the preset count threshold, it promptly returns the container to the reset state when it is found that the container has restarted due to an abnormal crash, thereby preventing "sick" containers from being mistakenly allowed to proceed. Steps 102 to 103 (which may also include subsequent write-back state steps 110 to 111) constitute the second-layer loop of the controller (warm-up state machine driven layer). This layer is activated after the first-layer loop ensures that the container is indeed healthy and has entered the "external service ready" state. It is responsible for cyclically deriving the runtime according to the preset adjustment cycle and progressively updating the network service weight and backfill allocation progress accordingly. By separating anomaly detection and weight ramping into decoupled first-layer and second-layer loops, it can be ensured that anomalies or network jitter in any layer will not block the execution of the other layer, thereby greatly improving the fault tolerance and high availability of container cold start traffic management.

[0089] In some embodiments, the specific preheating process for container access traffic is asynchronously driven in the background by a bypass listening component. Since this process is independent not only of the underlying traffic distribution of the container orchestration system but also of the business code within the application container, the container's preheating progress appears as a "black box" to external monitoring systems. If the real-time computation progress is not explicitly exposed, the operations and maintenance system will find it difficult to determine whether a newly started container is fully ready or undergoing a gradual preheating ramp-up, thus increasing the difficulty of troubleshooting and traffic scheduling management. To provide high transparency and observability to the purely background management process, embodiments of this application propose the following steps.

[0090] In some embodiments, see Figure 10 After generating configuration instructions based on network service weights, the following steps 110 to 111 can also be executed.

[0091] In step 110, the current network service traffic allocation progress of the target running container is obtained, and a status value is generated based on the allocation progress.

[0092] The status value indicates whether the system is waiting to preheat, is in the preheating ramp-up phase, or has completed preheating.

[0093] Here, allocation progress refers to the proportion of the actual runtime of the target running container to the original total target warm-up time, or the degree of approximation between the currently issued network service weights and the upper limit of the weights. The status value is an enumerated label obtained after dividing this numerical progress into macroscopic stages.

[0094] In some embodiments, obtaining the allocation progress and generating status values ​​can be achieved as follows: after each update of the weight configuration, extract the currently calculated runtime data; and perform stage demarcation based on this runtime data. For example, when the runtime is 0 or very small, it is determined that traffic has not yet started, and a stage status value of "awaiting warm-up" (e.g., Pending) is generated; when the runtime is detected to be within the range of being greater than zero and less than the target warm-up duration, a stage status value of "warming up" (Warming) is generated; when the runtime is detected to be greater than or equal to the target warm-up duration, a stage status value of "warming up" (Success) is generated.

[0095] In step 111, the allocation progress and status values ​​are written to the configuration attribute annotation field of the target running container and the container running condition field in the runtime environment. The configuration attribute annotation field and the container running condition field are used to output the allocation progress and status values ​​of the target running container when a query command is received.

[0096] Here, configuration attribute annotation fields (such as Annotation in Kubernetes) refer to extended areas in container metadata used to append arbitrary non-identifiable key-value pairs of states. Container runtime condition fields in the runtime environment (such as PodCondition in Kubernetes) refer to the standard state flow display window natively used by the cluster to show whether a specific runtime phase of a container has met certain criteria. Query commands are standard probe commands initiated by the operations and maintenance terminal (such as the `kubectl describe pod` operation).

[0097] In some embodiments, the field writing operation can be implemented by calling the cluster's interface patch update: after each round of warmup adjustment is completed, not only are the actual underlying network configuration instructions issued, but a status write-back is also initiated to the upper-layer management platform, filling the time and stage status values ​​of the above-mentioned allocation progress back into the metadata of the target running container (for example, writing the identifier "warmup-status:warming" to the comment field to indicate "warmup is in progress"; or writing "failed" or "success" when the status value shows failure or warmup completion). At the same time, the combined parameters "type=WarmupCompleted,status=False" (warming in progress) or "status=True" (warmup completed) are written to the condition field. When operations personnel or automated monitoring scripts view the target running container through general query commands, the underlying API server can directly read these two fields and display them on the standard output panel.

[0098] This application embodiment obtains the allocation progress and status values ​​of network service traffic and writes them back to the native configuration attribute annotation fields and running condition fields of the target running container, giving the status transparency and observability of the background bypass warm-up process. Operations personnel can intuitively grasp the current warm-up stage and detailed progress of each container using basic cluster query commands, without needing to deploy additional customized status monitoring tools or log into the container to explore, significantly improving the operational efficiency of container lifecycle management and the platform's usability.

[0099] In some embodiments, the control module responsible for scheduling and allocation, or the target running container itself, may encounter brief network jitters, momentary service interruptions, or unforeseen short-term restarts. If, after such a sudden interruption, the entire long warm-up progress of the target running container is reset and restarted from scratch, it will not only reduce cluster traffic scheduling efficiency but also waste container computing resources. Since the container orchestration system has persistently stored the historical progress in the annotation field of the system state library in the preceding steps, to enable the warm-up process to resume from where it stops, this application embodiment proposes the following steps after writing the allocation progress and status values ​​into the configuration attribute annotation field of the target running container and the container running condition field in the runtime environment.

[0100] In some embodiments, see Figure 11 After writing the allocation progress and status values ​​into the configuration attribute comment field of the target running container and the container running conditions field in the runtime environment, steps 112 to 114 can be performed.

[0101] In step 112, after detecting that the target running container has interrupted the processing of network service traffic and restarted, the allocation progress in the configuration attribute comment field is parsed.

[0102] Here, "interruption and restart of network service traffic" refers to the situation where the preheating management process, after being halted due to network isolation, controller failure restart, or short-term offline of container network interfaces, resumes normal connection listening. "Resolution" refers to the process of extracting specific parameters from statically stored configuration items.

[0103] In some embodiments, this step can be implemented as follows: When the system detects that a target running container that was previously in the warm-up process has regained connection activity in the cluster, since the container's persistent lifecycle has not completely ended, the container orchestration system reads the configuration attribute annotation fields on the metadata previously persistently mounted to the target running container. Through text matching and extraction, the allocation progress (e.g., the number of seconds of warm-up or the weight ratio already reached) saved in the last write-back before the last interruption is parsed from the attribute annotation fields.

[0104] In step 113, the runtime is re-determined based on the allocation progress obtained from the parsing.

[0105] Here, resetting the runtime means no longer forcibly resetting the preheating time to zero, but instead using the extracted historical progress as the new time starting point or time compensation base.

[0106] In some embodiments, the runtime can be re-determined based on the parsed allocation progress in the following way: After the system re-acquires the current base timestamp, it adds the parsed historical warm-up time (allocation progress) to the subsequent time evolution. For example, if it is parsed that the container has undergone 30 seconds of warm-up before the interruption, the system uses this 30 seconds as the initial compensation value. When the current time resumes and a time span is generated, the actual calculated runtime is directly set to "the newly generated time increment plus the previous 30-second progress", thereby skipping the original 0 to 30-second blank waiting period.

[0107] In step 114, the network service weights allocated to the target running container are updated based on the redefined runtime.

[0108] Here, updating network service weights refers to continuing to drive the linear ramp-up formula of traffic based on the restored and postponed runtime to complete the subsequent allocation command issuance.

[0109] In some embodiments, the actual overall runtime after supplementing historical progress can be directly substituted into the aforementioned gradual change calculation model. Based on the weight value calculated accordingly, the system regenerates configuration instructions and sends them to the load balancing component, controlling the network request distribution node to continue smoothly releasing traffic to the container according to the restored weight quota, until the business traffic weight reaches the weight upper limit.

[0110] This application embodiment extracts the pre-stored allocation progress of the container after the container preheating interruption is recovered, and determines the current runtime and network service weight accordingly. This allows the preheating management process to continue execution closely following the progress before the last network outage or failure. This method avoids the forced zeroing of preheating progress and redundant time recalculation caused by transient link failures, ensuring the continuity, high availability, and smooth state transition of the cluster in large-scale sudden failure scenarios.

[0111] The following will describe an exemplary application of the embodiments of this application in a real-world application scenario.

[0112] The container access traffic management method of this application embodiment is applied to a server equipped with a container orchestration system. See [link to relevant documentation]. Figure 12The container orchestration system is divided into two core areas: the control plane and the data plane. The overall working logic of the container orchestration system is as follows: the user issues a command to the system to deploy an object with a preheating duration annotation, triggering the creation of a container. In the control plane, the network hook interceptor responds to this action, intercepting and injecting preheating metadata into the attribute annotation fields of the target container, thus adding the preheating identifier. In the data plane, the system deploys an independent control component. This component uses a bypass preheating controller's two-layer loop mechanism to continuously write attribute annotation fields to the container to update and expose its preheating status; on the other hand, it outputs weight adjustment operations externally, adjusting the container weight through a load balancer, thereby smoothly controlling the distribution of traffic flowing into the container.

[0113] Figure 13 This is a flowchart illustrating the container access traffic management method provided in this application embodiment in an application scenario. See also... Figure 13 The method includes the following steps.

[0114] Step 201: Send an instruction to create a deployment object with a warm-up seconds annotation.

[0115] In this step, the user submits a deployment instruction with a preheating time declaration to the container orchestration platform interface server, which serves as the starting point for triggering the entire process.

[0116] Step 202: Issue a container group creation request.

[0117] In this step, after receiving the instruction, the container orchestration platform interface server passes the standard creation request to the network hook component at the control plane.

[0118] Step 203: Trace the deployment object to read the preheating configuration.

[0119] In this step, the web hook searches upwards in the background according to the request hierarchy to extract the preheating parameters previously declared by the user.

[0120] Step 204: Inject the warm-up tag and the previous restart annotation as a patch.

[0121] In this step, the network hook dynamically modifies the original request message, writing the initial identifier metadata required for warm-up into the container group to be created.

[0122] Step 205: Container group creation complete.

[0123] In this step, the container orchestration platform interface server, based on the modified request message, enables the underlying platform to complete the physical startup and deployment of the container group.

[0124] Step 206: Get the list / listen for events, provided the warm-up tag is true.

[0125] In this step, the independently operating bypass preheating controller accurately locates and continuously monitors the target container group for preheating control within the global object using this filtering condition.

[0126] Step 207: Execute the first loop and check the restart count.

[0127] In this step, the bypass preheating controller activates an anomaly detection barrier to intercept abnormal container groups that have experienced crashes and restarts, and resets their state to prevent "sick" containers from erroneously entering the preheating process.

[0128] Step 208: The container group becomes ready.

[0129] In this step, if the container group does not experience any abnormalities and the underlying processes start up successfully, its underlying probe status will change, and it will be determined that it is initially ready to provide external services.

[0130] Step 209: Execute the second loop to drive the state machine.

[0131] In this step, after the bypass preheating controller captures the ready signal, it officially takes over and starts the dynamic time calculation and configuration process for flow preheating.

[0132] Then it enters a loop, adjusting every 10 seconds. Within this loop cycle, the following interactive actions are continuously executed: Step 210, send instruction: a function whose weight is equal to the elapsed time.

[0133] In this action, the bypass preheating controller calculates the traffic quota to be released in the current stage by calculating the time increment, and sends the control command containing the latest weight to the corresponding load balancer.

[0134] Step 211: The weight of the flow to the container group gradually increases.

[0135] In this action, the load balancer complies with the command to allow the flow, resulting in a smooth, linear increase in the proportion of concurrent network traffic actually entering the container group.

[0136] After continuous adjustments and time accumulation in the above cycle, the process eventually reaches the following node: Step 212, preheating complete.

[0137] At this node, once the container's runtime reaches the target expectation, the warm-up phase marker is updated to indicate the end, and the container group officially becomes capable of handling full-volume concurrent network traffic.

[0138] The following description continues to illustrate the exemplary structure of the container access traffic management device 255 provided in the embodiments of this application as a software module. In some embodiments, such as Figure 2As shown, the software modules stored in the container access traffic management device 255 in the memory 250 may include: The bypass monitoring module 2551 is used to bypass monitor the running status of the target running container when a target running container carrying a preheating flag is detected. The baseline time acquisition module 2552 is used to acquire the baseline time when the target running container is in the running state of ready to provide external services; The weight adjustment module 2553 is used to determine the runtime between the current time and the base time according to the preset adjustment period. After each determination of the runtime, the network service weights allocated to the target running container are updated according to the runtime, and configuration instructions are generated according to the network service weights. The configuration instructions are used to enable the network request distribution node to release network service traffic to the target running container according to the network service weights.

[0139] This application provides a computer program product including a computer program or computer-executable instructions stored in a computer-readable storage medium. The processor of an electronic device reads the computer-executable instructions from the computer-readable storage medium and executes the computer-executable instructions, causing the electronic device to perform the container access traffic management method described above in this application.

[0140] This application provides a computer-readable storage medium storing computer-executable instructions or a computer program. When the computer-executable instructions or the computer program are executed by a processor, the processor will execute the container access traffic management method provided in this application. For example, ... Figure 3 The container access traffic management method is shown.

[0141] In some embodiments, the computer-readable storage medium may be a memory such as RAM, ROM, flash memory, magnetic surface memory, optical disk or CD-ROM; or it may be a variety of devices including one or any combination of the above-mentioned memories.

[0142] In some embodiments, computer-executable instructions may take the form of programs, software, software modules, scripts, or code, written in any form of programming language (including compiled or interpreted languages, or declarative or procedural languages), and may be deployed in any form, including as stand-alone programs or as modules, components, subroutines, or other units suitable for use in a computing environment.

[0143] As an example, computer-executable instructions can be deployed to execute on a single electronic device, or on multiple electronic devices located at one location, or on multiple electronic devices distributed across multiple locations and interconnected via a communication network.

[0144] In summary, this application's embodiments achieve zero-intrusion access to traffic control for existing services without modifying the source code by intercepting requests and dynamically injecting preheating declarations during the initial container instantiation stage. During the initial container operation, by continuously comparing and restarting historical data and synchronously refreshing thresholds, instances that crash abnormally are promptly intercepted and reset, effectively preventing system-level avalanches caused by premature traffic access to "sick" containers. Beyond this security barrier, by asynchronously monitoring the container status and strictly following linear extrapolation based on actual runtime to update network service weights, the preheating action is made completely independent of the native container creation main link, avoiding single-point failures blocking the entire system. Furthermore, the influx of traffic presents a smooth and gradual trend, improving the adaptability of new instances to instantaneous high-pressure concurrency. Finally, by writing real-time traffic allocation progress and stage judgment back to the physical attribute panel, and by extracting historical progress and extending the calculation after abnormal interruption and reconnection, the state black box of backend management is completely broken. This ensures that the entire traffic allocation management solution, while maintaining extremely high observation transparency, possesses strong fault-tolerant continuity capabilities and business continuity guarantees to cope with complex network jitter.

[0145] The above description is merely an embodiment of this application and is not intended to limit the scope of protection of this application. Any modifications, equivalent substitutions, and improvements made within the spirit and scope of this application are included within the scope of protection of this application.

Claims

1. A method for managing container access traffic, characterized in that, The method includes: When a target running container carrying a preheating flag is detected, the operating status of the target running container is monitored in bypass mode. When the target running container is in the running state of ready to provide external services, the baseline time is obtained; According to the preset adjustment period, the runtime between the current time and the reference time is determined. After each determination of the runtime, the network service weight allocated to the target running container is updated according to the runtime, and a configuration instruction is generated according to the network service weight. The configuration instruction is used to enable the network request distribution node to release network service traffic to the target running container according to the network service weight.

2. The method according to claim 1, characterized in that, The step of updating the network service weights allocated to the target running container based on the runtime includes: Obtain the target preheating time, weight lower limit, and weight upper limit pre-configured for the target running container; The network service weight is calculated based on the runtime, the target warm-up time, the lower limit of the weight, and the upper limit of the weight.

3. The method according to claim 2, characterized in that, The calculation of the network service weight based on the runtime, the target warm-up duration, the lower limit of the weight, and the upper limit of the weight includes: Calculate the difference between the upper limit of the weight and the lower limit of the weight, and calculate the ratio between the running time and the target preheating time; The asymptotic weight change is calculated based on the product of the difference and the ratio. The network service weight is obtained by summing the asymptotic weight change and the lower limit of the weight.

4. The method according to claim 2, characterized in that, After obtaining the reference time, the method further includes: If it is determined that the runtime is greater than or equal to the target warm-up time, the network service weight is updated to the upper limit value of the weight.

5. The method according to claim 1, characterized in that, Before the target runtime container reaches the state of being ready to provide external services, the method further includes: Record the restart count value of the target running container, wherein the restart count value is the number of times the target running container is restarted after a failure; If the restart count value is greater than a preset count threshold, the running state of the target running container is set to a reset state.

6. The method according to claim 5, characterized in that, If the restart count value is greater than a preset count threshold, the method further includes: Update the counting threshold to the restart count value recorded before the running state was set to the reset state.

7. The method according to claim 1, characterized in that, Prior to detecting the target operating container carrying the preheating identifier, the method further includes: Intercept the container creation request; Based on the creation request, trace back to the deployment object of the container, and read the target warm-up duration pre-configured for the container from the deployment object; Upon reading the target preheating duration, the container is created according to the creation request, and the preheating identifier is added to the container by writing configuration, thus obtaining the target running container.

8. The method according to claim 1, characterized in that, After generating configuration instructions based on the network service weights, the method further includes: Obtain the current network service traffic allocation progress of the target running container, and generate a status value based on the allocation progress, wherein the status value represents a value indicating that it is waiting to be warmed up, in the process of warming up, or in the process of warming up. The allocation progress and the status value are written into the configuration attribute annotation field and the container running condition field in the runtime environment of the target running container, wherein the configuration attribute annotation field and the container running condition field are used to output the allocation progress and the status value of the target running container when a query command is received.

9. The method according to claim 8, characterized in that, After writing the allocation progress and the status value into the configuration attribute comment field and the container runtime condition field in the runtime environment of the target running container, the method further includes: After detecting that the target running container has been interrupted in processing the network service traffic and has restarted, the allocation progress in the configuration attribute comment field is parsed. Based on the allocation schedule obtained from the analysis, the runtime is re-determined; The network service weights allocated to the target runtime container are updated based on the redefined runtime.

10. An electronic device, characterized in that, include: Memory is used to store executable instructions or computer programs. The processor, when executing computer-executable instructions or computer programs stored in the memory, implements the container access traffic management method according to any one of claims 1 to 9.