A gray release method in a distributed environment

Abstract

The application discloses a gray release method in a distributed environment and particularly relates to the technical field of gray release, which realizes data balance isolation and smooth switching between a gray environment and a production environment by constructing a data access environment mapping vector to implement core domain double writing and temporary domain isolation on a write operation, implement cache routing with an environment prefix on a read operation, realize cross-environment data final consistency in combination with version stamp asynchronous merging, and supplement cache elimination strategies with environment identification and core data synchronization during switching, thereby guaranteeing the continuity of user cross-environment operation and the integrity of core data while ensuring flexible routing.

Description

Technical Field

[0001] This invention relates to the field of canary deployment technology, and more specifically, to a canary deployment method in a distributed environment. Background Technology

[0002] In distributed system canary deployment practices, existing technologies are mostly based on IP segment routing. While simple to deploy, this fails to meet the needs of fine-grained user control. To enhance flexibility, an API gateway routing mechanism based on request parameters (URL / Header / Cookie) is introduced, allowing dynamic switching of access environments based on user identifiers. However, this mechanism faces severe data consistency issues at the physical deployment level: canary and production environments typically use independent databases and cache instances. When a user performs write operations in the canary environment (such as changing their profile picture or following a blogger), the data only falls into the canary database, and the production environment is unaware of it, forming data silos. If the two environments share a cache, key-value pairs written in the canary environment may overwrite or discard hot data in the production environment, triggering a cache avalanche risk. These problems are intertwined, causing users to lose their recent operations once they switch back to the production environment, severely damaging user experience and data integrity in scenarios such as social media and e-commerce. Therefore, how to achieve flexible routing while balancing data isolation and sharing, and avoiding write operations polluting production data, has become a core challenge that canary deployment technology urgently needs to solve. Summary of the Invention

[0003] To overcome the aforementioned deficiencies of the prior art, embodiments of the present invention provide a canary release method in a distributed environment to solve the problems mentioned in the background art.

[0004] To achieve the above objectives, the present invention provides the following technical solution:

[0005] A canary deployment method in a distributed environment includes the following steps:

[0006] Obtain the grayscale identifier and operation type from the user request, and construct a data access environment mapping vector containing the core data domain and the temporary data domain by combining it with a predefined data classification strategy; wherein, the operation type includes write operation and read operation;

[0007] Write operations are routed according to the data access environment mapping vector. Specifically, if the write operation involves the core data domain, the dual-write coordinator is activated to write the data to both the grayscale database and the production database simultaneously and record the data version stamp. If the write operation involves the temporary data domain, the data is written only to the current environment database and an environment identifier is added to the data.

[0008] For read operations, routing decisions are made, prioritizing reading from the current environment cache. If the cache misses, data is retrieved from the production database based on the data consistency level and written to the current environment cache, while an environment prefix is ​​appended to the cache key.

[0009] Real-time calculation of the differences between the core data domains of the grayscale environment and the production environment, triggering an asynchronous merge task to synchronize the effective changes in the grayscale environment to the production database and update the version stamp;

[0010] Construct cache keys with environment identifiers and set a timestamp-based eviction policy;

[0011] When a user environment switch event is detected, core data is synchronized from the production database to the new environment based on the user identifier, the local cache is updated, and the session state is reset.

[0012] In a preferred embodiment, before obtaining the grayscale identifier and operation type in the user request, the method further includes: deploying a request parsing unit and a user context awareness module at the system's traffic entry layer; then, the process of obtaining the grayscale identifier and operation type in the user request, combined with a predefined data classification strategy, to obtain and construct a data access environment mapping vector is as follows:

[0013] When a user request arrives, the grayscale identifier is extracted in real time based on the request parsing unit, the operation type is identified, and the user identity is parsed through the user context awareness module to obtain the user identifier.

[0014] A unified request event sampling period is set for the grayscale identifier, operation type, and user identifier, and a precise timestamp is attached to each group of request data;

[0015] When a user write operation request is detected, the core data and temporary data boundaries of the corresponding operation are marked according to a predefined data classification strategy; and a data consistency observation window is set before and after the write operation to monitor the data access behavior throughout the process and obtain a complete operation sequence covering the state before data writing, the writing process and the post-writing verification.

[0016] The operation sequence is jointly mapped with the user grayscale context and data classification label at the corresponding time to construct grayscale operation data domain association samples.

[0017] Based on the grayscale operation data domain associated samples, a sliding window analysis is performed on the user request sequence to construct a data access environment mapping vector.

[0018] In a preferred embodiment, before the write operations are distributed according to the data access environment mapping vector, the method further includes: deploying a write operation distributor and a dual-write coordinator in the data persistence layer, wherein the write operation distributor receives the data access environment mapping vector from the upper layer in real time. To obtain the core data field identifier through parsing. Temporary data field identifier Grayscale identifier priority weight and user identifier hash value At the same time, maintain the identifier of the environment to which the current request belongs. The dual-write coordinator consists of a parallel write engine and a version stamp generation module; the process of routing write operations according to the data access environment mapping vector is as follows:

