TCP garantit que tout arrive dans l'ordre. UDP envoie vite et ne promet rien. Quand choisir lequel ?
⏱️ Durée : environ 85 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Maître des sockets
🎬 L'histoire
HashBox ajoute deux fonctions : un chat entre apprenants et des cours en visioconférence. Kodi veut utiliser TCP pour les deux. Sam hésite.
« Pour le chat, oui : on ne veut perdre aucun message. Pour la vidéo, un paquet perdu vaut mieux qu'une image en retard. Il faut deux outils. »
Tu comprends les deux protocoles de transport, et tu écris tes premiers serveurs et clients avec des sockets.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer le rôle des ports et des sockets
- décrire la poignée de main en trois temps de TCP
- expliquer ce que TCP garantit et ce que UDP ne garantit pas
- écrire un serveur et un client TCP avec
socket - expliquer le problème des frontières de messages dans TCP
🧩 Défi d'échauffement (5 XP)
Deux façons de transmettre un message : (A) un appel téléphonique : on compose, l'autre décroche, on se parle, on raccroche ; si on n'entend pas, on répète. (B) une carte postale : on l'envoie, aucune confirmation, elle peut se perdre ou arriver dans le désordre. Quels usages conviennent à chacune ? Que ferais-tu pour envoyer un livre en 10 cartes postales ?
💡 Le concept
Les ports et les sockets
Une adresse IP désigne une machine. Un port (nombre de 0 à 65 535) désigne un programme sur cette machine. Un socket est l'extrémité d'une communication, identifiée par (adresse IP, port).
| Port | Service |
|---|---|
| 22 | SSH |
| 25 | SMTP (envoi de mail) |
| 53 | DNS |
| 80 | HTTP |
| 443 | HTTPS |
Une connexion est identifiée par quatre valeurs : IP source, port source, IP destination, port destination.
UDP : le message isolé
- Pas de connexion : on envoie des datagrammes indépendants.
- Pas de garantie : perte, doublon, désordre possibles.
- Léger et rapide.
- Usages : DNS, voix et vidéo en direct, jeux, découverte réseau.
TCP : le flux fiable
- Connexion établie avant l'échange.
- Flux d'octets ordonné et sans perte.
- Accusés de réception, retransmission en cas de perte, ordre garanti.
- Contrôle de flux (ne pas submerger le récepteur) et de congestion (ne pas submerger le réseau).
- Usages : web, e-mail, transferts de fichiers, bases de données.
La poignée de main en trois temps
sequenceDiagram
participant C as Client
participant S as Serveur
C->>S: SYN (je voudrais me connecter)
S->>C: SYN-ACK (d'accord, et moi aussi)
C->>S: ACK (connexion établie)
C->>S: données
S->>C: ACK des données
C->>S: FIN (j'ai fini)
S->>C: FIN-ACK
Description du schéma : le client envoie SYN, le serveur répond SYN-ACK, le client confirme avec ACK : la connexion est établie. Ils échangent des données avec accusés de réception, puis se quittent avec FIN.
Le coût : un aller-retour avant le premier octet de données.
TCP est un flux, pas des messages
TCP ne conserve pas les frontières des messages. Si tu envoies « bonjour » puis « monde », le récepteur peut lire « bonjourmonde » en une fois, ou « bonj » puis « ourmonde ». Il faut donc définir un protocole de découpage : un séparateur (ligne \n) ou une longueur annoncée.
Un serveur TCP et un client en Python
import socket, threading
def serveur(ecouteur):
connexion, _ = ecouteur.accept()
with connexion:
donnees = connexion.recv(1024)
connexion.sendall(b"echo: " + donnees)
ecouteur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ecouteur.bind(("127.0.0.1", 0)) # port 0 : le système choisit un port libre
ecouteur.listen()
port = ecouteur.getsockname()[1]
threading.Thread(target=serveur, args=(ecouteur,), daemon=True).start()
with socket.create_connection(("127.0.0.1", port), timeout=2) as client:
client.sendall(b"bonjour")
print(client.recv(1024)) # b'echo: bonjour'
ecouteur.close()
UDP en Python
import socket
recepteur = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
recepteur.bind(("127.0.0.1", 0))
port = recepteur.getsockname()[1]
emetteur = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
emetteur.sendto(b"salut", ("127.0.0.1", port)) # pas de connexion
print(recepteur.recvfrom(1024)) # (b'salut', (...))
emetteur.close(); recepteur.close()
🧠 Astuce : choisis TCP quand l'exactitude prime, UDP quand la fraîcheur prime.
🔍 Exemple pas à pas
Problème : écrire un petit serveur d'écho ligne par ligne qui gère correctement les frontières de messages avec TCP.
import socket, threading
def gerer(connexion):
with connexion, connexion.makefile("rwb") as fichier:
for ligne in fichier: # lit jusqu'au \n
fichier.write(b"echo: " + ligne)
fichier.flush()
def serveur(ecouteur):
while True:
try:
connexion, _ = ecouteur.accept()
except OSError:
return
threading.Thread(target=gerer, args=(connexion,), daemon=True).start()
ecouteur = socket.socket()
ecouteur.bind(("127.0.0.1", 0))
ecouteur.listen()
port = ecouteur.getsockname()[1]
threading.Thread(target=serveur, args=(ecouteur,), daemon=True).start()
with socket.create_connection(("127.0.0.1", port), timeout=2) as c:
f = c.makefile("rwb")
for message in (b"un\n", b"deux\n", b"trois\n"):
f.write(message)
f.flush()
print(f.readline())
ecouteur.close()
Lecture : on a défini un protocole simple : un message = une ligne terminée par \n. Grâce à lui, le récepteur sait où chaque message s'arrête, quelle que soit la façon dont TCP a découpé les octets. Un protocole peut aussi annoncer la longueur avant les données (struct.pack("!I", n)).
UDP : mesurer la perte (sur la boucle locale il y en a rarement, mais le principe demeure) :
import socket
r = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
r.bind(("127.0.0.1", 0)); r.settimeout(0.5)
port = r.getsockname()[1]
e = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for i in range(5):
e.sendto(f"msg{i}".encode(), ("127.0.0.1", port))
recus = []
try:
while True:
recus.append(r.recvfrom(100)[0].decode())
except socket.timeout:
pass
print(recus, "→", 5 - len(recus), "perdu(s)")
✍️ À toi, avec aide (10 XP)
Complète le tableau, puis justifie un choix pour HashBox :
| Cas d'usage | TCP ou UDP ? | Pourquoi ? |
|---|---|---|
| Chat entre apprenants | ? | ? |
| Visioconférence | ? | ? |
| Téléchargement d'un support de cours | ? | ? |
| Requête DNS | ? | ? |
| Jeu de quiz en temps réel (score) | ? | ? |
💡 Indice 1
Pour le téléchargement, un octet manquant rend le fichier inutilisable.
💡 Indice 2
Pour la voix, un retard rend le son inutilisable.
💡 Indice 3
DNS : une petite question, une petite réponse, on réessaie si perdu.
✅ Réponse
| Cas | Choix | Pourquoi |
|---|---|---|
| Chat | TCP | aucun message ne doit se perdre ni arriver dans le désordre |
| Visioconférence | UDP | une image tardive est inutile ; mieux vaut en perdre une que ralentir |
| Téléchargement | TCP | le fichier doit être complet et exact |
| Requête DNS | UDP (TCP en repli) | question courte, réponse courte, simple de réessayer |
| Quiz en temps réel (score) | TCP pour les actions importantes, UDP éventuellement pour des positions fréquentes | dépend de ce qui peut se perdre sans conséquence |
🚀 À toi, en solo (20 XP)
Protocole à longueur annoncée. Écris un petit protocole où chaque message commence par 4 octets annonçant sa longueur (struct.pack("!I", n)). Implémente :
envoyer_message(sock, octets);recevoir_message(sock)(lit exactement le bon nombre d'octets, même si TCP les livre en plusieurs morceaux).
Teste avec un serveur d'écho et des messages de 5, 5 000 et 100 000 octets.
✅ Pistes de correction
import socket, struct, threading
def recevoir_exactement(sock, n):
morceaux = b""
while len(morceaux) < n:
bloc = sock.recv(n - len(morceaux))
if not bloc:
raise ConnectionError("connexion fermée avant la fin du message")
morceaux += bloc
return morceaux
def envoyer_message(sock, octets):
sock.sendall(struct.pack("!I", len(octets)) + octets)
def recevoir_message(sock):
(n,) = struct.unpack("!I", recevoir_exactement(sock, 4))
return recevoir_exactement(sock, n)
def echo(ecouteur):
c, _ = ecouteur.accept()
with c:
try:
while True:
envoyer_message(c, recevoir_message(c))
except ConnectionError:
pass
ecouteur = socket.socket()
ecouteur.bind(("127.0.0.1", 0)); ecouteur.listen()
port = ecouteur.getsockname()[1]
threading.Thread(target=echo, args=(ecouteur,), daemon=True).start()
with socket.create_connection(("127.0.0.1", port), timeout=) c:
taille (, , ):
msg = (()) * (taille // + )
msg = msg[:taille]
envoyer_message(c, msg)
recevoir_message(c) == msg
()
ecouteur.close()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
Supposer 1 send = 1 recv | Messages coupés ou fusionnés | Définir un protocole de découpage |
| Oublier les délais d'attente | Programme figé si l'autre disparaît | settimeout partout |
| TCP pour tout | Latence inutile pour le temps réel | UDP pour ce qui supporte la perte |
| Fermer sans lire la fin | Données perdues | Fermer proprement (shutdown) après avoir tout lu |
🐉 Mini-boss (40 XP)
Mini serveur de chat TCP. Écris un serveur qui accepte plusieurs clients simultanés (un thread par client). Protocole : une ligne par message ; /pseudo nom définit le nom ; tout autre texte est diffusé aux autres clients sous la forme nom: texte.
- Teste avec 3 clients simulés dans le même programme.
- Gère la déconnexion d'un client sans planter le serveur.
- Ajoute un délai d'inactivité de 2 secondes (déconnexion).
- Explique quelles propriétés de TCP rendent ce chat simple à écrire.
✅ Pistes de correction
import socket, threading, time
clients, verrou = {}, threading.Lock()
def diffuser(source, texte):
with verrou:
for c, nom in list(clients.items()):
if c is not source:
try:
c.sendall(texte.encode() + b"\n")
except OSError:
clients.pop(c, None)
def gerer(c):
c.settimeout(2)
with verrou:
clients[c] = "anonyme"
try:
f = c.makefile("rb")
for ligne in f:
texte = ligne.decode().strip()
if texte.startswith("/pseudo "):
clients[c] = texte[8:]
else:
diffuser(c, f"{clients[c]}: {texte}")
except (OSError, socket.timeout):
pass
finally:
with verrou:
clients.pop(c, None)
c.close()
def serveur(ecouteur):
while :
:
c, _ = ecouteur.accept()
OSError:
threading.Thread(target=gerer, args=(c,), daemon=).start()
ecouteur = socket.socket(); ecouteur.bind((, )); ecouteur.listen()
port = ecouteur.getsockname()[]
threading.Thread(target=serveur, args=(ecouteur,), daemon=).start()
():
s = socket.create_connection((, port), timeout=)
s.sendall(.encode())
s
a, b, c = client(), client(), client()
time.sleep()
a.sendall()
time.sleep()
(b.recv(), c.recv())
a.close()
b.sendall()
time.sleep()
(c.recv())
ecouteur.close()
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. TCP garantit :
- A. la vitesse maximale
- B. la confidentialité
- C. l'ordre et l'absence de perte des octets
2. La poignée de main TCP se déroule en :
- A. trois temps (SYN, SYN-ACK, ACK)
- B. un seul message
- C. cinq échanges
3. UDP est adapté à :
- A. les transferts de fichiers
- B. la voix et la vidéo en direct
- C. les paiements
4. 🔁 Révision mission 04 : Le routeur choisit la route avec :
- A. le plus court préfixe
- B. le plus petit numéro
- C. le plus long préfixe
5. 🔁 Révision mission 04 : Le TTL sert à :
- A. empêcher un paquet de tourner indéfiniment
- B. chiffrer le paquet
- C. compresser le paquet
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Dans ta vie, quand préfères-tu un échange « avec accusé de réception » plutôt qu'un message sans garantie ?
- Pourquoi un protocole doit-il définir où s'arrête un message ?
🎒 À retenir
- Port = programme ; socket = (IP, port).
- TCP : connexion, ordre, fiabilité ; coût d'un aller-retour.
- UDP : datagrammes sans garantie, rapide.
- TCP est un flux : il faut définir les frontières de messages.
- Toujours des délais d'attente.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Maître des sockets
← Mission 04 — Le routage · Mission 06 — DNS : l'annuaire d'internet →
HEF-060 — Réseaux

