DNS (Domain Name Server) cache updating method and device based on push

Abstract

The invention discloses a DNS cache updating method and device based on pushing, the method is applied to a recursive server, the recursive server is used for periodically initiating an updating DNS query request to an updating database and deleting a local cache according to a domain name list in an updating DNS response, and the method comprises the following steps: receiving a DNS query request sent by a client, checking whether an effective record exists in the local cache or not, and if yes, returning the effective record to the client; if not, triggering a cache miss event, and obtaining a latest analysis result from the authoritative server; the authoritative server pushes an event to the update database after the DNS record is changed; inserting the latest analysis result into a local cache, and setting cache expiration time according to a TTL value returned by the authoritative server; and returning the latest analysis result to the client, and managing the actual validity period of the local cache record. According to the invention, the updating time efficiency and the TTL are decoupled, and real-time updating is realized.

Description

Technical Field

[0001] The present application relates to the technical field of domain name system, and in particular to a push-based DNS cache update method and device. Background Art

[0002] With the rapid development of the internet, the scale of networks continues to expand, and network applications become increasingly diverse. The Domain Name System (DNS), as one of the core infrastructures of the internet, has become increasingly important. DNS is responsible for converting easy-to-remember domain names into computer-recognizable IP addresses, enabling rapid location and access to network resources. However, faced with massive domain name resolution requests, increasingly complex network security threats, and the impact of emerging network technologies, the traditional domain name system has gradually exposed numerous problems and shortcomings, such as low resolution efficiency, weak security protections, and difficulty adapting to new network architectures. These have greatly restricted the further development and innovation of the internet. Therefore, updating and optimizing the domain name system to improve its performance, enhance security, expand its functionality, and better adapt to the development needs of the modern internet has become a critical issue that needs to be urgently addressed in the current field of network technology.

[0003] The existing Domain Name System (DNS) uses a time-to-live (TTL) passive update mechanism. Its core process includes:

[0004] Step 1: Cache writing. When the authoritative server returns the DNS resolution record, it carries a TTL value (such as 3600 seconds) to indicate the allowed length of time for the recursive resolver to cache the record.

[0005] Step 2: Cache the response. Within the TTL validity period, the recursive resolver directly uses the local cache record to respond to the client request, avoiding repeated queries to the authoritative server.

[0006] Step 3: Cache cleaning. After the TTL expires, the recursive resolver automatically deletes the cached records and queries the authoritative server for the latest records again the next time the client requests.

[0007] However, the passive update mechanism using the survival time has the following defects:

[0008] 1. The TTL value must simultaneously meet the mutually exclusive goals of "low load" and "high timeliness". Existing technologies do not have a decoupling method, mainly because:

[0009] a. Long TTL: This reduces query frequency, but error records must wait for the TTL to expire before they can be updated, causing the service to be unavailable for a long time after the update;

[0010] b. Short TTL: Updates quickly, but it will result in frequent queries to the authoritative server, which will generate a large amount of invalid query traffic and increase the load on the authoritative server.

[0011] 2. Lack of real-time update mechanism: The parser must wait until the TTL expires or the cache is manually cleared before triggering a query for new parsing results. This makes it unable to cope with emergency processing scenarios in large-scale distributed caching scenarios. Summary of the Invention

[0012] To this end, the present application provides a push-based DNS cache update method and device to solve the problem that the existing technology lacks a real-time update mechanism.

[0013] In order to achieve the above objectives, this application provides the following technical solutions:

[0014] In a first aspect, a push-based DNS cache update method is provided. The method is applied to a recursive server, wherein the recursive server is configured to periodically initiate an update DNS query request to an update database and delete a local cache based on a domain name list in an update DNS response returned by the update database. The method comprises:

[0015] Step 1: Receive the DNS query request sent by the client;

[0016] Step 2: Prioritize checking whether there is a valid record in the local cache according to the DNS query request;

[0017] Step 3: If there is a valid record in the local cache, the valid record is returned to the client;

[0018] Step 4: If there is no valid record in the local cache or the valid record has expired, a cache miss event is triggered, and the authoritative server is requested to obtain the latest resolution result. After the DNS record is changed, the authoritative server will proactively send an insert domain name request to the update database and send the changed domain name information to the update database.