[0019] For each write operation request, the following decision logic is executed by the write operation distributor: If This triggers the core data writing process and activates the dual-write coordinator.

[0020] The parallel writing engine establishes connections with the grayscale database connection pool and the production database connection pool, constructs the data to be written into a unified data packet, and sends write commands to both databases simultaneously.

[0021] Before the data packet is sent, the version stamp generation module generates a data version stamp based on the current system time, user identifier hash value, and global monotonically increasing sequence number.

[0022] In a preferred embodiment, prior to making routing decisions for the read operation, the method further includes: deploying a read operation router and a cache proxy module at the data access layer, wherein the read operation router receives data access environment mapping vectors from the upper layer in real time. To obtain the current environment identifier. User ID hash value The data domain category involved in the read operation is also specified, and the consistency level of the data is dynamically obtained from the metadata configuration center based on the data domain category. The routing decision for the read operation is as follows:

[0023] The read operation router constructs a cache key with an environment prefix for the current request, which is generated as follows: ,in, For environment prefix mapping function, It serves as a globally unique identifier for data resources. This represents a string concatenation operation;

[0024] For each read operation request, a query is first initiated against the cache cluster bound to the current environment: if the key exists in the cache... If the data item is found, the cached value is returned directly, and the access timestamp of the cached item is updated asynchronously; if the cache is not found, the data backfilling process is triggered.

[0025] In a preferred embodiment, the data backfilling process specifically includes: executing a data source selection and cache writing strategy based on the consistency level through the read operation router, including:

[0026] The read operation router initiates a synchronization query request to the production database to obtain the latest record of the data.

[0027] After retrieving the data returned from the production database, it is processed according to the consistency level. The value determines the cache write behavior, specifically: if If so, the query results will be immediately written to the current environment cache, and a cache expiration time will be set. for: ,in Based on the expiration time, To prevent division by zero for extremely small positive numbers; if If so, the data will still be written to the cache, but the expiration time will need to be extended: This allows subsequent read requests to prioritize the use of the cache.

[0028] In a preferred embodiment, before calculating the difference between the core data domains of the grayscale environment and the production environment in real time, the method further includes: deploying a difference calculation engine in the data consistency coordination layer, wherein the difference calculation engine operates within a fixed time window. If the period is specified, then the real-time calculation of the difference between the core data domains of the grayscale environment and the production environment is specifically as follows:

[0029] The difference calculation engine retrieves version stamps and corresponding resource keys of data records that have changed since the last comparison from the core data tables of the grayscale database and the production database in batches.

[0030] For each resource key Obtain the grayscale environment version stamp set respectively. Production environment version stamp set And calculate the version stamp difference. ;in, for: ,in This is the set difference operator, which selects the set of elements belonging to the set. But not belonging to elements, This indicates the number of elements in the set.

[0031] In a preferred embodiment, the method further includes: deploying an asynchronous merge scheduler in the data consistency coordination layer; then, the triggering asynchronous merge task synchronizes the effective changes in the grayscale environment to the production database and updates the version stamp, specifically:

[0032] Calculate the total number of synchronization tasks based on the version stamp difference. : ,in Indicates the first An index for each resource key. Indicates the total number of resource keys; when At that time, the asynchronous merging task is triggered through the difference calculation engine;

[0033] After receiving the trigger signal, the asynchronous merging scheduler obtains the list of resource keys to be synchronized and the corresponding grayscale environment change data from the difference calculation engine, and constructs a merging task queue, wherein each merging task is based on a resource key.

[0034] The grayscale environment change data is applied to the production database one by one according to the version stamp time sequence.

[0035] In a preferred embodiment, constructing a cache key with an environment identifier and setting a timestamp-based eviction policy specifically involves:

[0036] Deploy a cache key namespace manager and a timestamp-aware eviction engine at the cache infrastructure layer;

[0037] The namespace manager extracts the environment identifier based on the context of the current request. and resource identifiers And construct composite cache keys;

[0038] The timestamp-aware eviction engine scans the cache key space at fixed intervals and calculates the aging factor for each cache item. : ,in, The current system time. Use the baseline aging time window; when When this happens, the cached item enters the candidate set for eviction;

[0039] The timestamp-aware elimination engine adjusts the actual elimination threshold based on priority level, setting a dynamic elimination threshold. ;when When this happens, mark the cached item as eligible for eviction;

[0040] The timestamp-aware eviction engine removes cached items that meet the eviction criteria in batches and frees up memory space.

