Comment deux machines communiquent

Adresses IP, interfaces réseau et paquets.

◷ 20 minutesTravail sur votre machine

Objectifs

À la fin de cette leçon, vous saurez :

expliquer ce qu'est une adresse IP, comment elle s'écrit et à quoi elle sert ;
distinguer machine, interface réseau et adresse ;
expliquer le rôle de la boucle locale (127.0.0.1) dans votre quotidien de développeur ;
décrire le voyage d'un paquet à travers un réseau.

🔗 Pour vous rafraîchir la mémoire : observer les processus

L'adresse IP : l'adresse postale des machines

Pour que deux machines se parlent, chacune a besoin d'être adressable : c'est le rôle de l'adresse IP, l'équivalent réseau d'une adresse postale.

machine A (192.168.1.10)  ──────── réseau ─────────  machine B (192.168.1.20)

Deux familles coexistent aujourd'hui :

	Écriture	Espace d'adresses
IPv4	quatre nombres de 0 à 255 séparés par des points	~4,3 milliards — saturé depuis longtemps
IPv6	huit groupes hexadécimaux (`fe80::1`)	quasi infini (~340 undécillions)

Décomposons une adresse IPv4 pour comprendre sa mécanique :

192.168.1.10
   │    │  │
   │    │  └── chaque nombre tient sur UN OCTET (0–255)
   │    └──── séparés par des points
   └───────── quatre octets = 32 bits au total

Chaque nombre va de 0 à 255 parce qu'il est codé sur 8 bits (2⁸ = 256 valeurs). Quatre octets donnent 2³² ≈ 4,3 milliards d'adresses — énorme en 1980, ridiculement petit face aux milliards de téléphones et objets connectés d'aujourd'hui. C'est pourquoi IPv6 existe ; mais en développement web quotidien, vous manipulerez surtout des adresses IPv4, et c'est notre focus ici.

💡 Besoin d'un rappel sur les bits ? Le chapitre sur le binaire et les portes logiques explique pourquoi « 8 bits = 0–255 » et « 32 bits = 4 octets » avec des conversions à la main.

Machine ≠ interface ≠ adresse : la distinction qui évite les confusions

Une machine peut posséder plusieurs interfaces réseau, chacune étant un point de connexion avec son propre monde :

lo      → 127.0.0.1     (boucle locale : « moi-même », virtuelle)
eth0    → 192.168.1.10  (carte filaire ou interface principale de la VM)
wlan0   → 192.168.1.11  (Wi-Fi, sur un laptop)
docker0 → 172.17.0.1    (réseau interne Docker, si installé)

L'image postale aide encore : la machine est le bâtiment, chaque interface est une porte différente, chaque adresse est l'adresse d'une porte. Une lettre adressée à « la porte Wi-Fi » n'arrive pas par la porte filaire.

Vous observerez ces interfaces vous-même dans deux leçons avec ip addr — retenez dès maintenant la lecture : nom d'interface, état, adresse + masque.

La boucle locale : l'adresse la plus importante du développeur

L'interface lo (loopback) est particulière : elle n'a ni câble ni antenne. C'est un miroir logiciel — tout paquet envoyé à 127.0.0.1 revient immédiatement à votre propre machine, sans jamais toucher le réseau physique.

navigateur ──→ 127.0.0.1:3000 ──→ serveur Node sur la MÊME machine
                (le paquet ne sort jamais de la RAM)

C'est ainsi que fonctionnent vos développements quotidiens : localhost:3000, http://127.0.0.1:3001... Votre frontend parle à votre backend via la boucle locale, sans câble, sans latence réseau, sans firewall. Deux précisions utiles :

tout le bloc 127.x.x.x désigne « soi-même » (127.0.0.2 marche aussi), mais la convention universelle est 127.0.0.1 ;
localhost est un nom qui désigne cette adresse — la résolution nom → IP sera justement le sujet du chapitre DNS.