[0019] Step 5: Insert the latest parsing result into the local cache and set the cache expiration time according to the TTL value returned by the authoritative server;

[0020] Step 6: Return the latest parsing result to the client, and manage the actual validity period of the local cache record according to the cache expiration time.

[0021] Preferably, the update database is a distributed global database deployed in the cloud.

[0022] Preferably, the update DNS query request includes a last synchronization timestamp and a unique identifier of the recursive server.

[0023] Preferably, after receiving the update DNS query request sent by the recursive server, the update database filters out all change events later than the last synchronization timestamp according to the last synchronization timestamp in the update DNS query request, and generates an update DNS response; wherein, the update DNS response also includes the latest timestamp and data check value.

[0024] Preferably, the recursive server needs to perform data integrity verification, cache mark invalidation and asynchronous cleaning mechanism after receiving the updated DNS response.

[0025] Preferably, in step 4, the domain name insertion request includes a domain name identifier, a record type, a change timestamp, and a digital signature.

[0026] Preferably, in step 4, after receiving the domain name insertion request, the update database first performs signature verification, then checks the time window, and finally performs distributed writing.

[0027] Preferably, in step 6, the actual validity period of the local cache record is managed according to the cache expiration time, specifically including: judging whether the update database is available; if the update database is available, the actual validity period of the cache is the earlier time point between the TTL expiration time and the active pull update interval Δ time; if the update database is unavailable, automatically falling back to the traditional TTL mechanism; if the recursive server does not support the active pull update mechanism based on the update database, the traditional TTL expiration mechanism is used alone.

[0028] In a second aspect, a push-based DNS cache update device is provided, wherein the device is provided on a recursive server, and the recursive server is configured to periodically initiate an update DNS query request to an update database, and delete a local cache based on a domain name list in an update DNS response returned by the update database, wherein the device comprises:

[0029] A DNS query request receiving module is used to receive DNS query requests sent by the client;

[0030] A valid record checking module is used to check whether there is a valid record in the local cache according to the DNS query request; if there is a valid record in the local cache, the valid record is returned to the client; if there is no valid record in the local cache or the valid record has expired, a cache miss event is triggered and the latest resolution result is obtained from the authoritative server; after the DNS record is changed, the authoritative server will actively send an insert domain name request to the update database and send the changed domain name information to the update database;

[0031] A parsing result insertion module is used to insert the latest parsing result into the local cache and set the cache expiration time according to the TTL value returned by the authoritative server;

[0032] The parsing result returning module is used to return the latest parsing result to the client and manage the actual validity period of the local cache record according to the cache expiration time.

[0033] In a third aspect, a computer device includes a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, the processor implements the steps of a push-based DNS cache update method.

[0034] Compared with the prior art, this application has at least the following beneficial effects:

[0035] 1. The present application provides a push-based DNS cache update method, which is applied to a recursive server. The recursive server is used to periodically initiate an update DNS query request to the update database, and delete the local cache according to the domain name list in the update DNS response returned by the update database. The method includes: receiving a DNS query request sent by a client, and preferentially checking whether there is a valid record in the local cache. If so, the valid record is returned to the client; if not, a cache miss event is triggered, and the latest resolution result is obtained from the authoritative server; after the DNS record is changed, the authoritative server will actively send an insert domain name request to the update database, and send the changed domain name information to the update database; insert the latest resolution result into the local cache, and set the cache expiration time according to the TTL value returned by the authoritative server; return the latest resolution result to the client, and manage the actual validity period of the local cache record according to the cache expiration time. In the push-based DNS cache update method provided by the present application, the authoritative server pushes an event to the update database after the change, and the recursive resolver pulls the incremental update list at a fixed interval and ensures global synchronization within the fixed interval, breaking through the delay bottleneck of traditional DNS relying on TTL passive updates and realizing real-time updates.