[0041] In a preferred embodiment, before synchronizing core data from the production database to the new environment based on the user identifier, updating the local cache, and resetting the session state when a user environment switch event is detected, the method further includes: deploying an environment switch detector and a state synchronization engine to the user session management layer; then, the step of synchronizing core data from the production database to the new environment based on the user identifier, updating the local cache, and resetting the session state when a user environment switch event is detected specifically includes:

[0042] The environment switching detector continuously monitors the grayscale flags and user configuration table update events in the user request context; for each logged-in user, it maintains their current bound environment and the latest effective environment; when it detects that the current bound environment and the latest effective environment are inconsistent, it determines that a user environment switching event has occurred, and records the switching timestamp and user identifier;

[0043] After receiving a switching event, the state synchronization engine queries the user's core data domain list. For each core data item in the core data domain list, the state synchronization engine initiates a synchronization query to the production database to obtain the latest version of the data item at the current moment.

[0044] The state synchronization engine uses a priority queue scheduling method to calculate the synchronization priority of each data item;

[0045] The state synchronization engine writes the core data pulled from the production database into the database of the new environment according to priority, and at the same time updates the corresponding cache items in the cache of the new environment.

[0046] After core data synchronization is complete, the user's session information is cleared from the old environment, and a new session token is generated for the new environment. Simultaneously, the user's latest core data is preloaded into the new session's cache for secure delivery to the front end via the new session token.

[0047] The technical effects and advantages of this invention are as follows:

[0048] 1. This invention aims to solve the problems of data silos, cache conflicts, and switching interruptions caused by environmental isolation in existing canary releases. It achieves balanced data isolation and smooth switching between canary and production environments by constructing a data access environment mapping vector to perform core domain dual writes and temporary domain isolation for write operations, implement cache routing with environment prefixes for read operations, combine asynchronous merging of version stamps to achieve eventual data consistency across environments, and supplement it with a cache eviction policy with environment identifiers and core data synchronization during switching. This ensures flexible routing while guaranteeing the continuity of user operations across environments and the integrity and consistency of core data. Attached Figure Description

[0049] To facilitate understanding by those skilled in the art, the present invention will be further described below with reference to the accompanying drawings;

[0050] Figure 1 This is a flowchart of a method according to an embodiment of the present invention. Detailed Implementation

[0051] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0052] Example: Figure 1 The present invention provides a canary release method in a distributed environment, comprising the following steps:

[0053] Obtain the grayscale identifier and operation type from the user request, and combine them with a predefined data classification strategy to construct a data access environment mapping vector that includes the core data domain and the temporary data domain;

[0054] Write operations are split according to the mapping vector: if the operation involves the core data domain, the dual-write coordinator is activated, and the data is written to both the grayscale database and the production database at the same time, and the data version stamp is recorded; if the operation involves the temporary data domain, only the current environment database is written and an environment identifier is added to the data.

[0055] For read operations, routing decisions are made, prioritizing reading from the current environment cache. If the cache misses, data is retrieved from the production database based on the data consistency level and written to the current environment cache, while an environment prefix is ​​appended to the cache key.

[0056] Real-time calculation of the differences between the core data domains of the grayscale environment and the production environment, triggering an asynchronous merge task to synchronize the effective changes in the grayscale environment to the production database and update the version stamp;

[0057] Construct cache keys with environment identifiers and set a timestamp-based eviction policy to avoid cross-environment cache key conflicts and data overwriting;

[0058] When a user environment switch event is detected, core data is synchronized from the production database to the new environment based on the user identifier, the local cache is updated, and the session state is reset to ensure the continuity of user operations and data consistency across environments.

[0059] In this embodiment of the invention, the process of obtaining the grayscale identifier and operation type in a user request, and constructing a data access environment mapping vector containing a core data domain and a temporary data domain, in conjunction with a predefined data classification strategy, is as follows:

[0060] A request parsing unit and a user context awareness module are deployed at the system's traffic entry layer. These units are used to extract grayscale identifiers from URL parameters, HTTP headers, and cookies in real time when each user request arrives. Simultaneously, the request path and method are parsed to identify the operation type, and the user identity is parsed through the user context awareness module to obtain the user identifier. The operation types include read operations and write operations.

[0061] The request parsing unit synchronizes with a unified clock source to ensure that all request events have traceable consistency on the global timeline.

[0062] A unified request event sampling period is set for the grayscale identifier, operation type, and user identifier obtained by the user context awareness module obtained by the request parsing unit, and a precise timestamp is added to each set of request data so that each user behavior forms a continuous and traceable operation sequence in the time dimension.

[0063] Preferably, the sampling period is dynamically adjusted according to the system's average response time and the number of concurrent requests to ensure that the complete behavioral trajectory of user operations under grayscale control can be captured;