Conséquence pratique à retenir pour plus tard : un serveur qui écoute sur 127.0.0.1 n'est joignable que depuis sa propre machine. C'est parfait pour la sécurité (une base de données ne devrait parler qu'à ses voisins), et c'est LA cause classique du « mon serveur tourne mais je ne peux pas y accéder depuis ailleurs » — nous y reviendrons.

Le voyage d'un paquet

Les données circulent découpées en paquets — comme un long courrier découpé en enveloppes numérotées :

[ adresse source | adresse destination | données ]
     192.168.1.10       142.250.74.238    GET /...

Le trajet se fait de proche en proche (hop by hop) : aucun équipement ne connaît le chemin complet, chacun fait juste son geste local :

votre VM          → « destination hors de mon réseau ? → passerelle ! »
box/routeur       → « je connais le FAI suivant »
routeur du FAI    → « vers ce backbone »
...               → jusqu'à la machine finale

Chaque routeur lit uniquement l'adresse de destination, consulte SA table de routage, transmet au voisin le mieux placé. C'est exactement le fonctionnement postal : votre lettre passe par plusieurs centres de tri sans que personne ne connaisse tout l'itinéraire.

Trois conséquences à graver :

Le découpage permet le partage : dix machines peuvent entremêler leurs paquets sur le même câble sans se bloquer mutuellement ;
Les paquets peuvent arriver dans le désordre, être dupliqués ou perdus : le réseau livre « au mieux » (best effort), sans garantie. Qui restaure l'ordre et la fiabilité ? TCP — chapitre suivant ;
Un chemin peut tomber : si un routeur meurt, les suivants contournent. Cette résilience est la raison profonde de la conception d'Internet.

Exercice

Sur votre VM, exécutez ip addr : listez vos interfaces, leurs états et leurs adresses.
Quelle différence entre l'adresse de lo et celle de votre interface principale ? Laquelle est visible du reste du réseau ?
Depuis votre machine hôte, testez ping <ip-de-la-vm>. Interprétez le résultat.
Question de synthèse : pourquoi le découpage en paquets permet-il à plusieurs machines de partager le même réseau sans se bloquer ?
Un collègue lance son serveur Node sur le port 3000 et vous dit « viens voir sur http://127.0.0.1:3000 ». Pourquoi ça ne marchera pas depuis VOTRE poste ?

Résumé

Adresse IP = identifiant d'une interface ; IPv4 = 4 octets notés point par point.
Une machine peut avoir plusieurs interfaces ; lo/127.0.0.1 = soi-même, jamais sur le câble.
Les données voyagent en paquets adressés, routés hop par hop, sans garantie (TCP viendra).
Un serveur sur 127.0.0.1 est invisible du dehors : cause n°1 des « je n'y accède pas ».

Correction disponibleCherchez d’abord par vous-même.Voir la correction

Correction

Réponses détaillées

Question 1. Sortie type attendue (abréviations variables selon la VM) :

1: lo: <LOOPBACK,UP,LOWER_UP>
    inet 127.0.0.1/8 scope host lo
2: eth0: <BROADCAST,MULTICAST,UP>
    inet 192.168.65.3/24 ...

UP signifie interface active ; l'adresse est toujours affichée avec son masque (/24) — notion détaillée dans la prochaine leçon.

Question 2. 127.0.0.1 n'existe que dans la machine : aucun paquet à destination de la boucle locale ne sort physiquement, donc cette adresse est invisible du reste du réseau. L'adresse de eth0, en revanche, est l'identité de votre machine vue des autres — c'est elle qu'on utilise pour s'y connecter à distance (SSH, etc.).

Question 3. Selon votre environnement : souvent oui (l'hôte peut atteindre sa VM), parfois non (isolation réseau volontaire). Ce qui compte est la méthode d'interprétation : ping qui répond = joignable AU NIVEAU RÉSEAU — mais joignable ne veut pas dire accessible sur tous les services (un firewall peut laisser passer l'ICMP et bloquer les ports). L'inverse aussi : un ping KO n'empêche pas un service HTTP de répondre si l'ICMP est filtré.

Question 4. Parce qu'un paquet est petit et indépendant : quand A envoie son paquet, B et C peuvent glisser les leurs entre deux. Le médium est partagé par tranches très brèves au lieu d'être monopolisé par un long transfert. (Historiquement, avant cette idée — commutation de paquets —, les réseaux téléphoniques réservaient un circuit entier par communication.)

Question 5. 127.0.0.1 désigne « la machine qui fait la requête » : depuis votre poste, cette URL viserait VOTRE machine, où rien ne tourne sur le port 3000. Il faut l'adresse IP réelle de la machine du collègue (192.168.1.xx:3000) — et encore, à condition que son serveur écoute sur toutes les interfaces plutôt que sur 127.0.0.1, et qu'aucun firewall ne bloque. Trois couches de vérification, exactement le diagnostic appris dans ce chapitre.