[0036] 2. This application determines whether the update database is available. If it is available, the actual validity period of the cache is the earlier time point between the TTL expiration time and the active pull update interval Δ time; if it is not available, it automatically falls back to the traditional TTL mechanism; if the recursive server does not support the active pull update mechanism based on the update database, the traditional TTL expiration mechanism is used alone, thereby decoupling the update timeliness from TTL and improving the update efficiency and flexibility. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] To more intuitively illustrate the prior art and the present application, exemplary drawings are provided below. It should be understood that the specific shapes and structures shown in the drawings should not generally be considered as limiting conditions for implementing the present application; for example, based on the technical concepts disclosed in this application and the exemplary drawings, those skilled in the art are capable of easily making routine adjustments or further optimizations to the addition / reduction / attribution division, specific shapes, positional relationships, connection methods, dimensional ratios, etc. of certain units (components).

[0038] Figure 1 A flowchart of a push-based DNS cache update method provided in Example 1 of the present application;

[0039] Figure 2 This is an interactive flow chart of a push-based DNS cache update method provided in Example 1 of the present application;

[0040] Figure 3 A structural diagram of a push-based DNS cache update system provided in Example 3 of the present application. DETAILED DESCRIPTION

[0041] The present application will be further described below in detail through specific embodiments in conjunction with the accompanying drawings.

[0042] In the description of this application: unless otherwise specified, the meaning of "plurality" is two or more. The terms "first", "second", "third", etc. in this application are intended to distinguish the objects referred to and do not have any special meaning in terms of technical connotation (for example, they should not be understood as emphasizing the importance or order, etc.). Expressions such as "including", "comprising", "having", etc. also mean "not limited to" (certain units, components, materials, steps, etc.).

[0043] The terms such as "upper", "lower", "left", "right", "middle", etc. cited in this application are usually used to indicate the general relative position relationship for the convenience of intuitive understanding by referring to the drawings, and are not absolute limitations on the position relationship in the actual product.

[0044] Example 1

[0045] See also Figure 1 and Figure 2 This embodiment provides a push-based DNS cache update method. The method is applied to a recursive server. The recursive server is configured to periodically initiate a DNS update query request to an update database and delete the local cache based on the domain name list in the DNS update response returned by the update database (i.e., the active pull update phase). The method includes:

[0046] S1: Receives the DNS query request sent by the client;

[0047] S2: First check whether there is a valid record in the local cache based on the DNS query request;

[0048] S3: If there is a valid record in the local cache, the valid record is returned to the client;

[0049] S4: If there is no valid record in the local cache or the valid record has expired, a cache miss event is triggered and the latest resolution result is obtained from the authoritative server. After the DNS record is changed, the authoritative server will actively send an insert domain name request to the update database and send the changed domain name information to the update database.

[0050] Specifically, if the local cache does not exist or has expired, a cache miss event is triggered and the standard DNS resolution process begins.

[0051] The standard DNS resolution process (when the cache misses) includes: the recursive server follows the traditional DNS protocol, starting from the root server and querying step by step, passing through the root domain name server → top-level domain server → authoritative servers at all levels, until the query accesses the authoritative server where the domain name is located and obtains the latest resolution result.

[0052] In this step, once the authoritative server completes the DNS record modification operation (e.g., IP address change, record type adjustment, etc.), it immediately performs the following operations (i.e., the domain name update triggering phase):

[0053] S401: Generate a domain name insertion request instruction;

[0054] The insert domain request instruction contains the domain identifier, record type, change timestamp and digital signature:

[0055] Domain name identifier: Full domain name (e.g., www.example.com, with the protocol identifier removed to avoid redundancy);

[0056] Record type: Specify the DNS record type (such as A record, AAAA record, MX record, etc.);

[0057] Change timestamp: ensure time series consistency;

[0058] Digital signature: Use the authoritative server private key to digitally sign the first three items to prevent data tampering.

[0059] S402: Send the domain name insertion request instruction to the update database through a secure channel (such as HTTPS / TLS).

[0060] Specifically, after receiving the domain name insertion request instruction, the update database executes the verification and storage process in sequence, including:

[0061] S4021: Signature Verification: Verify the integrity and legitimacy of the instruction using the preset authoritative server public key, and reject requests that fail verification.

[0062] S4022: Time window check (optional): If you configure an anti-replay attack policy, you need to check whether the difference between the timestamp and the current time is within a reasonable threshold (such as ±5 minutes).