[0064] When a user write operation request is detected, the core data and temporary data boundaries of the corresponding operation are marked according to a predefined data classification strategy. The data classification strategy predivides the core data domain (such as user account, order record) and temporary data domain (such as user session state, cached intermediate results) based on field-level labels, and sets a data consistency observation window before and after the write operation to monitor the data access behavior throughout the process and obtain a complete operation sequence covering the state before writing, the writing process and the verification after writing.

[0065] The operation sequence is jointly mapped with the user grayscale context and data classification label at the corresponding time to construct grayscale operation data domain association samples, so that each data write request is associated with a clear grayscale environment identifier and data category, which is used to characterize the dynamic interaction relationship between user behavior and data domain.

[0066] Based on the grayscale operation data domain associated samples, a sliding window analysis is performed on the user request sequence to construct a data access environment mapping vector. : ,in, Indicates whether the current request involves core data fields. Indicate whether a temporary data field is involved. A hash value for user identification, used for subsequent shard routing. Priority weights for grayscale indicators;

[0067] For example, in the first Within each observation window, the priority weight of the grayscale indicator can be represented as: ,in , , These represent the indicator functions for whether a grayscale identifier appears in the URL, HTTP header, and cookie, respectively, and satisfy the following conditions: ;

[0068] It should be noted that the data access environment mapping vector is not a simple concatenation of request parameters, but also includes the priority weight of grayscale identifiers, the data domain affiliation of the operation and its coupling relationship with the user identity. Its physical significance is to provide a refined decision-making basis for subsequent write operation diversion, read operation routing and data synchronization during environment switching, thereby achieving cross-environment data consistency and operation continuity while ensuring data isolation.

[0069] In this embodiment of the invention, write operations are routed according to the mapping vector: if the operation involves a core data domain, the dual-write coordinator is activated, and the data is simultaneously written to both the grayscale database and the production database, with a data version stamp recorded; if the operation involves a temporary data domain, the process of writing only to the current environment database and adding an environment identifier to the data is as follows:

[0070] A write operation splitter and a dual-write coordinator are deployed in the data persistence layer. The splitter receives data access environment mapping vectors from the upper layer in real time. And parse the core data field identifiers within it. Temporary data field identifier Grayscale identifier priority weight and user identifier hash value At the same time, the splitter maintains the identifier of the environment to which the current request belongs. This is used to determine the target environment baseline for writing;

[0071] The identifier of the environment to which it belongs Values and ,in , indicating a grayscale environment This indicates the production environment;

[0072] For each write operation request, the splitter executes the following decision logic: If If the operation involves core data domains, the core data write process is triggered, activating the dual-write coordinator. The dual-write coordinator consists of a parallel write engine and a version stamp generation module. The parallel write engine simultaneously establishes connections with both the grayscale database connection pool and the production database connection pool, constructs the data to be written into a unified data packet, and sends write commands to both databases. Before sending the data packet, the version stamp generation module generates a data version stamp based on the current system time, user identifier hash value, and globally monotonically increasing sequence number. Its expression is: ,in, This indicates string concatenation. For millisecond-level timestamps synchronized with the clock source, A globally monotonically increasing sequence number assigned to the coordinator; this version stamp is written along with the data into the corresponding record in both databases for subsequent data difference comparison and synchronization tracing.

[0073] like and If the operation only involves a temporary data field, the flow divider will direct the write operation to the current environment database and trigger the environment identifier attachment module; this module adds an implicit field to the record to be written before the data is written. Its value is determined by the current environment identifier. Priority weight of grayscale identifier Joint decision: ,in, The preset threshold, for example, a value of 1, indicates that at least one valid grayscale identifier exists; this environment identifier enables temporary data to be logically isolated by environment, but physically coexist in the same database instance, and the identifier field distinguishes temporary data generated in different environments;

[0074] It should be noted that when performing dual writes of core data, the dual-write coordinator must ensure eventual consistency between the two databases. By introducing a retry mechanism and transaction compensation logs, it prevents data inconsistency caused by single-database failures. At the same time, the introduction of version stamps is not only used to mark data versions, but also to provide a unique comparison benchmark for subsequent real-time calculation of the differences between the core data domains of the two environments, thereby supporting the asynchronous merging task to accurately identify new or changed data in the gray-scale environment.

[0075] In this embodiment of the invention, routing decisions are made for read operations, prioritizing reading from the current environment cache. If the cache misses, data is retrieved from the production database based on the data consistency level and written to the current environment cache. Simultaneously, the process of appending an environment prefix to the cache key is as follows:

[0076] A read-operation router and a cache proxy module are deployed at the data access layer. The router receives the data access environment mapping vector from the upper layer in real time. The current environment identifier is obtained through parsing. User ID hash value And the data domain category involved in the operation; at the same time, dynamically obtain the consistency level of the data from the metadata configuration center according to the data domain category. ,in This indicates a strong consistency requirement, for example, in a core data domain. This indicates eventual consistency tolerance, such as temporary data domains, where intermediate values ​​are determined by the business's pre-set synchronization strategy;

