All developers unconsciously accept and use the concept that localhost is equivalent to 127.0.0.1, much like the mathematical notion that 1+1=2. However, just as mathematicians strive to prove why 1+1 equals 2, I unexpectedly found myself curious about this today. Consequently, I delved into the underlying principle and gained a new understanding of Linux's communication mechanism. This experience highlighted the logical rigor of developers, and I found myself amazed while uncovering the principle. Below is a summary of what I learned.

1. How does localhost connect to 127.0.0.1?

Question: Why does calling localhost connect to 127.0.0.1?

Answer: When a network request is made, the Linux system resolves the domain name to an IP address. During this process, it first checks the /etc/hosts file. By default, the /etc/hosts file includes the following configuration:


127.0.0.1    localhost

127.0.0.1 refers to the loopback interface, which means it refers to itself. Therefore, when you call http://localhost from your browser or terminal, Linux directs this request directly to 127.0.0.1 via the /etc/hosts file, bypassing DNS. Consequently, localhost functions internally in Linux as an alias for itself.

2. What is the /etc/hosts file and what role does it play?

Question: How exactly does the /etc/hosts file work?

Answer: The /etc/hosts file is one of the most fundamental mechanisms in Linux's hostname resolution process. When a network request occurs, Linux resolves the domain name to an IP address in the following order:

  1. Check the /etc/hosts file: The getaddrinfo() function, provided by Linux's glibc library, is the starting point for all network requests. This function first checks the /etc/hosts file when resolving a domain's IP address. If the domain is defined in /etc/hosts, Linux uses this information to return the IP address directly, bypassing the DNS server.
  2. Query DNS server: If the domain is not defined in the /etc/hosts file, it looks up the IP address via the configured DNS server.

The /etc/hosts file applies to all network requests and operates consistently across various network request libraries such as browsers, curl, ping, and Python's requests module.

3. What can be achieved by utilizing /etc/hosts?

Question: What effect would adding a domain name to the /etc/hosts file have?

Answer: By adding a desired domain name and IP address to the /etc/hosts file, requests for that domain will connect directly to the specified IP, bypassing DNS. For example:


127.0.0.1    localhost
127.0.0.1    app1.local
127.0.0.1    app2.local

With this setup:

  • Requests to app1.local and app2.local will be routed by Linux to 127.0.0.1.
  • This is useful for virtual domain testing or internal communication between applications in a development environment.
  • The requested domains have the same effect as localhost but can be handled independently.

4. How do Nginx and Gunicorn collaborate with /etc/hosts?

Question: Can servers like Nginx and Gunicorn interact with the /etc/hosts file?

Answer: Since web servers like Nginx operate above the Linux networking layer, they respect the domain mappings defined in /etc/hosts. For example:

  • If 127.0.0.1 app1.local is set in /etc/hosts, Nginx routes requests for this domain to the application mapped to 127.0.0.1.
  • You can set up virtual hosts in Nginx to differentiate requests by domain. Example:
server {
    server_name app1.local;
    location / {
        proxy_pass http://127.0.0.1:8000;  # app1 service
    }
}

server {
    server_name app2.local;
    location / {
        proxy_pass http://127.0.0.1:8001;  # app2 service
    }
}

This configuration allows running two applications independently on the same server.

5. How is /etc/hosts useful in development environments?

Question: In what situations is the /etc/hosts file actually useful?

Answer: The /etc/hosts file is particularly useful in development and testing environments for the following situations:

  • Local domain testing: You can test specific domains in a local environment. For example, mapping https://test.local to a local application.
  • DNS bypass: Temporarily connect to a different IP without needing actual DNS server configurations. For example, routing example.com to another server IP.
  • Internal communication between applications: Using /etc/hosts for communication between multiple applications running on the same server reduces DNS requests and optimizes communication speed.

6. The value of /etc/hosts in dynamic IP and DNS cache issues

Personal experience: Developers using dynamic IPs typically resolve IP change issues through DDNS (Dynamic DNS). However, a common issue arises: Linux hosts maintain a DNS cache, which can cause them to continue using a previous IP until its TTL (Time to Live) expires. This can lead to issues where applications send TCP requests to outdated IPs unless the cache is manually cleared with the sudo resolvectl flush-caches command.

To solve this problem, using /etc/hosts allows routing a specific domain to a fixed IP, bypassing DNS altogether. Through this, I discovered a way to fundamentally prevent communication issues caused by IP changes. It's quite impressive that such a simple configuration can be key to resolving these issues.

In Conclusion

Through all this, I realized that localhost and the /etc/hosts file, which I had unconsciously used, are closely connected to the fundamental networking mechanism of Linux. The logical rigor with which Linux developers designed such fundamental structures fills me with awe. It's surprising how a single, simple file can play such an important role in both development and production environments.

This experience reaffirmed how beneficial it is to understand the essence of technology. 😊

Illustration of the /etc/hosts file usage