[0063] S4023: Distributed write: Write legal events to distributed database shards in timestamp order to ensure high availability and data persistence.

[0064] S5: Insert the latest parsing result into the local cache and set the cache expiration time according to the TTL value returned by the authoritative server;

[0065] S6: Return the latest parsing result to the client and manage the actual validity period of the local cache record according to the cache expiration time.

[0066] In this step, the actual validity period of the local cache record is managed according to the cache expiration time, specifically including:

[0067] S601: Determine whether the update database is available;

[0068] S602: If the updated database is available, the actual validity period of the cache is the earlier time point between the TTL expiration time and the active pull update interval Δ time;

[0069] This step is a hybrid invalidation strategy, that is, if the updated database is available, the actual validity period of the cache is determined by the "TTL expiration time" and the "active pull update interval Δ time", whichever is earlier.

[0070] S603: If the update database is unavailable, automatically fall back to the traditional TTL mechanism;

[0071] This step is a TTL fault-tolerant fallback strategy, that is, if the update database is unavailable, it will automatically fall back to the traditional TTL mechanism to ensure service continuity.

[0072] S604: If the recursive server does not support the active pull update mechanism based on the update database, the traditional TTL expiration mechanism is used alone.

[0073] This step is a backward compatibility guarantee strategy. That is, if the recursive resolver does not support the active pull update mechanism based on the update database, it only needs to use the traditional TTL expiration mechanism alone, and there is no compatibility issue with the overall DNS system.

[0074] In the push-based DNS cache update method provided in this embodiment, the process of the recursive server actively pulling updates specifically includes:

[0075] S001: The recursive server maintains the last synchronization timestamp (initial value is empty or 0) and periodically (interval Δ time, default 60 seconds) initiates an update DNS query request to the update database.

[0076] Specifically, the update DNS query request includes the last synchronization timestamp and the unique identifier of the recursive resolution server, wherein the last synchronization timestamp is used to obtain incremental updates, and the unique identifier of the recursive server is used for log tracking and permission control.

[0077] S002: After receiving the DNS query request, the update database filters out all change events later than the timestamp in the query request and generates a response message (i.e., update DNS response) containing the following content:

[0078] Domain list: a collection of domain names to be updated (e.g. [www.example.com,mail.example.org])

[0079] Latest timestamp: The timestamp of the latest event contained in the current response (used by recursive resolvers to update synchronization status)

[0080] Data checksum (optional): such as a SHA-256 hash value, used to verify the integrity of the response.

[0081] S003: After receiving the response, the recursive server performs cache update operations in sequence.

[0082] Cache update operations specifically include:

[0083] Data integrity check: If the response contains a checksum, verify that the data has not been tampered with;

[0084] Cache mark invalidation: traverse the domain name list and mark the matching entries in the local cache as invalid;

[0085] Asynchronous cleanup mechanism: The background asynchronous mechanism gradually removes invalid entries according to the strategy to avoid excessive instantaneous resource usage.

[0086] To more clearly illustrate a push-based DNS cache update method provided by this embodiment, this embodiment takes the scenario of the Foo-bar online store as an example:

[0087] Scenario: Foo-bar Online Store

[0088] Problem background:

[0089] Misconfiguration: The administrator mistakenly set an IP address and bound it to a 12-hour TTL, causing global resolvers to cache incorrect records and a sudden drop in traffic.

[0090] DDoS attack: With a short TTL (2 minutes), when the authoritative server is attacked, the resolver cannot obtain new records and the service crashes.

[0091] Push-based cache update solution:

[0092] After the administrator updates the record, the authoritative server immediately notifies UpdateDB.

[0093] The resolver fetches the updated list every minute, clears the error cache, and triggers a new resolve.

[0094] Recovery time was reduced from 12 hours / 2 minutes to 66 seconds, avoiding business losses.

[0095] The push-based DNS cache update method provided in this embodiment has the following key points:

[0096] 1. Global update push mechanism

[0097] a. Technical essence: By building a centralized update database as a change event distribution node, efficient synchronization between authoritative servers and recursive resolvers is achieved.