[0077] The read operation router constructs a cache key with an environment prefix for the current request, which is generated as follows: ,in, For environment prefix mapping functions, such as , ; A globally unique identifier for data resources, such as a database table name concatenated with the primary key; This represents a string concatenation operation;

[0078] Read operations will first query the cache cluster bound to the current environment: if the key exists in the cache... If the data item is found, the cached value is returned directly, and the access timestamp of the cached item is updated asynchronously to extend its data lifecycle; if the cache is not found, the data backfilling process is triggered.

[0079] During the backfilling process, the read operation router operates according to the consistency level. Execution of data source selection and cache write strategy: The router initiates a synchronization query request to the production database to obtain the latest record of the data; after the production database returns the data, it determines the consistency level. The value determines the cache write behavior: if This indicates a high requirement for data consistency, so the query results are immediately written to the current environment cache, and a cache expiration time is set. for: ,in Based on the expiration time, This prevents division by zero for extremely small positive numbers; the higher the consistency level, the shorter the cache expiration time, thus reducing the probability of returning dirty data; if If a certain degree of data lag is tolerated, the data will still be written to the cache, but the expiration time will need to be extended. For example, And allow subsequent read requests to use the cache first;

[0080] The The consistency level threshold is a constant pre-configured based on business requirements;

[0081] When writing to the cache, the aforementioned cache key with the environment prefix is ​​still used. This ensures that data from different environments is physically isolated in the cache layer, avoiding key conflicts and data overwriting; after the data is written, the latest data is returned to the upper-level caller.

[0082] It should be noted that for temporary data domains (L close to 0), if a copy of the data already exists in the current environment database (e.g., generated by a previous write operation) and the cache is not hit, the read operation router can also be configured to prioritize pulling from the current environment database to reduce latency, but an environment identifier needs to be attached to the data record for verification. This process uses the production database as the authoritative data source to maximize the cache hit rate while ensuring eventual consistency.

[0083] In this embodiment of the invention, the process of calculating the difference between the core data domains of the grayscale environment and the production environment in real time, triggering an asynchronous merging task to synchronize the effective changes in the grayscale environment to the production database and update the version stamp is as follows:

[0084] A difference calculation engine and an asynchronous merging scheduler are deployed at the data consistency coordination layer. The difference calculation engine operates within a fixed time window. Periodically, retrieve version stamps and corresponding resource keys of data records that have changed since the last comparison from the core data tables of the grayscale database and the production database; for each resource key... Obtain the grayscale environment version stamp set respectively. Production environment version stamp set The version stamp is in hash format; it is parsed into a triple. ,in Identify the hash value for the user. For millisecond-level timestamps synchronized with the clock source, The globally monotonically increasing sequence number assigned to the coordinator;

[0085] For each resource key Define version stamp difference for: ,in This is the set difference operator, which selects the set of elements belonging to the set. But not belonging to elements, Indicates the number of elements in the set;

[0086] Version stamp difference This is used to indicate the number of version stamps that exist in the grayscale environment but are missing in the production environment; if This indicates that the grayscale environment has made changes to the resource that have not yet been synchronized.

[0087] By comparing the order of the version stamp sequences, the temporal relationship of the changes is determined, and the number of data change records in the grayscale environment relative to the latest version in the production environment is extracted:

[0088] And calculate the total number of synchronization tasks. : ,in Indicates the first An index for each resource key. Indicates the total number of resource keys; when At that time, the difference calculation engine triggers an asynchronous merging task;

[0089] After receiving the trigger signal, the asynchronous merge scheduler obtains the list of resource keys to be synchronized and the corresponding grayscale environment change data from the difference calculation engine, and constructs a merge task queue; each merge task applies the change data in the grayscale environment to the production database one by one according to the version stamp time sequence, based on the resource key.

[0090] When applying changes, the merger first locks the corresponding record in the production database and merges and writes the grayscale data. After successful writing, the new version stamp of the production database record is updated to the version stamp value of the corresponding change in the grayscale environment to ensure that the change is no longer considered a difference in subsequent comparisons.

[0091] It should be noted that the asynchronous merge task adopts an eventual consistency model, which allows for a certain delay, but must ensure that the core data changes generated in the gray-scale environment are not lost; the execution status of the merge task is continuously monitored by the scheduler, and failed tasks are automatically retried until successful or the maximum number of retries is reached; through the comparison and synchronization of version stamp sequences, bidirectional eventual consistency of the core data domains between the gray-scale environment and the production environment is achieved, which not only ensures the data isolation during the gray-scale test, but also ensures the integrity and continuity of the data after the switch.

[0092] In this embodiment of the invention, the process of constructing a cache key with an environment identifier and setting a timestamp-based eviction policy to avoid cross-environment cache key conflicts and data overwriting is as follows:

