Appeler une fonction à distance ressemble à un appel local — jusqu'au jour où la réponse ne vient pas. Alors, l'appel a-t-il eu lieu ?
⏱️ Durée : environ 100 minutes · 🎓 Niveau : avancé · 🏅 Badge : Messager fiable
🎬 L'histoire
Le service d'inscription de HashBox appelle le service de paiement : debiter(membre, 40). La réponse n'arrive jamais. Kodi relance l'appel. Trois jours plus tard, le client se plaint d'avoir été débité deux fois : la première requête avait réussi, c'est seulement la réponse qui s'était perdue.
« Un appel à distance a trois issues, dit Sam : il réussit, il échoue… ou on ne sait pas. C'est la troisième qui change toute la conception. Et elle n'existe pas dans un appel local. »
Tu apprends à construire un mini-RPC avec sockets, à gérer le cadrage des messages, les erreurs et les délais, et à comprendre les trois sémantiques de livraison : au plus une fois, au moins une fois, exactement une fois (et pourquoi elle est une illusion).
🎯 Ta mission
À la fin, je serai capable de :
- comparer les styles de communication : appel synchrone (RPC/REST), messages asynchrones
- implémenter un RPC avec cadrage par longueur, sérialisation JSON, erreurs et délais d'attente
- expliquer les sémantiques au plus une fois / au moins une fois / exactement une fois
- reconnaître les trois issues d'un appel distant (succès, échec, inconnu)
- faire évoluer un contrat de message de façon compatible
🧩 Défi d'échauffement (5 XP)
Tu envoies une lettre recommandée pour demander un remboursement. Aucun accusé de réception ne revient après trois semaines. Tu hésites : renvoyer la demande (risque d'être remboursé deux fois) ou attendre (risque de ne jamais être remboursé) ? Que ferais-tu pour pouvoir renvoyer sans danger ?
💡 Le concept
Les façons de communiquer
| Style | Principe | Avantages | Inconvénients |
|---|---|---|---|
| Appel synchrone (RPC, REST, gRPC) | l'appelant attend la réponse | simple à raisonner, résultat immédiat | couplage temporel, panne en cascade, latences cumulées |
| Messages asynchrones (files, publication/abonnement) | l'émetteur dépose un message et continue | découplage, tampon face aux pics | plus complexe, cohérence finale |
| Flux d'événements | un journal ordonné que plusieurs consommateurs lisent | rejouable, découplé | conception d'événements, ordre |
Règle utile : synchrone quand l'appelant a besoin du résultat pour continuer ; asynchrone quand on peut décoller du temps.
Un appel à distance n'est pas un appel local
| Appel local | Appel distant |
|---|---|
| Rapide (ns) | lent (ms) |
| Fiable | peut échouer de plusieurs façons |
| Mêmes types en mémoire | sérialisation, versions différentes |
| Résultat certain | succès, échec ou inconnu |
Les composants d'un RPC
- Contrat (interface) : méthodes, types des paramètres et des résultats (IDL : Protocol Buffers, OpenAPI).
- Souche cliente (stub) : transforme l'appel local en message.
- Sérialisation : JSON, Protocol Buffers, MessagePack.
- Transport : TCP, HTTP/2.
- Squelette serveur : décode, appelle la vraie fonction, encode la réponse.
Le cadrage des messages sur TCP
TCP est un flux d'octets sans frontières de messages. Il faut donc un cadrage :
- préfixe de longueur : 4 octets indiquant la taille, puis le contenu ;
- délimiteur (ligne) ;
- HTTP (en-têtes + longueur).
Et lire correctement : recv(n) peut renvoyer moins de n octets ; il faut boucler jusqu'à avoir tout reçu.
Les trois issues d'un appel
sequenceDiagram
participant C as Client
participant S as Serveur
C->>S: debiter(40)
S->>S: exécute
S--xC: réponse perdue
Note over C: délai dépassé : succès ? échec ? INCONNU
Description du schéma : le client envoie une requête ; le serveur l'exécute ; la réponse est perdue ; le client atteint son délai d'attente sans savoir si la requête a été exécutée.
Sémantiques de livraison
| Sémantique | Comportement | Comment | Risque |
|---|---|---|---|
| Au plus une fois (at-most-once) | exécutée 0 ou 1 fois | pas de relance | action perdue |
| Au moins une fois (at-least-once) | exécutée 1 ou plusieurs fois | relancer jusqu'à réponse | doublons |
| Exactement une fois (exactly-once) | exécutée 1 fois | ? | impossible à garantir au niveau du transport |
Exactement une fois n'existe pas comme garantie de réseau. On l'obtient comme effet : au moins une fois (relances) + idempotence (le doublon est sans effet) — mission 4.
Délais et échéances
Un appel doit toujours avoir un délai maximal. Mieux : une échéance (deadline) absolue transmise d'appel en appel (mission 3), pour que chaque maillon sache combien de temps il reste.
Gestion des erreurs
Distinguer :
- erreurs métier (« solde insuffisant ») : définitives, ne pas relancer ;
- erreurs transitoires (indisponible, délai) : on peut relancer, si l'opération est idempotente ;
- erreurs de protocole (message mal formé).
Évolution des contrats
Les clients et serveurs sont déployés à des moments différents : le contrat doit évoluer de façon compatible (cf. HEF-110, mission 5) :
- ajouter un champ optionnel : compatible ;
- supprimer ou renommer un champ : cassant ;
- ignorer les champs inconnus à la lecture ;
- numéroter les versions des champs (Protocol Buffers).
🧠 Astuce : pour chaque appel distant, écris trois lignes : que se passe-t-il si ça échoue ? si ça expire ? si ça s'exécute deux fois ? Si tu ne peux pas répondre aux trois, l'appel n'est pas prêt.
🔍 Exemple pas à pas
Problème : construire un mini-RPC de bout en bout sur sockets locales (cadrage par longueur, JSON, erreurs, délai d'attente), puis rejouer la perte de réponse pour voir l'exécution en double.
import json, socket, struct, threading, time
# ---------------- cadrage : 4 octets de longueur + JSON ----------------
def envoyer(sock, objet):
corps = json.dumps(objet).encode()
sock.sendall(struct.pack(">I", len(corps)) + corps)
def lire_exactement(sock, n):
tampon = b""
while len(tampon) < n:
morceau = sock.recv(n - len(tampon)) # recv peut renvoyer moins que demandé !
if not morceau:
raise ConnectionError("connexion fermée")
tampon += morceau
return tampon
def recevoir(sock):
(taille,) = struct.unpack(">I", lire_exactement(sock, 4))
return json.loads(lire_exactement(sock, taille))
# ---------------- serveur ----------------
class Serveur:
def __init__(self, methodes, perdre_premiere_reponse_de=None):
self.methodes, self.appels, self.perdre = methodes, [], perdre_premiere_reponse_de
self.deja_perdu = False
self.sock = socket.socket(); self.sock.bind(("127.0.0.1", )); .sock.listen()
.port = .sock.getsockname()[]
threading.Thread(target=._boucle, daemon=).start()
():
:
: conn, _ = .sock.accept()
OSError:
threading.Thread(target=._servir, args=(conn,), daemon=).start()
():
conn:
:
: requete = recevoir(conn)
(ConnectionError, struct.error, OSError):
:
resultat = .methodes[requete[]](**requete[])
reponse = {: requete[], : resultat}
KeyError e:
reponse = {: requete[], : {: , : (e)}}
Exception e:
reponse = {: requete[], : {: (e).__name__, : (e)}}
.appels.append(requete[])
.perdre == requete[] .deja_perdu:
.deja_perdu = ; conn.close();
envoyer(conn, reponse)
(): .sock.close()
():
():
:
():
.port, .delai, .compteur = port, delai,
():
.compteur +=
:
socket.create_connection((, .port), timeout=.delai) s:
s.settimeout(.delai)
envoyer(s, {: .compteur, : methode, : params})
r = recevoir(s)
(socket.timeout, TimeoutError):
DelaiDepasse()
ConnectionError:
DelaiDepasse()
r:
ErreurDistante()
r[]
():
nom.startswith(): AttributeError(nom)
**params: .appeler(nom, **params)
SOLDES = {: }
():
SOLDES[membre] < montant: ValueError()
SOLDES[membre] -= montant; SOLDES[membre]
(): time.sleep();
srv = Serveur({: a, b: a + b, : debiter, : lent})
cli = Client(srv.port, delai=)
cli.addition(a=, b=) ==
: cli.debiter(membre=, montant=); AssertionError
ErreurDistante e: (, e)
: cli.inconnue(); AssertionError
ErreurDistante e: (, e)
: cli.lent(); AssertionError
DelaiDepasse e: (, e)
srv.fermer()
SOLDES[] =
srv = Serveur({: debiter}, perdre_premiere_reponse_de=)
cli = Client(srv.port, delai=)
:
cli.debiter(membre=, montant=)
DelaiDepasse e:
(, e)
solde = cli.debiter(membre=, montant=)
()
SOLDES[] == srv.appels.count() ==
srv.fermer()
Lecture :
- Le cadrage par longueur et la boucle
lire_exactementrendent le protocole robuste aux lectures partielles de TCP. - Les erreurs sont typées : une erreur métier (« solde insuffisant ») est définitive ; une méthode inconnue est une erreur de protocole ; un délai dépassé donne un résultat inconnu (le serveur continue de travailler).
- La perte de réponse reproduit l'incident de HashBox : le serveur a exécuté
debiter, mais le client ne le sait pas ; sa relance (sémantique au moins une fois) débite deux fois. Le solde passe de 100 à 20 au lieu de 60. - Remède : rendre l'opération idempotente (mission 4).
✍️ À toi, avec aide (10 XP)
Un client lit des messages de ce flux d'octets TCP où les messages sont cadrés par un préfixe de longueur de 4 octets, mais les données arrivent par morceaux de tailles quelconques :
Écris un décodeur incrémental Decodeur avec une méthode alimenter(octets) qui renvoie la liste des messages complets disponibles (et conserve le reste). Teste en découpant un flux de 3 messages en morceaux de 1, 3, 7, puis 50 octets, dans cet ordre, et vérifie que tu retrouves exactement les 3 messages.
💡 Indice 1
Garde un tampon bytearray entre les appels.
💡 Indice 2
Boucle : si le tampon contient ≥ 4 octets et au moins 4 + taille octets, extrais un message.
💡 Indice 3
Utilise struct.unpack('>I', tampon[:4]).
✅ Réponse
import json, struct
class Decodeur:
def __init__(self): self.tampon = bytearray()
def alimenter(self, octets):
self.tampon += octets
messages = []
while len(self.tampon) >= 4:
(taille,) = struct.unpack(">I", self.tampon[:4])
if len(self.tampon) < 4 + taille: break
messages.append(json.loads(bytes(self.tampon[4:4 + taille])))
del self.tampon[:4 + taille]
return messages
def encoder(objet):
corps = json.dumps(objet).encode(); return struct.pack(">I", len(corps)) + corps
MSGS = [{"n": 1}, {"n": 2, "texte": "bonjour ça va ?"}, {: , : (())}]
flux = .join(encoder(m) m MSGS)
d, recus, i = Decodeur(), [],
taille (, , , , ):
recus += d.alimenter(flux[i:i + taille]); i += taille
(recus)
recus == MSGS d.tampon
🚀 À toi, en solo (20 XP)
Contrat évolutif. Écris un petit sérialiseur/désérialiseur de messages versionnés :
- un schéma décrit des champs numérotés avec type et caractère obligatoire/optionnel (
{1: ("membre", str, True), 2: ("montant", int, True)}) ; encoder(schema, message)produit un dictionnaire{numero: valeur}(comme Protocol Buffers : le numéro, pas le nom, circule) ;decoder(schema, donnees): ignore les champs inconnus, applique des valeurs par défaut pour les champs optionnels absents, et lève une erreur claire pour un champ obligatoire absent ou mal typé ;- teste l'évolution : un serveur en version 2 (qui ajoute un champ optionnel
devise) lit les messages d'un client version 1 ; un client version 1 lit les messages d'un serveur version 2 (champ inconnu ignoré) ; - montre un changement cassant : retirer un champ obligatoire, ou changer son type.
✅ Pistes de correction
class ErreurContrat(Exception): pass
def encoder(schema, message):
donnees = {}
for numero, (nom, type_, obligatoire) in schema.items():
if nom in message:
if not isinstance(message[nom], type_): raise ErreurContrat(f"{nom} : type {type(message[nom]).__name__} au lieu de {type_.__name__}")
donnees[numero] = message[nom]
elif obligatoire:
raise ErreurContrat(f"champ obligatoire absent : {nom}")
return donnees
def decoder(schema, donnees, defauts=None):
defauts, resultat = defauts or {}, {}
for numero, (nom, type_, obligatoire) in schema.items():
if numero in donnees:
if not isinstance(donnees[numero], type_): raise ErreurContrat(f"{nom} : mauvais type")
resultat[nom] = donnees[numero]
elif obligatoire:
ErreurContrat()
nom defauts:
resultat[nom] = defauts[nom]
resultat
V1 = {: (, , ), : (, , )}
V2 = {**V1, : (, , )}
msg_v1 = encoder(V1, {: , : })
msg_v2 = encoder(V2, {: , : , : })
decoder(V2, msg_v1, defauts={: }) == {: , : , : }
decoder(V1, msg_v2) == {: , : }
V3_retire = {: (, , )}
V3_type = {: (, , ), : (, , )}
: decoder({**V1, : (, , )}, msg_v1); AssertionError
ErreurContrat e: (, e)
: decoder(V3_type, msg_v1); AssertionError
ErreurContrat e: (, e)
decoder(V3_retire, msg_v1) == {: }
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Relancer un appel non idempotent après un délai | Doublons (débits, envois, créations) | Idempotence (mission 4) ; relances seulement si sûres |
| Appel sans délai d'attente | Un appelant bloqué indéfiniment | Échéance explicite sur chaque appel |
| Lire TCP comme s'il envoyait des messages | Messages tronqués ou collés | Cadrage et lecture complète |
| Contrat modifié de façon cassante | Clients anciens cassés pendant les déploiements | Champs optionnels, numéros stables, ignorer l'inconnu |
🐉 Mini-boss (40 XP)
Mini-framework RPC de HashBox. Construis minirpc.py :
- cadrage par longueur, JSON, boucle de réception robuste ;
- serveur multi-clients avec registre de méthodes, erreurs typées (métier, protocole, interne) ;
- client avec souche dynamique, délai et échéance transmise dans la requête (le serveur ne démarre pas un travail dont l'échéance est dépassée) ;
- identifiant de requête et déduplication côté serveur (cache des réponses pour les
iddéjà traités), pour obtenir « au plus une fois » apparent sur relance ; - injection de pannes (perte de réponse, délai, coupure de connexion) avec un
Chaosconfigurable ; - 12 tests : succès, erreurs, délai, échéance, relance sans déduplication (double effet) et avec déduplication (effet unique), contrat compatible.
✅ Pistes de correction
Un bon travail : structures Requete(id, methode, params, echeance), Reponse(id, ok|erreur), cache des réponses {id_client: {id: reponse}} borné; un test central montre qu'avec une perte de réponse, le client qui relance avec le même identifiant obtient la réponse mémorisée sans ré-exécution. La conclusion attendue : le transport ne peut garantir « exactement une fois » ; c'est la combinaison identifiant stable + déduplication qui produit un effet unique.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un délai dépassé sur un appel distant laisse le résultat :
- A. forcément échoué
- B. forcément réussi
- C. inconnu : l'action a pu avoir lieu ou non
2. « Exactement une fois » s'obtient en pratique par :
- A. au moins une fois (relances) + idempotence
- B. une garantie du réseau
- C. un délai plus long
3. Sur TCP, pour recevoir un message complet, il faut :
- A. lire une seule fois
- B. lire en boucle jusqu'à avoir tous les octets annoncés
- C. fermer la connexion
4. 🔁 Révision mission 01 : a → b (a s'est produit avant b) signifie :
- A. que l'horloge physique de a est plus petite
- B. que a et b sont sur la même machine
- C. que a peut avoir influencé causalement b
5. 🔁 Révision mission 01 : Deux événements aux horloges vectorielles [2,0] et [0,1] sont :
- A. concurrents
- B. l'un avant l'autre
- C. identiques
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quel appel distant de ton système n'est pas sûr à rejouer, et que fais-tu aujourd'hui en cas de délai dépassé ?
- Quel contrat de ton système est modifié sans que ses consommateurs soient prévenus ?
🎒 À retenir
- Un appel distant a trois issues : succès, échec, inconnu.
- Cadrage par longueur et lecture complète sur TCP.
- Au plus une fois, au moins une fois, exactement une fois = relances + idempotence.
- Échéances explicites ; erreurs métier, transitoires, de protocole.
- Contrats évolutifs : ajouter en optionnel, ne jamais réutiliser un numéro.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Messager fiable
← Mission 01 — Modèles et contraintes distribuées · Mission 03 — Latence, timeout et retry →
HEF-140 — Systèmes distribués

