La bonne architecture n'est pas la plus élégante : c'est celle qui permet d'apprendre vite aujourd'hui sans interdire de grandir demain.
⏱️ Durée : environ 105 minutes · 🎓 Niveau : avancé · 🏅 Badge : Architecte pragmatique
🎬 L'histoire
Dès le premier jour de l'espace formateurs, un ingénieur propose une architecture en quatorze microservices, un bus d'événements, trois bases de données différentes et un orchestrateur. « C'est ce qu'il faudra quand on aura un million d'utilisateurs. » Aujourd'hui, HashBox en a quarante pour ce produit, et l'équipe compte quatre personnes. Pendant que l'on installe l'infrastructure, personne ne parle à un formateur.
« Une architecture se juge par rapport à ce que le produit doit faire maintenant et à ce qu'il a une chance raisonnable de devenir, dit Sam. Elle doit rendre les décisions faciles à changer, surtout celles dont on sait qu'on se trompera. Et elle ne doit pas compliquer l'apprentissage. »
Tu apprends à partir des attributs de qualité demandés par le produit, à comparer des options avec une matrice pondérée robuste, à décider entre construire et acheter, à choisir entre monolithe modulaire et microservices, à vérifier automatiquement des règles d'architecture, et à distinguer décisions réversibles et irréversibles.
🎯 Ta mission
À la fin, je serai capable de :
- dériver les attributs de qualité d'une architecture des besoins du produit
- comparer des options avec une matrice pondérée et tester sa robustesse aux poids
- comparer construire et acheter sur un horizon de coût total de possession
- comprendre monolithe modulaire, microservices et squelette ambulant, et leur coût
- écrire des « fonctions d'aptitude » qui vérifient automatiquement des règles d'architecture
🧩 Défi d'échauffement (5 XP)
Tu construis une maison pour une famille qui ne sait pas encore si elle aura un enfant, deux, ou aucun. Veux-tu faire dès maintenant cinq chambres et un sous-sol aménagé, ou une maison simple avec des murs porteurs bien placés qui permettent d'agrandir ? Qu'est-ce qui est facile à changer plus tard (peinture, mobilier), et qu'est-ce qui est très difficile (fondations, plan) ? Applique la distinction à un logiciel.
💡 Le concept
L'architecture au service du produit
L'architecture est l'ensemble des décisions difficiles à changer : structure en composants, choix des technologies principales, frontières de données, modes de déploiement. Elle découle de trois entrées :
| Entrée | Exemples pour HashBox |
|---|---|
| Besoins fonctionnels | publier un cours, s'inscrire, payer |
| Attributs de qualité | disponibilité, sécurité, performance, évolutivité, coût, facilité de changement |
| Contraintes | équipe de 4, six semaines, budget, conformité (RGPD), compétences |
Les attributs de qualité, hiérarchisés
On ne peut pas tout maximiser. Un arbre d'utilité relie chaque qualité à des scénarios précis et chiffrés :
| Qualité | Scénario | Importance | Difficulté |
|---|---|---|---|
| Disponibilité | « le site répond à 99,5 % des requêtes sur 30 jours » | Élevée | Moyenne |
| Changeabilité | « ajouter un moyen de paiement en moins de 3 jours » | Élevée | Élevée |
| Performance | « page d'un cours en moins de 800 ms (p95) » | Moyenne | Faible |
| Coût | « moins de 0,05 € d'infrastructure par membre actif et par mois » | Moyenne | Moyenne |
Les qualités importantes et difficiles guident l'architecture. Pour un MVP, la changeabilité (apprendre vite) l'emporte presque toujours sur l'évolutivité extrême.
Comparer des options : la matrice pondérée
- lister les critères (attributs de qualité, coût, risque) ;
- attribuer un poids à chacun ;
- noter chaque option sur chaque critère ;
- calculer le score pondéré.
Piège : les poids sont des opinions. On teste la robustesse : si l'on fait varier les poids de ±30 %, le gagnant change-t-il ? Une décision stable face aux variations est solide ; une décision qui bascule demande plus d'information.
Construire ou acheter
| Construire | Acheter / réutiliser |
|---|---|
| contrôle total, différenciation | rapidité, maintenance par un tiers |
| coût initial élevé + maintenance | licence (par utilisateur ou forfait), dépendance |
| nécessaire pour ce qui est différenciant | judicieux pour ce qui est banal (paiement, authentification, e-mail) |
Comparer le coût total de possession (TCO) sur 3 ans : construire = développement + exploitation + maintenance ; acheter = licences (croissantes avec les utilisateurs) + intégration + dépendance (coût de sortie).
Monolithe modulaire ou microservices ?
| Monolithe modulaire | Microservices | |
|---|---|---|
| Déploiement | un seul artefact | un par service |
| Frontières | modules dans un code unique, règles de dépendance | réseau |
| Avantages | simple, rapide à changer, une transaction | équipes autonomes, mise à l'échelle indépendante |
| Coûts | discipline nécessaire | toute la complexité distribuée (HEF-140) : réseau, pannes, cohérence, observabilité |
| Quand | équipe petite, produit en découverte | grandes organisations, domaines stabilisés |
Loi de Conway : l'architecture reflète l'organisation. Règle utile : commencer par un monolithe bien découpé en modules, extraire un service seulement quand une raison précise le justifie (échelle différente, équipe distincte, contrainte de sécurité).
Le squelette ambulant
Une implémentation minimale mais de bout en bout qui traverse toutes les couches (interface, logique, stockage, déploiement, observation) : elle valide l'architecture tôt et permet de livrer dès la première semaine.
Décisions réversibles et irréversibles
| Type | Définition | Attitude |
|---|---|---|
| Porte à deux sens | réversible à faible coût (choix d'une bibliothèque derrière une interface) | décider vite |
| Porte à sens unique | coûteuse à défaire (modèle de données, format public d'API, fournisseur de cloud) | décider avec soin, documenter |
Stratégie : transformer les décisions irréversibles en réversibles — interfaces, couches d'isolation, migrations progressives.
Fonctions d'aptitude (architecture évolutive)
Une fonction d'aptitude (fitness function) est un test automatique d'une propriété d'architecture :
| Propriété | Fonction d'aptitude |
|---|---|
| Frontières de modules | un module domaine ne peut pas importer infrastructure |
| Pas de cycles | le graphe de dépendances est acyclique |
| Taille | aucune fonction de plus de 60 lignes |
| Performance | temps de réponse p95 < budget en CI |
| Sécurité | aucune dépendance avec faille critique |
Elles s'exécutent en intégration continue : l'architecture ne se dégrade pas sans qu'on le voie.
Coût par utilisateur
Un produit doit être viable : coût d'infrastructure par utilisateur actif doit rester inférieur à revenu par utilisateur. Un modèle simple : coût fixe (environnement, supervision) + coût variable par utilisateur. Les microservices augmentent le coût fixe (chaque service a son environnement, sa supervision).
🧠 Astuce : écris l'architecture comme des décisions (ADR) avec leurs alternatives écartées et les signaux qui te feraient la revoir (« si nous dépassons 50 000 membres actifs, extraire le service de paiement »).
🔍 Exemple pas à pas
Problème : comparer trois architectures par une matrice pondérée avec test de robustesse (simulation des poids), chiffrer construire contre acheter, appliquer des fonctions d'aptitude (dépendances interdites, cycles), et modéliser le coût par utilisateur d'un monolithe modulaire et de microservices.
import ast, random
# ---------------- 1. matrice pondérée et robustesse aux poids ----------------
CRITERES = ["changeabilité", "coût de démarrage", "disponibilité", "évolutivité", "simplicité d'exploitation"]
POIDS = {"changeabilité": 0.30, "coût de démarrage": 0.20, "disponibilité": 0.15, "évolutivité": 0.10, "simplicité d'exploitation": 0.25} # produit en découverte, équipe de 4
OPTIONS = { # notes de 1 à 5
"monolithe modulaire": {"changeabilité": 5, "coût de démarrage": 5, "disponibilité": 3, "évolutivité": 3, "simplicité d'exploitation": 5},
"microservices": {"changeabilité": 3, "coût de démarrage": 1, "disponibilité": 4, "évolutivité": 5, "simplicité d'exploitation": 1},
"tout fournisseur (plateforme sans serveur)": {"changeabilité": 4, "coût de démarrage": 4, "disponibilité": , : , : },
}
(): (poids[c] * OPTIONS[option][c] c CRITERES)
o OPTIONS: ()
gagnant = (OPTIONS, key= o: score(o, POIDS)); (, gagnant)
():
rng, victoires = random.Random(graine), {o: o OPTIONS}
_ (essais):
w = {c: POIDS[c] * rng.uniform( - bruit, + bruit) c CRITERES}
total = (w.values()); w = {c: v / total c, v w.items()}
victoires[(OPTIONS, key= o: score(o, w))] +=
{o: v / essais o, v victoires.items()}
r = robustesse()
(, {o.split()[]: o, v r.items()})
r[] < < (r.values()) <
():
dev + mois * (maintenance_mensuelle + hebergement_mensuel)
():
total = integration
m (, mois + ):
total += forfait + par_utilisateur * utilisateurs(m)
total
croissance = m: * ** m
()
point_de_bascule =
mois (, , , , , ):
c, a = tco_construire(mois), tco_acheter(mois, croissance)
()
a > c point_de_bascule : point_de_bascule = mois
bascule = (m m (, ) tco_acheter(m, croissance) > tco_construire(m))
(, bascule)
tco_acheter(, croissance) < tco_construire() <= bascule <=
MODULES = {
: ,
: ,
: ,
: ,
: ,
}
():
graphe = {}
nom, code sources.items():
deps = ()
noeud ast.walk(ast.parse(code)):
(noeud, ast.Import): deps |= {a.name a noeud.names}
(noeud, ast.ImportFrom) noeud.module: deps.add(noeud.module)
graphe[nom] = {d d deps d sources}
graphe
():
g, violations = dependances(sources), []
nom, deps g.items():
d deps:
source, cible interdits:
nom.startswith(source) d.startswith(cible): violations.append()
etat = {}
():
etat[n] =
d g[n]:
etat.get(d) == : violations.append( + .join(chemin + [n, d]))
d etat: visiter(d, chemin + [n])
etat[n] =
n g:
n etat: visiter(n, [])
violations
v verifier(MODULES, [(, ), (, )]): (, v)
(verifier(MODULES, [(, ), (, )])) ==
verifier({: , : , : }, [(, )]) == []
():
socle + services * fixe_par_service + variable_par_1000 * utilisateurs /
()
u (, , , ):
m, s = cout_mensuel(u, ), cout_mensuel(u, )
()
cout_mensuel(, ) / > * cout_mensuel(, ) / cout_mensuel(, ) / cout_mensuel(, ) <
Lecture :
- La matrice pondérée place le monolithe modulaire en tête avec les poids d'un produit en découverte. Le test de robustesse montre que ce choix n'est pas absolument stable (la plateforme sans serveur gagne dans une partie des tirages) alors que les microservices ne gagnent presque jamais : l'information utile est la marge, pas le score.
- Construire ou acheter : l'achat est moins cher pendant les deux premières années et demie (peu de membres), puis la licence croît avec les utilisateurs et dépasse le coût de construction vers le mois 32 : le choix dépend de l'horizon et de la croissance, et une stratégie de sortie s'impose.
- Les fonctions d'aptitude détectent une dépendance interdite (le domaine qui importe l'infrastructure) automatiquement dans l'intégration continue.
- Pour 500 membres, 12 microservices coûtent plus de sept fois plus par membre qu'un monolithe ; à 500 000 membres, l'écart n'est plus que d'environ 40 % : la complexité distribuée se justifie quand l'échelle ou les équipes l'exigent.
✍️ À toi, avec aide (10 XP)
Une équipe hésite entre construire un système de notifications (développement : 40 000 €, maintenance : 1 500 €/mois, hébergement : 200 €/mois) et acheter un service (intégration : 5 000 €, 300 €/mois de forfait + 0,02 € par notification ; 200 000 notifications par mois au départ, +5 % par mois).
- Calcule le coût cumulé des deux options à 12, 24, 36 et 48 mois.
- À partir de quel mois construire devient-il moins cher ?
- Que se passe-t-il si la croissance est de +10 % par mois ? De 0 % ?
- Quel facteur non chiffré ici ferait pencher la décision vers acheter ou construire ?
💡 Indice 1
Cumule mois par mois dans une boucle.
💡 Indice 2
Le coût variable de l'achat croît avec le volume.
💡 Indice 3
Pense à la dépendance, au coût de sortie, à la différenciation.
✅ Réponse
def construire(mois): return 40000 + mois * (1500 + 200)
def acheter(mois, croissance):
total, volume = 5000, 200000
for m in range(mois):
total += 300 + 0.02 * volume; volume *= 1 + croissance
return total
for c in (0.05, 0.10, 0.0):
bascule = next(m for m in range(1, 400) if construire(m) < acheter(m, c))
print(f"croissance {c:4.0%} : construire devient moins cher au mois {bascule}")
for m in (12, 24, 36, 48): print(f"{m} mois : construire {construire(m):8.0f} | acheter {acheter(m, 0.05):f}")
construire() < acheter(, ) < acheter(, )
🚀 À toi, en solo (20 XP)
Vérificateur d'architecture modulaire. Pour un monolithe modulaire représenté par un dictionnaire chemin_module → code source :
- chaque module expose une API publique (liste
__all__) ; les autres modules ne peuvent importer que des noms de cet__all__(from billing import chargeautorisé sichargeest dansbilling.__all__) ; - règles de couches :
web → application → domaine,infrastructure → domaine; toute autre dépendance est interdite ; - détecte : import d'un nom privé, dépendance de couche interdite, cycle entre modules, module sans
__all__; - calcule des métriques de couplage par module : couplage afférent (qui dépend de moi), efférent (de qui je dépends), instabilité I = Ce / (Ca + Ce) ;
- teste sur un projet d'exemple de 7 modules avec 4 violations injectées ; vérifie que chaque violation est détectée et qu'un projet propre ne produit aucune alerte.
✅ Pistes de correction
import ast
COUCHES = {"web": 0, "application": 1, "domaine": 2, "infrastructure": 1}
AUTORISE = {("web", "application"), ("application", "domaine"), ("infrastructure", "domaine"), ("web", "domaine")}
def analyse(sources):
exports, graphe, noms_importes, alertes = {}, {m: set() for m in sources}, [], []
for module, code in sources.items():
arbre = ast.parse(code); tout = None
for n in arbre.body:
if isinstance(n, ast.Assign) and any(getattr(t, "id", "") == "__all__" for t in n.targets): tout = {e.value for e in n.value.elts}
if tout is None: alertes.append(f"{module} : pas d'API publique (__all__)"); tout = set()
exports[module] = tout
n ast.walk(arbre):
(n, ast.ImportFrom) n.module sources:
graphe[module].add(n.module); noms_importes += [(module, n.module, a.name) a n.names]
(n, ast.Import):
a n.names:
a.name sources: graphe[module].add(a.name)
src, cible, nom noms_importes:
nom exports[cible]: alertes.append()
src, deps graphe.items():
d deps:
couche_src, couche_d = src.split()[], d.split()[]
couche_src != couche_d (couche_src, couche_d) AUTORISE: alertes.append()
etat = {}
():
etat[n] =
d graphe[n]:
etat.get(d) == : alertes.append( + .join(chemin + [n, d]))
d etat: visiter(d, chemin + [n])
etat[n] =
n graphe:
n etat: visiter(n, [])
ca = {m: ( d graphe.values() m d) m graphe}
ce = {m: (graphe[m]) m graphe}
instabilite = {m: (ce[m] / (ca[m] + ce[m]) ca[m] + ce[m] ) m graphe}
alertes, instabilite
PROPRE = {
: ,
: ,
: ,
: ,
}
alertes, inst = analyse(PROPRE)
(, alertes , , {m: (i, ) m, i inst.items()})
alertes == [] inst[] ==
SALE = (PROPRE)
SALE[] =
SALE[] =
SALE[] =
alertes, _ = analyse(SALE)
a alertes: (, a)
( a a alertes) ( a a alertes) ( a a alertes) ( a a alertes)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Concevoir pour un million d'utilisateurs avec quarante | Complexité et coût prématurés, apprentissage retardé | Monolithe modulaire, squelette ambulant, signaux de revue |
| Choisir une technologie par mode | Décision irréversible non justifiée | Critères, matrice robuste, ADR avec alternatives |
| Matrice pondérée avec des poids intouchables | Fausse précision | Tester la robustesse aux poids |
| Règles d'architecture seulement écrites | Elles s'érodent | Fonctions d'aptitude en intégration continue |
🐉 Mini-boss (40 XP)
Dossier d'architecture du MVP HashBox « espace formateurs ».
- arbre d'utilité : 6 scénarios de qualité chiffrés avec importance et difficulté ; identifie les 2 qui guident l'architecture ;
- matrice pondérée de 3 options (monolithe modulaire, microservices, plateforme gérée) avec test de robustesse (5000 tirages) ; conclusion argumentée ;
- analyse construire / acheter pour deux composants (paiement, recherche) avec TCO sur 36 mois et sensibilité à la croissance ;
- définition du squelette ambulant (5 composants minimaux) et plan de livraison en 2 semaines ;
- au moins 5 fonctions d'aptitude exécutables (frontières, cycles, taille de fonction, présence de tests, dépendances interdites) appliquées à un petit projet de ton choix ;
- classification des 8 décisions principales en portes à deux sens / à sens unique, avec pour chacune du sens unique une façon de la rendre réversible ;
- 3 ADR avec alternatives écartées et signaux de revue chiffrés (« si X dépasse Y, extraire Z »).
✅ Pistes de correction
Un bon dossier : scénarios de qualité mesurables, matrice robuste (gagnant et probabilité), TCO avec courbes et bascule, squelette ambulant crédible, fonctions d'aptitude qui échouent quand on viole une règle, tableau de réversibilité (le format public de l'API et le modèle de données sont à sens unique : on les protège par des versions et des migrations progressives), ADR avec signaux de revue précis (par exemple « extraire la facturation en service si l'équipe dépasse 8 personnes ou si le trafic de facturation dépasse 10 % de la CPU »).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pour un produit en découverte avec une petite équipe, l'architecture recommandée est généralement :
- A. quatorze microservices dès le premier jour
- B. un monolithe modulaire, avec possibilité d'extraire des services plus tard
- C. aucune structure
2. Une fonction d'aptitude (fitness function) est :
- A. une métrique de performance du processeur
- B. un algorithme génétique
- C. un test automatique d'une propriété d'architecture
3. Une décision « à sens unique » est une décision :
- A. coûteuse à défaire, à prendre avec soin
- B. qu'on peut changer en cinq minutes
- C. prise par une seule personne
4. 🔁 Révision mission 05 : Un test d'utilisabilité avec 5 personnes sert surtout à :
- A. mesurer précisément un taux de réussite
- B. découvrir des problèmes d'utilisabilité majeurs
- C. remplacer les données d'usage
5. 🔁 Révision mission 05 : Le rapport de contraste minimal AA pour un texte normal est :
- A. 2:1
- B. 10:1
- C. 4,5:1
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quelle décision d'architecture de ton produit serait très coûteuse à défaire, et l'as-tu documentée ?
- Quelle complexité de ton système répond à un problème d'échelle que tu n'as pas encore ?
🎒 À retenir
- Architecture = décisions difficiles à changer, guidées par les qualités importantes et difficiles.
- Matrice pondérée + test de robustesse aux poids.
- Construire le différenciant, acheter le banal ; TCO sur l'horizon.
- Monolithe modulaire d'abord ; microservices quand une raison précise l'exige.
- Fonctions d'aptitude en CI ; décisions à deux sens rapides, à sens unique soignées.
flowchart LR
T(["Architecture orientée produit"])
T --> R1["1. Architecture = décisions difficiles à changer, guidées par les…"]
T --> R2["2. Matrice pondérée + test de robustesse aux poids."]
T --> R3["3. Construire le différenciant, acheter le banal ; TCO sur l'horizon."]
T --> R4["4. Monolithe modulaire d'abord ; microservices quand une raison précise…"]
T --> R5["5. Fonctions d'aptitude en CI ; décisions à deux sens rapides, à sens…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Architecte pragmatique
← Mission 05 — UX et parcours · Mission 07 — Priorisation et roadmap →
HEF-150 — Ingénierie produit