[0093] A cache key namespace manager and a timestamp-aware eviction engine are deployed at the cache infrastructure layer. The namespace manager extracts environment identifiers based on the context of the current request. and resource identifiers For example, the primary key of a data table, constructing a composite cache key. The general format is: ,in, For environment prefix mapping function, A standardized representation of a resource identifier, such as "user:1001"; Optional version suffix, timestamp written according to data. The suffix is ​​used to distinguish versions of the same resource at different times; if version tracking is not required, the suffix is ​​omitted, and the original key is directly overwritten when updating data.

[0094] In addition to business data, the cached value also needs to embed metadata fields, including the write timestamp. Last access timestamp Priority level Data consistency level The mapping yields: ,in This is a floor function, which maps the data consistency level within the continuous interval [0,1] to a set of discrete integer values. The timestamp-aware eviction engine scans the cache key space at fixed intervals and calculates the aging factor for each cache item. : ,in, The current system time. Use the baseline aging time window; when When the threshold is reached, it indicates that the item has exceeded the baseline window of unvisited access and is added to the candidate set for elimination.

[0095] Timestamp-aware elimination engine based on priority level Adjust the actual elimination threshold and set a dynamic elimination threshold. for: ;

[0096] when When that happens, mark the cached item as eligible for eviction;

[0097] The timestamp-aware eviction engine removes cached items that meet the eviction criteria in batches and frees up memory space.

[0098] It should be noted that the timestamp-based eviction policy not only relies on the last access time, but also combines the write timestamp and priority to form a multi-dimensional aging judgment. This allows the caching system to automatically clean up cold data and retain data differently based on its importance, thereby optimizing cache resource utilization while ensuring cross-environment data isolation.

[0099] In this embodiment of the invention, when a user environment switching event is detected, core data is synchronized from the production database to the new environment based on the user identifier, the local cache is updated, and the session state is reset. The process of ensuring the continuity of user operations across environments and data consistency is as follows:

[0100] Deploy an environment switching detector and a state synchronization engine in the user session management layer to monitor changes in grayscale indicators and background configuration updates in user requests in real time. When a user switches from the current environment to the target environment, such as from a grayscale environment to a production environment, a cross-environment data synchronization and session reset process is triggered.

[0101] The environment switching detector continuously monitors the grayscale flags in the user request context and user configuration table update events; for each logged-in user, it maintains their current bound environment and the latest effective environment; when it detects that the current bound environment and the latest effective environment are inconsistent, it determines that a user environment switching event has occurred, and records the switching timestamp and user identifier;

[0102] After receiving a switch event, the state synchronization engine queries the user's core data domain list, including data items that must remain consistent across environments, such as user basic information, account balance, and permission roles. For each core data item in the core data domain list, the state synchronization engine initiates a synchronization query to the production database to obtain the latest version of that data item at the current moment.

[0103] To ensure that the synchronization process does not affect the user experience, the state synchronization engine uses a priority queue scheduling method to calculate the synchronization priority of each data item. : ,in, Assign business weights to data items. This represents the time interval since the last change to the data item. To prevent division by zero for extremely small positive numbers, Core data indicator function;

[0104] The state synchronization engine writes the core data pulled from the production database to the database of the new environment in priority order, and at the same time updates the corresponding cache items in the cache of the new environment;

[0105] After the core data synchronization is completed, the user's session information is cleared from the user's old environment to prevent subsequent requests from mistakenly entering the old environment; a new session token is generated for the new environment, and the user's latest core data is preloaded into the cache of the new session; the new session token is securely issued to the front end, and subsequent requests carry this token to ensure that requests are always routed to the new environment.

[0106] This invention addresses the issues of data silos, cache conflicts, and handover interruptions caused by environmental isolation in existing canary releases. It achieves balanced data isolation and smooth handover between canary and production environments by constructing a data access environment mapping vector to implement dual-write to the core domain and isolation of the temporary domain for write operations, implementing cache routing with environment prefixes for read operations, combining asynchronous merging of version stamps to achieve eventual data consistency across environments, and supplementing this with a cache eviction policy with environment identifiers and core data synchronization during handover. This ensures flexible routing while guaranteeing the continuity of user operations across environments and the integrity and consistency of core data.