[0098] b. Core implementation: The authoritative server pushes events to the update database after changes; the recursive resolver pulls the incremental update list at a fixed interval Δ to ensure global synchronization within Δ time.

[0099] c. Technical Effects:

[0100] a) Changes to authoritative servers can take effect globally within Δ + network latency, breaking through the latency bottleneck of traditional DNS that relies on passive updates to TTL.

[0101] b) The update database is an independent component, decoupled from the DNS protocol, avoiding intrusive modifications to the existing DNS query link.

[0102] 2. Update Time and TTL Decoupling Mechanism

[0103] a. Technical Essence: By actively marking the cache invalid status, the cache lifecycle management is expanded from a single reliance on TTL to a dual control of "active pull update interval Δ time + TTL".

[0104] b. Core implementation:

[0105] a) Hybrid invalidation strategy: The cache validity period is min (TTL expiration time, active pull update interval Δ time).

[0106] b) Quick fix: The recursive resolver actively cleans up invalid caches, triggering real-time updates even if the TTL has not expired.

[0107] c. Technical Effect: Supports long TTL to reduce query load, while emergency changes can take effect in seconds, balancing efficiency and flexibility.

[0108] 3. Backward compatibility design

[0109] a. Technical essence: Support the coexistence of old and new systems, ensuring smooth transition and fault tolerance.

[0110] b. Core implementation: The update mechanism is independent of the standard DNS protocol. Non-upgraded recursive resolvers continue to rely on the TTL mechanism; upgraded recursive resolvers operate in dual mode and automatically fall back to the TTL mechanism in case of failure.

[0111] c. Technical effect: Supports progressive deployment to avoid the risk of full system upgrades, and traditional parsers still work according to the original logic.

[0112] The push-based DNS cache update method provided in this embodiment has the following advantages:

[0113] (1) Decoupling update time and TTL: Force the cache to be refreshed by pushing events, and correct error records in seconds if the TTL has not expired.

[0114] (2) Improve system availability: Reduce service interruption time caused by TTL restrictions (from hours to minutes).

[0115] (3) Reduce operating costs: Support long TTL, reduce invalid query traffic, and alleviate the load on authoritative servers.

[0116] (4) Compatibility and security: backward compatible with traditional DNS and supports gradual deployment.

[0117] Example 2

[0118] This embodiment provides a push-based DNS cache update device, which is provided on a recursive server. The recursive server is configured to periodically initiate an update DNS query request to an update database and delete the local cache based on the domain name list in the update DNS response returned by the update database. The device includes:

[0119] A DNS query request receiving module is used to receive DNS query requests sent by the client;

[0120] A valid record checking module is used to check whether there is a valid record in the local cache according to the DNS query request; if there is a valid record in the local cache, the valid record is returned to the client; if there is no valid record in the local cache or the valid record has expired, a cache miss event is triggered and the latest resolution result is obtained from the authoritative server; after the DNS record is changed, the authoritative server will actively send an insert domain name request to the update database and send the changed domain name information to the update database;

[0121] A parsing result insertion module is used to insert the latest parsing result into the local cache and set the cache expiration time according to the TTL value returned by the authoritative server;

[0122] The parsing result returning module is used to return the latest parsing result to the client and manage the actual validity period of the local cache record according to the cache expiration time.

[0123] For the specific implementation content of each module in a push-based DNS cache update device, please refer to the above definition of a push-based DNS cache update method, which will not be repeated here.

[0124] Example 3

[0125] See also Figure 3 This embodiment provides a push-based DNS cache update system, including:

[0126] Update database, a distributed global database deployed in the cloud, which stores recently updated domain name records (including metadata such as timestamps and subdomain identifiers);

[0127] The authoritative server is used to proactively send a domain name insertion request to the update database when a DNS record changes, and send the changed domain name information to the update database;

[0128] The recursive server is used to integrate the active update module, periodically (for example, Δ = 1 minute) initiates a DNS update request to the update database, deletes the local cache based on the domain name list returned in the update DNS response, and requests the authoritative server to obtain the latest record through the standard DNS protocol when the cache misses, and responds to the client and stores it in the local cache synchronously.

