Tous les développeurs acceptent et utilisent de manière inconsciente l'idée que localhost == 127.0.0.1, tout comme ils acceptent 1+1=2. Cependant, tout comme les mathématiciens cherchent à prouver pourquoi 1+1 fait 2, je me suis soudainement demandé pourquoi cela fonctionne de cette manière. J'ai donc décidé d'explorer ce principe et, en conséquence, j'ai acquis une nouvelle compréhension du mécanisme de communication sous Linux. Cela m'a permis d'apprécier la rigueur logique des développeurs, et je n'ai pas pu m'empêcher d'être impressionné par le processus d'apprentissage. Voici un résumé de ce que j'ai appris au cours de ce processus.

1. Comment localhost se connecte-t-il à 127.0.0.1 ?

Question: Pourquoi l'appel de localhost conduit-il à 127.0.0.1 ?

Réponse: Lorsque des requêtes réseau se produisent, le système Linux convertit les noms de domaine en adresses IP. Dans ce processus, il commence par vérifier le fichier /etc/hosts. Par défaut, le fichier /etc/hosts contient les réglages suivants :

127.0.0.1    localhost

Dans ce cas, 127.0.0.1 fait référence à l'interface de boucle locale (loopback) et signifie soi-même. Par conséquent, lorsque vous appelez http://localhost dans un navigateur ou un terminal, Linux redirige directement cette demande à 127.0.0.1 sans passer par le DNS grâce au fichier /etc/hosts. En conséquence, le nom localhost fonctionne comme un alias représentant soi-même au sein de Linux.

2. Qu'est-ce que le fichier /etc/hosts et quel est son rôle ?

Question: Quel est le mécanisme précis de fonctionnement du fichier /etc/hosts ?

Réponse: Le fichier /etc/hosts est l'un des mécanismes de base dans le processus de résolution de noms d'hôtes sous Linux. Lorsqu'une requête réseau se produit, Linux traduit les noms de domaine en adresses IP dans l'ordre suivant :

1. Vérification du fichier /etc/hosts: La fonction getaddrinfo() fournie par la bibliothèque glibc de Linux est le point de départ de toutes les requêtes réseau. Cette fonction vérifie d'abord le fichier /etc/hosts pour résoudre l'adresse IP d'un domaine. Si le domaine est défini dans /etc/hosts, Linux utilise cette information pour renvoyer immédiatement l'adresse IP sans passer par le serveur DNS.
2. Demande au serveur DNS: Si le domaine n'est pas défini dans le fichier /etc/hosts, Linux interroge le serveur DNS configuré pour obtenir l'adresse IP.

Le fichier /etc/hosts s'applique à toutes les requêtes réseau et fonctionne de la même manière pour les bibliothèques de requêtes réseau comme les navigateurs, curl, ping, et le module requests de Python.

3. Que permet l'utilisation de /etc/hosts ?

Question: Quels effets ont l'ajout d'un domaine dans le fichier /etc/hosts ?

Réponse: En ajoutant un nom de domaine et une adresse IP souhaités dans le fichier /etc/hosts, vous pouvez établir une connexion au domaine sans passer par le DNS, directement à l'adresse IP configurée. Par exemple :

127.0.0.1    localhost
127.0.0.1    app1.local
127.0.0.1    app2.local

Avec cette configuration :

• Si des requêtes sont envoyées à app1.local ou app2.local, Linux les redirigera vers 127.0.0.1.
• Cela est utile lors des tests de domaines virtuels ou des communications internes entre applications dans un environnement de développement.
• Le domaine demandé fonctionnera de manière similaire à localhost, tout en permettant une gestion indépendante de chaque domaine.

4. Comment Nginx et Gunicorn collaborent-ils avec /etc/hosts ?

Question: Un serveur comme Nginx peut-il interagir avec le fichier /etc/hosts ?

Réponse: Les serveurs web comme Nginx fonctionnent au-dessus de la couche réseau de Linux, ils suivent donc les domaines configurés dans /etc/hosts. Par exemple :

• Si 127.0.0.1 app1.local est configuré dans /etc/hosts, Nginx redirigera cette demande de domaine vers l'application mappée sur 127.0.0.1.
• Nginx peut configurer des hôtes virtuels pour séparer les requêtes par domaine. Exemple :

server {
    server_name app1.local;
    location / {
        proxy_pass http://127.0.0.1:8000;  # service app1
    }
}

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

Cette configuration permet de faire fonctionner deux applications de manière indépendante sur le même serveur.

5. Comment le fichier /etc/hosts est-il utile dans les environnements de développement ?

Question: Dans quelles situations le fichier /etc/hosts est-il réellement utile ?

Réponse: Le fichier /etc/hosts est particulièrement utile dans les environnements de développement et de test dans les situations suivantes :

• Tests de domaines locaux: Permet de tester un domaine spécifique dans l'environnement local. Exemple : mapping de https://test.local sur une application locale.
• Contourner le DNS: Connecter temporairement à une autre IP sans la configuration réelle d'un serveur DNS. Exemple : relier example.com à une autre IP de serveur.
• Communications internes entre applications: En utilisant /etc/hosts pour les communications entre plusieurs applications exécutées sur le même serveur, cela réduit les requêtes DNS et optimise la vitesse de communication.

6. La valeur de /etc/hosts face aux problèmes de DNS et d'IP dynamique

Expérience personnelle: Les développeurs utilisant des IP dynamiques résolvent généralement les problèmes de changement d'IP grâce à DDNS (DNS dynamique). Cependant, il existe un inconvénient. Les hôtes Linux possèdent un cache DNS qui continue d'utiliser l'ancienne IP jusqu'à l'expiration du TTL (Time to Live), sauf si on supprime manuellement le cache avec la commande sudo resolvectl flush-caches. Cela peut entraîner des échecs de communication entre applications en envoyant des requêtes TCP à l'ancienne IP.

Pour résoudre ce problème, l'utilisation de /etc/hosts permet de rediriger un domaine vers une IP fixe en contournant le DNS. Cela a été une expérience précieuse pour éviter les interruptions de communication dues aux problèmes de changement d'IP. Il est très impressionnant de constater qu'une simple configuration peut être essentielle à la résolution de problèmes.

En conclusion

À travers tout ce processus, j'ai découvert que l'utilisation inconsciente de localhost et du fichier /etc/hosts est en fait intimement liée aux mécanismes de réseau fondamentaux de Linux. J'ai été impressionné par la logique et la rigueur avec lesquelles les développeurs Linux ont conçu ces structures de base. Il est surprenant qu'un simple fichier puisse jouer un rôle aussi important tant dans l'environnement de développement que dans l'environnement de production.

Cette expérience m'a permis de réaliser à quel point il est bénéfique de comprendre l'essence de la technologie. 😊