Comment Internet fonctionne
Un paquet, une adresse, un port, un annuaire. Louis Pouzin a inventé la poste — le reste, c'est du tri.
42 secondes · sous-titres Français inclus · 8.8 Mo
Les 7 trucs que tu vas savoir faire
Leçon 11 : Comment Internet fonctionne
Regarde la leçon (42 s) : 1971, un Français invente le paquet qui voyage tout seul. Ensuite, tout le reste n'est que de l'adresse, des portes et un annuaire.
L'adresse : quatre nombres, trois points
Écris `adresse(a, b, c, d)` : l'adresse IP en quatre nombres — `adresse(203, 113, 7, 42)` → `"203.113.7.42"`. Quatre octets, trois points, dans l'ordre.
Le datagramme de Pouzin
Écris `datagramme(src, dst, donnees)` : le paquet complet — un Hash avec `"src"`, `"dst"` et `"data"`. Idée de Louis Pouzin en 1971 : tout le voyage est DANS le paquet.
Sur la même adresse, une autre porte
Écris `port(service)` : `"http"` → 80 · `"https"` → 443 · `"ssh"` → 22 · tout autre service → `nil`. Même machine, autre porte : c'est ça qui sépare le web du SSH.
Le DNS, l'annuaire
Écris `resoudre(nom)` : le DNS — `"slopcourse.fr"` → `"203.113.7.42"` · `"42.fr"` → `"198.51.100.42"` · nom inconnu → `nil`. Tu tapes un nom, il te rend une adresse.
Attrape le paquet
Écris `attrape?(reseau, mon_port, dst, port)` : true SI `dst` commence par MON réseau (comme `"10.0.0."`) ET que le port du paquet vaut `mon_port`. Bon réseau + bonne porte — sinon tu laisses passer.
Leçon 11 : OK
Sans aide : `joue(moi, paquet)` — 1) résous `moi` dans ce DNS : `"slopcourse.fr"` → `"203.113.7.42"`, `"42.fr"` → `"198.51.100.42"` · 2) mon réseau = les trois premiers chiffres + `"."` · 3) attrape si `paquet["dst"]` est sur mon réseau ET `paquet["port"] == 443`. Nom inconnu → `false`.
📄 La feuille de chute
imprime-la, colle-la à ton écran, fais semblant que c'est ton idée📄 Cheat sheet — Comment Internet fonctionne (Louis Pouzin & le datagramme)
1971, Louis Pouzin invente le paquet qui porte sa propre adresse. Depuis, Internet n'est qu'une poste géante : une adresse, une porte, un annuaire.
L'histoire, en trois lignes
| Année | Ce qui s'est passé | Ce que ça a apporté |
|---|---|---|
| 1971 | Louis Pouzin (CYCLADES) invente le datagramme | le paquet autonome : tout le voyage est dedans |
| 1974 | Cerf & Kahn (TCP/IP) s'en inspirent | le contrat d'Inter-Net : best effort, pas de route garantie |
| aujourd'hui | des milliards de paquets par seconde | tes 4 notions : adresse · port · DNS · tri |
Pouzin : au lieu de construire un circuit entre deux machines (le téléphone), on découpe en paquets, on adresse chacun, on envoie. Chaque routeur fait son tri local. C'est le geste fondateur.
1. L'adresse IP : un quartier, puis une maison
def adresse(a, b, c, d)
"#{a}.#{b}.#{c}.#{d}"
end
adresse(203, 113, 7, 42) # => "203.113.7.42"
# réseau = les 3 premiers octets ici (notre raccourci de jeu)
ip.split(".")[0..2].join(".") + "." # => "203.113.7."
Le début dit le réseau (le quartier), la fin dit l'hôte (la maison). Même rue, autres numéros.
2. Le datagramme : l'enveloppe complète
def datagramme(src, dst, donnees)
{ "src" => src, "dst" => dst, "data" => donnees }
end
datagramme("10.0.0.1", "10.0.0.2", "ping")
# => {"src"=>"10.0.0.1", "dst"=>"10.0.0.2", "data"=>"ping"}
Expéditeur, destinataire, contenu : rien à chercher ailleurs. (C'est ça, l'idée de Pouzin.)
3. Les portes : une adresse, plusieurs services
case service
when "http" then 80
when "https" then 443
when "ssh" then 22
else nil # service inconnu : la porte n'existe pas pour nous
end
Une machine, plusieurs portes : l'adresse t'amène à la maison, le port t'amène à la pièce.
4. Le DNS : l'annuaire
case nom
when "slopcourse.fr" then "203.113.7.42"
when "42.fr" then "198.51.100.42"
else nil
end
Tu tapes un nom, il te rend un chiffre. Pas de magie : un case/when à l'échelle du monde
(le vrai DNS sont des millions de lignes du même genre, réparties en hiérarchie).
5. Le jeu : attraper le paquet
def attrape?(reseau, mon_port, dst, port)
dst.start_with?(reseau) && port == mon_port
end
attrape?("10.0.0.", 8080, "10.0.0.42", 8080) # => true
attrape?("10.0.0.", 8080, "192.168.1.5", 8080) # => false — autre quartier
attrape?("10.0.0.", 8080, "10.0.0.42", 22) # => false — autre porte
Les deux conditions, toujours. Un && — et la moitié du filtrage d'Internet tient là :
mon réseau ET mon port.
Le tour complet (ce que fait ton routeur, en une fonction)
# 1. DNS : nom -> adresse 2. adresse -> réseau 3. paquet: réseau + port == moi ?
# 4. oui -> j'attrape 5. non -> je laisse passer (et quelqu'un d'autre attrapera)
À ne plus jamais dire
"Internet envoie des données dans un tube"→ des paquets autonomes, chacun avec son adresse"il faut une connexion permanente"→ Pouzin a prouvé le contraire en 1971"le DNS est magique"→ un annuaire nom → adresse ; le tien tiendrait en dix lignes de Ruby
SlopCourse 
— du slop au code propre.