[0129] For the specific implementation content of each module in a push-based DNS cache update system, please refer to the above definition of a push-based DNS cache update method, which will not be repeated here.

[0130] Example 4

[0131] This embodiment provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, the steps of a push-based DNS cache update method are implemented.

[0132] The technical features of the above embodiments can be combined arbitrarily (as long as there is no contradiction in the combination of these technical features). In order to make the description concise, not all possible combinations of the technical features in the above embodiments are described; these embodiments that are not explicitly written should also be considered to be within the scope of this specification.

Claims

1. A push-based DNS cache update method, characterized in that: The method is applied to a recursive server, which is used to periodically initiate an update DNS query request to an update database and delete a local cache based on a domain name list in an update DNS response returned by the update database. The method includes: Step 1: Receive the DNS query request sent by the client; Step 2: Prioritize checking whether there is a valid record in the local cache according to the DNS query request; Step 3: If there is a valid record in the local cache, the valid record is returned to the client; Step 4: If there is no valid record in the local cache or the valid record has expired, a cache miss event is triggered, and the authoritative server is requested to obtain the latest resolution result. After the DNS record is changed, the authoritative server will proactively send an insert domain name request to the update database and send the changed domain name information to the update database. Step 5: Insert the latest parsing result into the local cache and set the cache expiration time according to the TTL value returned by the authoritative server; Step 6: Return the latest parsing result to the client, and manage the actual validity period of the local cache record according to the cache expiration time.

2. The push-based DNS cache update method according to claim 1, characterized in that: The update database is a distributed global database deployed in the cloud.

3. The push-based DNS cache update method according to claim 1, characterized in that: The update DNS query request includes a last synchronization timestamp and a unique identifier of the recursive server.

4. The push-based DNS cache update method according to claim 3, characterized in that: After receiving the update DNS query request sent by the recursive server, the update database filters out all change events later than the last synchronization timestamp according to the last synchronization timestamp in the update DNS query request, and generates an update DNS response; wherein, the update DNS response also includes the latest timestamp and data check value.

5. The push-based DNS cache update method according to claim 4, characterized in that: After receiving the updated DNS response, the recursive server needs to perform data integrity verification, cache mark invalidation and asynchronous cleaning mechanism.

6. The push-based DNS cache update method according to claim 1, characterized in that: In step 4, the domain name insertion request includes a domain name identifier, a record type, a change timestamp, and a digital signature.

7. The push-based DNS cache update method according to claim 1, characterized in that: In step 4, after receiving the domain name insertion request, the update database first performs signature verification, then checks the time window, and finally performs distributed writing.

8. The push-based DNS cache update method according to claim 1, characterized in that: In step 6, the actual validity period of the local cache record is managed according to the cache expiration time, specifically including: judging whether the update database is available; if the update database is available, the actual validity period of the cache is the earlier time point between the TTL expiration time and the active pull update interval Δ time; if the update database is not available, it automatically falls back to the traditional TTL mechanism; if the recursive server does not support the active pull update mechanism based on the update database, the traditional TTL expiration mechanism is used alone.

9. A push-based DNS cache update device, characterized in that: The device is provided on a recursive server, and the recursive server is used to periodically initiate an update DNS query request to an update database, and delete a local cache according to a domain name list in an update DNS response returned by the update database. The device includes: A DNS query request receiving module is used to receive DNS query requests sent by the client; A valid record checking module is used to check whether there is a valid record in the local cache according to the DNS query request; if there is a valid record in the local cache, the valid record is returned to the client; if there is no valid record in the local cache or the valid record has expired, a cache miss event is triggered and the latest resolution result is obtained from the authoritative server; after the DNS record is changed, the authoritative server will actively send an insert domain name request to the update database and send the changed domain name information to the update database; A parsing result insertion module is used to insert the latest parsing result into the local cache and set the cache expiration time according to the TTL value returned by the authoritative server; The parsing result returning module is used to return the latest parsing result to the client and manage the actual validity period of the local cache record according to the cache expiration time.

10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, wherein: When the processor executes the computer program, the steps of the method according to any one of claims 1 to 7 are implemented.

Images