Clearing the Domain Name System cache is a fundamental troubleshooting step for any Linux user experiencing connectivity anomalies. When a system resolves a domain name to an IP address, this mapping is stored locally to speed up subsequent requests. However, when network configurations change, such as switching servers or updating DNS providers, the cached entry can become stale, leading to failed connections or loading the wrong website. This guide provides precise commands and contextual explanations for managing the DNS resolver cache on various Linux distributions.
Understanding the DNS Cache Mechanism
Before initiating a flush, it is essential to understand what the cache actually stores and how different networking components interact. Modern Linux systems do not rely on a single monolithic service for this task; the behavior depends entirely on the network configuration. The process typically involves a local caching daemon, a systemd service, or a dedicated resolver library. If you are unsure which stack your system is using, attempting to flush a non-existent service will result in an error, making diagnosis the logical first step.
Identifying Your Current Resolver
To manage the cache effectively, you must first identify the active service. The traditional `nscd` (Name Service Cache Daemon) is largely deprecated, while modern systems utilize `systemd-resolved` or rely on direct `dnsmasq` instances. NetworkManager and Docker environments also maintain their own internal caches. Running a diagnostic command will reveal which process is currently handling name resolution, ensuring you target the correct component rather than wasting effort on an inactive service.
Method 1: Systemd-Resolved (Most Modern Distributions)
The `systemd-resolved` service is the default on distributions like Ubuntu 22.04, Fedora, and recent versions of Debian. This init system provides a built-in interface for cache management, eliminating the need for external tools. The cache statistics and health status are exposed through the `resolvectl` command, which offers a clear view of cache hits and current settings before and after the flush operation.
Executing the Flush
To purge the cache managed by systemd, you need to invoke the resolvectl utility with the flush-caches directive. This operation requires elevated privileges, necessitating the use of sudo. Upon execution, the system will immediately clear all stored negative and positive cache entries, forcing the resolver to query authoritative nameservers for the next lookup.
Verification and Statistics
After performing the flush, verifying the result is crucial to ensure the operation was successful. You can use the statistics command to confirm that the cache entries have dropped to zero. This step confirms that the flush was not only executed but also that the system is now operating with a clean slate, ready to rebuild the cache with accurate data.
Method 2: NetworkManager and dnsmasq
Many desktop environments rely on NetworkManager to handle network interfaces, which often integrates with dnsmasq for local DNS resolution. In this architecture, the cache is not managed by systemd-resolved but by the dnsmasq instance running as a user service. Flushing requires interacting with the dnsmasq process directly, as the standard systemd commands will not affect this specific daemon.
Command Execution
To clear the cache in this environment, you send a reload signal to the dnsmasq process via the NetworkManager dispatcher. The specific command triggers a restart of the caching logic, effectively wiping the lookup table without disrupting the overall network connection. This method is particularly useful for laptops that frequently switch between networks.
Method 3: Legacy Systems and nscd
For older servers or intentionally minimal installations, you might encounter the Name Service Cache Daemon (nscd). This service predates systemd and operates as a standalone daemon. While less common in 2024, it is still present in some production environments or legacy Docker images. Managing it requires direct interaction with the nscd binary to control the cache lifecycle.