[0107] This invention achieves fine-grained classification of user requests by constructing a data access environment mapping vector, laying the foundation for subsequent differentiated processing. In write operation routing, a dual-write coordinator is activated for core data domains and a version stamp is recorded to ensure real-time consistency of core data between gray-scale and production environments, fundamentally eliminating the data silo problem. Temporary data domains are only written to the current environment and an identifier is added, effectively reducing synchronization overhead and system coupling. In read operation routing, reads are preferentially read from the current environment cache; if a cache miss occurs, data is retrieved from the production database based on the consistency level and written to the cache. Simultaneously, an environment prefix is ​​appended to the cache key, ensuring low-latency response for read requests and avoiding cross-environment cache errors through key space isolation. Key conflicts and data overwrites are eliminated, mitigating the risk of cache avalanche. By calculating the differences between the core data domains of the two environments in real time and triggering asynchronous merging tasks, effective changes in the gray-scale environment are ultimately synchronized to the production database and the version stamp is updated, ensuring data integrity and traceability during environment switching. A cache key with an environment identifier is constructed, and a timestamp-based eviction policy is set to strengthen the logical isolation and automatic aging of cached data, optimizing cache resource utilization. When a user environment switch event is detected, core data is synchronized from the production database to the new environment based on the user identifier, and the local cache is updated and the session state is reset, ensuring the continuity of user operations across environments and data consistency, significantly improving the user experience.

[0108] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation.

[0109] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0110] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A canary release method in a distributed environment, characterized in that: Includes the following steps: Obtain the grayscale identifier and operation type from the user request, and construct a data access environment mapping vector containing the core data domain and the temporary data domain by combining it with a predefined data classification strategy; wherein, the operation type includes write operation and read operation; Write operations are routed according to the data access environment mapping vector. Specifically, if the write operation involves the core data domain, the dual-write coordinator is activated to write the data to both the grayscale database and the production database simultaneously and record the data version stamp. If the write operation involves the temporary data domain, the data is written only to the current environment database and an environment identifier is added to the data. For read operations, routing decisions are made, prioritizing reading from the current environment cache. If the cache misses, data is retrieved from the production database based on the data consistency level and written to the current environment cache, while an environment prefix is ​​appended to the cache key. Real-time calculation of the differences between the core data domains of the grayscale environment and the production environment, triggering an asynchronous merge task to synchronize the effective changes in the grayscale environment to the production database and update the version stamp; Construct cache keys with environment identifiers and set a timestamp-based eviction policy; When a user environment switch event is detected, core data is synchronized from the production database to the new environment based on the user identifier, the local cache is updated, and the session state is reset.

2. The canary release method in a distributed environment according to claim 1, characterized in that: Before obtaining the grayscale identifier and operation type in the user request, the system further includes: deploying a request parsing unit and a user context awareness module at the system's traffic entry layer; then, the process of obtaining the grayscale identifier and operation type in the user request, combined with a predefined data classification strategy, to obtain and construct a data access environment mapping vector is as follows: When a user request arrives, the grayscale identifier is extracted in real time based on the request parsing unit, the operation type is identified, and the user identity is parsed through the user context awareness module to obtain the user identifier. A unified request event sampling period is set for the grayscale identifier, operation type, and user identifier, and a precise timestamp is attached to each group of request data; When a user write operation request is detected, the core data and temporary data boundaries of the corresponding operation are marked according to a predefined data classification strategy; and a data consistency observation window is set before and after the write operation to monitor the data access behavior throughout the process and obtain a complete operation sequence covering the state before data writing, the writing process and the post-writing verification. The operation sequence is jointly mapped with the user grayscale context and data classification label at the corresponding time to construct grayscale operation data domain association samples. Based on the grayscale operation data domain associated samples, a sliding window analysis is performed on the user request sequence to construct a data access environment mapping vector.

3. The canary release method in a distributed environment according to claim 1, characterized in that: Before the write operations are distributed according to the data access environment mapping vector, the method further includes: deploying a write operation distributor and a dual-write coordinator in the data persistence layer, wherein the write operation distributor receives the data access environment mapping vector from the upper layer in real time. To obtain the core data field identifier through parsing. Temporary data field identifier Grayscale identifier priority weight and user identifier hash value At the same time, maintain the identifier of the environment to which the current request belongs. The dual-write coordinator consists of a parallel write engine and a version stamp generation module; the process of routing write operations according to the data access environment mapping vector is as follows: For each write operation request, the following decision logic is executed by the write operation distributor: If This triggers the core data writing process and activates the dual-write coordinator. The parallel writing engine establishes connections with the grayscale database connection pool and the production database connection pool, constructs the data to be written into a unified data packet, and sends write commands to both databases simultaneously. Before the data packet is sent, the version stamp generation module generates a data version stamp based on the current system time, user identifier hash value, and global monotonically increasing sequence number.

4. The canary release method in a distributed environment according to claim 1, characterized in that: Before making routing decisions for read operations, the method further includes: deploying a read operation router and a cache proxy module at the data access layer, wherein the read operation router receives data access environment mapping vectors from the upper layer in real time. To obtain the current environment identifier. User ID hash value The data domain category involved in the read operation is also specified, and the consistency level of the data is dynamically obtained from the metadata configuration center based on the data domain category. The routing decision for the read operation is as follows: The read operation router constructs a cache key with an environment prefix for the current request, which is generated as follows: ,in, For environment prefix mapping function, It serves as a globally unique identifier for data resources. This represents a string concatenation operation; For each read operation request, a query is first initiated against the cache cluster bound to the current environment: if the key exists in the cache... If the data item is found, the cached value is returned directly, and the access timestamp of the cached item is updated asynchronously; if the cache is not found, the data backfilling process is triggered.

5. The canary release method in a distributed environment according to claim 4, characterized in that: The data backfilling process specifically involves: the read operation router executing a data source selection and cache writing strategy based on the consistency level, including: The read operation router initiates a synchronization query request to the production database to obtain the latest record of the data. After obtaining the data returned by the production database, it is processed according to the consistency level. The value determines the cache write behavior, specifically: if If so, the query results will be immediately written to the current environment cache, and a cache expiration time will be set. for: ,in Based on the expiration time, To prevent division by zero for extremely small positive numbers; if If so, the data will still be written to the cache, but the expiration time will need to be extended: This allows subsequent read requests to prioritize the use of the cache.

6. The canary release method in a distributed environment according to claim 1, characterized in that: Before calculating the difference between the core data domains of the grayscale environment and the production environment in real time, the method further includes: deploying a difference calculation engine in the data consistency coordination layer, wherein the difference calculation engine operates within a fixed time window. If the period is specified, then the real-time calculation of the difference between the core data domains of the grayscale environment and the production environment is specifically as follows: The difference calculation engine retrieves version stamps and corresponding resource keys of data records that have changed since the last comparison from the core data tables of the grayscale database and the production database in batches. For each resource key Obtain the grayscale environment version stamp set respectively. Production environment version stamp set And calculate the version stamp difference. Among them, version stamp difference for: ,in This is the set difference operator, which selects the set of elements belonging to the set. But not belonging to elements, This indicates the number of elements in the set.

7. The canary release method in a distributed environment according to claim 6, characterized in that: Also includes: Deploying the asynchronous merge scheduler in the data consistency coordination layer; then the triggered asynchronous merge task will synchronize the effective changes in the gray-scale environment to the production database and update the version stamp, specifically: The total number of synchronization tasks is calculated based on the version stamp difference. : ,in Indicates the first An index for each resource key. Indicates the total number of resource keys; when At that time, the asynchronous merging task is triggered through the difference calculation engine; After receiving the trigger signal, the asynchronous merging scheduler obtains the list of resource keys to be synchronized and the corresponding grayscale environment change data from the difference calculation engine, and constructs a merging task queue, wherein each merging task is based on a resource key. The grayscale environment change data is applied to the production database one by one according to the version stamp time sequence.

8. The canary release method in a distributed environment according to claim 1, characterized in that: The construction of the cache key with environment identifier and the setting of the timestamp-based eviction policy are specifically as follows: Deploy a cache key namespace manager and a timestamp-aware eviction engine at the cache infrastructure layer; The namespace manager extracts the environment identifier based on the context of the current request. and resource identifiers And construct composite cache keys; The timestamp-aware eviction engine scans the cache key space at fixed intervals and calculates the aging factor for each cache item. : ,in, The current system time. Use the baseline aging time window; when When this happens, the cached item enters the candidate set for eviction; The timestamp-aware elimination engine adjusts the actual elimination threshold based on priority level, setting a dynamic elimination threshold. ;when When this happens, mark the cached item as eligible for eviction; The timestamp-aware eviction engine removes cached items that meet the eviction criteria in batches and frees up memory space.

9. The canary release method in a distributed environment according to claim 1, characterized in that: Before synchronizing core data from the production database to the new environment based on the user identifier, updating the local cache, and resetting the session state when a user environment switch event is detected, the method further includes: deploying the environment switch detector and the state synchronization engine to the user session management layer; then, the step of synchronizing core data from the production database to the new environment based on the user identifier, updating the local cache, and resetting the session state when a user environment switch event is detected specifically includes: The environment switching detector continuously monitors the grayscale flags and user configuration table update events in the user request context; for each logged-in user, it maintains their current bound environment and the latest effective environment; when it detects that the current bound environment and the latest effective environment are inconsistent, it determines that a user environment switching event has occurred, and records the switching timestamp and user identifier; After receiving a switching event, the state synchronization engine queries the user's core data domain list. For each core data item in the core data domain list, the state synchronization engine initiates a synchronization query to the production database to obtain the latest version of the data item at the current moment. The state synchronization engine uses a priority queue scheduling method to calculate the synchronization priority of each data item; The state synchronization engine writes the core data pulled from the production database into the database of the new environment according to priority, and at the same time updates the corresponding cache items in the cache of the new environment. After the core data synchronization is complete, the user's session information is cleared from the user's old environment, and a new session token is generated for the new environment. At the same time, the user's latest core data is preloaded into the cache of the new session so that it can be securely distributed to the front end through the new session token.

Images