« Ça marche chez moi » est un symptôme : la machine du développeur et celle de production ne construisent pas la même chose.
⏱️ Durée : environ 95 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Constructeur déterministe
🎬 L'histoire
Un jeudi, HashBox reconstruit une ancienne version pour corriger un bug urgent. Le résultat n'a rien à voir avec celui d'il y a six mois : une dépendance a été mise à jour automatiquement, et le programme plante au démarrage. Personne ne sait quelle version exacte de chaque bibliothèque avait été utilisée.
« Un build doit être comme une recette précise, dit Sam : mêmes ingrédients, mêmes quantités, même four. Si le résultat change d'une fois sur l'autre sans que la recette change, c'est que la recette est incomplète. »
Tu apprends à rendre un build déterministe : versions figées, empreintes vérifiées, artefacts identiques bit à bit, caches fiables.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer pourquoi un build doit être reproductible
- figer les dépendances avec un fichier de verrouillage et des empreintes
- produire deux fois un artefact identique (déterminisme)
- construire un cache fondé sur le contenu et un build incrémental
- produire un inventaire des composants (SBOM) d'un artefact
🧩 Défi d'échauffement (5 XP)
Une pâtisserie vend des gâteaux. La recette dit « un peu de farine, du beurre, cuire jusqu'à ce que ce soit prêt ». Chaque cuisinier fait un gâteau différent. Écris ce qu'il faudrait préciser pour que deux cuisiniers obtiennent le même gâteau à chaque fois. Qu'est-ce qui, dans un logiciel, joue le rôle de la « farine » et du « four » ?
💡 Le concept
Qu'est-ce qu'un build reproductible ?
Un build est reproductible si, à partir des mêmes sources et de la même configuration, on obtient le même artefact, quel que soit le jour, la machine ou la personne.
| Avantage | Pourquoi |
|---|---|
| Fiabilité | ce qu'on teste est ce qu'on déploie |
| Diagnostic | « chez moi ça marche » disparaît |
| Sécurité | on peut vérifier qu'un binaire correspond bien aux sources (chaîne d'approvisionnement) |
| Retour arrière | on peut reconstruire exactement une ancienne version |
| Cache | même entrée → même sortie → on peut réutiliser |
Les sources de non-déterminisme
| Source | Exemple | Remède |
|---|---|---|
| Dépendances flottantes | requests>=2 | versions exactes + verrouillage |
| Horodatages | date de build dans l'archive | date fixe (SOURCE_DATE_EPOCH) |
| Ordre des fichiers | ordre du système de fichiers | trier |
| Chemins absolus | /home/kodi/... incorporé | chemins relatifs, répertoires normalisés |
| Environnement | variables, locale, fuseau | environnement explicite |
| Aléatoire | identifiants générés | graine fixée, pas d'aléa dans le build |
Verrouillage et empreintes
- Fichier de dépendances : ce que tu demandes (
requests>=2,<3). - Fichier de verrouillage (lock file) : ce qui a été résolu, versions exactes et empreintes (hachés) de chaque paquet, y compris les dépendances transitives.
requests==2.32.3 --hash=sha256:...
urllib3==2.2.2 --hash=sha256:...
À l'installation, l'outil vérifie l'empreinte : un paquet altéré (ou remplacé par un homonyme malveillant) est refusé (pip install --require-hashes). Le verrouillage se commit dans le dépôt et se met à jour par un changement explicite et relu.
Le contenu comme clé : cache et build incrémental
Un cache adressé par le contenu : clé = haché de toutes les entrées de l'étape (sources, versions, options). Si la clé existe, on réutilise le résultat ; sinon on construit et on stocke. Un changement dans une entrée change la clé, donc invalide exactement ce qu'il faut.
clé(étape) = H( H(sources) + H(dépendances) + H(commande) + H(clés des étapes précédentes) )
C'est le principe des systèmes de build modernes (Bazel, Nix, Docker avec ses couches).
Les étapes d'un build
flowchart LR
S["Sources"] --> D["Résoudre les dépendances (verrouillées)"]
D --> C["Compiler / empaqueter"]
C --> T["Tester"]
T --> A["Artefact (versionné, haché)"]
A --> R["Registre d'artefacts"]
Description du schéma : cinq étapes en chaîne : les sources, la résolution des dépendances verrouillées, la compilation ou l'empaquetage, les tests, et la publication d'un artefact versionné et haché dans un registre.
Principe clé : construire une fois, déployer partout. L'artefact testé est exactement celui qui part en production (jamais reconstruit pour chaque environnement).
SBOM : inventaire des composants
Un SBOM (Software Bill of Materials) liste chaque composant d'un artefact (nom, version, empreinte, licence). Il sert à repérer rapidement les composants vulnérables (HEF-100, mission 8) quand une faille est annoncée.
Versionner les artefacts
Chaque artefact porte une version immuable (par exemple 1.4.2+build.57 ou le SHA du commit) et son haché. On ne remplace jamais un artefact publié.
🧠 Astuce : fais deux builds consécutifs et compare les empreintes. Si elles diffèrent, cherche la différence avec
diff: tu trouveras presque toujours un horodatage ou un ordre de fichiers.
🔍 Exemple pas à pas
Problème : montrer qu'un build qui incorpore la date n'est pas reproductible, le rendre déterministe, vérifier un fichier de verrouillage par empreintes, et produire un SBOM.
import hashlib, io, json, tempfile, time, zipfile
from pathlib import Path
def sha256(octets):
return hashlib.sha256(octets).hexdigest()
def creer_projet(dossier):
Path(dossier, "app").mkdir()
Path(dossier, "app", "main.py").write_text("print('HashBox')\n")
Path(dossier, "app", "outils.py").write_text("def double(x):\n return 2 * x\n")
Path(dossier, "LISEZMOI.txt").write_text("HashBox 1.0\n")
# ---------------- build NAÏF : horodatage et ordre du système de fichiers ----------------
def build_naif(dossier):
tampon = io.BytesIO()
with zipfile.ZipFile(tampon, "w") as z:
for chemin in Path(dossier).rglob("*"): # ordre non garanti
if chemin.is_file():
z.write(chemin, chemin.relative_to(dossier)) # incorpore la date de modification
z.writestr("BUILD_INFO", f"construit à {time.time()}") # horodatage dans l'artefact
return tampon.getvalue()
# ---------------- build REPRODUCTIBLE ----------------
DATE_FIXE = (2025, 1, 1, , , )
():
tampon = io.BytesIO()
zipfile.ZipFile(tampon, , zipfile.ZIP_DEFLATED) z:
chemin (p p Path(dossier).rglob() p.is_file()):
info = zipfile.ZipInfo((chemin.relative_to(dossier)), date_time=DATE_FIXE)
info.external_attr = <<
info.compress_type = zipfile.ZIP_DEFLATED
z.writestr(info, chemin.read_bytes())
info = zipfile.ZipInfo(, date_time=DATE_FIXE); info.external_attr = <<
z.writestr(info, version)
tampon.getvalue()
tempfile.TemporaryDirectory() d:
creer_projet(d)
a = sha256(build_naif(d)); time.sleep(); b = sha256(build_naif(d))
(, a[:], b[:], , a == b)
a != b
a = sha256(build_reproductible(d, )); time.sleep(); b = sha256(build_reproductible(d, ))
(, a[:], b[:], , a == b)
a == b
tempfile.TemporaryDirectory() d1, tempfile.TemporaryDirectory() d2:
creer_projet(d1); creer_projet(d2)
sha256(build_reproductible(d1, )) == sha256(build_reproductible(d2, ))
()
PAQUETS = {: , : }
LOCK = [{: , : , : , : sha256(PAQUETS[])},
{: , : , : , : sha256(PAQUETS[])}]
():
installes = []
entree lock:
contenu = telecharger(entree[])
sha256(contenu) != entree[]:
ValueError()
installes.append()
installes
installer(LOCK, PAQUETS.__getitem__) == [, ]
pirate = (PAQUETS, **{: })
:
installer(LOCK, pirate.__getitem__)
AssertionError()
ValueError e:
(, e)
():
{: sha256(artefact),
: [{: e[], : e[], : e[]} e (lock, key= e: e[])]}
tempfile.TemporaryDirectory() d:
creer_projet(d)
document = sbom(LOCK, build_reproductible(d, ))
(json.dumps(document, indent=)[:], )
(document[]) == (document[]) ==
Lecture :
- Le build naïf change à chaque exécution (horodatage, date de modification des fichiers) : impossible de comparer ou de vérifier.
- Le build reproductible fixe tout ce qui varie : ordre trié, dates et permissions figées, aucune donnée de l'heure. Deux builds, même dans des dossiers différents, donnent le même artefact bit à bit.
- Le verrouillage avec empreintes refuse un paquet altéré — la défense contre un remplacement malveillant dans la chaîne d'approvisionnement (voir HEF-100).
- Le SBOM relie l'artefact (son haché) à la liste exacte de ses composants.
✍️ À toi, avec aide (10 XP)
Écris verifier_lock(requirements, lock) qui contrôle la cohérence entre un fichier de dépendances et son verrouillage :
- chaque dépendance déclarée (
nom+ contrainte==,>=ou<) est présente dans le lock ; - la version verrouillée respecte la contrainte ;
- chaque entrée du lock a une empreinte (non vide) ;
- aucun paquet n'est verrouillé sans être déclaré ou dépendance transitive connue (liste fournie).
Renvoie une liste de problèmes. Teste avec un cas bon et trois mauvais.
💡 Indice 1
Représente les versions par des tuples d'entiers pour comparer.
💡 Indice 2
Une contrainte >=1.2 est respectée si (1,2,…) >= (1,2).
💡 Indice 3
Les paquets transitifs sont fournis dans un ensemble connus.
✅ Réponse
import re
def version(v):
return tuple(int(x) for x in v.split("."))
def respecte(v, contrainte):
m = re.fullmatch(r"(==|>=|<)(.+)", contrainte)
op, ref = m.group(1), version(m.group(2))
return {"==": version(v) == ref, ">=": version(v) >= ref, "<": version(v) < ref}[op]
def verifier_lock(requirements, lock, connus=frozenset()):
problemes = []
par_nom = {e["nom"]: e for e in lock}
for nom, contrainte in requirements.items():
if nom not in par_nom:
problemes.append(f"{nom} déclaré mais absent du lock"); continue
if not respecte(par_nom[nom]["version"], contrainte):
problemes.append(f"{nom} {par_nom[nom]['version']} ne respecte pas {contrainte}")
for e lock:
e.get():
problemes.append()
e[] requirements e[] connus:
problemes.append()
problemes
req = {: , : }
bon = [{: , : , : }, {: , : , : }, {: , : , : }]
verifier_lock(req, bon, connus={}) == []
verifier_lock(req, bon[:]) == []
verifier_lock(req, [(bon[], version=), bon[]]) == []
verifier_lock(req, [bon[], (bon[], sha256=)]) == []
verifier_lock(req, bon) == []
()
🚀 À toi, en solo (20 XP)
Un petit système de build incrémental. Écris Construction où chaque cible a : des sources (contenu en mémoire), des dépendances (autres cibles) et une commande (fonction pure qui produit un contenu). Le système :
- calcule la clé de chaque cible = haché(contenu des sources + clés des dépendances + nom de la commande) ;
- n'exécute une cible que si sa clé n'est pas déjà en cache ;
- compte les exécutions réelles ;
- teste un graphe
lib → app → paquetetlib → tests: une première construction (tout est exécuté), une seconde identique (rien n'est exécuté), la modification d'un fichier deapp(seulsappetpaquetsont reconstruits, paslibnitests), la modification delib(tout est reconstruit).
✅ Pistes de correction
import hashlib
class Construction:
def __init__(self):
self.cibles, self.cache, self.executions = {}, {}, []
def cible(self, nom, sources, deps, commande):
self.cibles[nom] = {"sources": sources, "deps": deps, "commande": commande}
def cle(self, nom, memo=None):
memo = {} if memo is None else memo
if nom in memo:
return memo[nom]
c = self.cibles[nom]
h = hashlib.sha256()
for chemin in sorted(c["sources"]):
h.update(chemin.encode()); h.update(c["sources"][chemin].encode())
for d in sorted(c["deps"]):
h.update(self.cle(d, memo).encode())
h.update(c["commande"].__name__.encode())
memo[nom] = h.hexdigest()
return memo[nom]
def ():
memo = {} memo memo
d .cibles[nom][]:
.construire(d, memo)
cle = .cle(nom, memo)
cle .cache:
c = .cibles[nom]
entrees = {d: .cache[.cle(d, memo)] d c[]}
.cache[cle] = c[](c[], entrees)
.executions.append(nom)
.cache[cle]
(): + .join((sources)) +
(): + .join((entrees.values())) +
(): + .join((entrees.values())) +
(): + .join((entrees.values())) +
():
b = Construction()
b.cible(, {: lib_src}, [], compiler)
b.cible(, {: app_src}, [], assembler)
b.cible(, {}, [], empaqueter)
b.cible(, {: }, [], tester)
b
b = monter(, )
t (, ): b.construire(t)
(b.executions) == [, , , ]
b.executions.clear()
t (, ): b.construire(t)
b.executions == []
b.cibles[][][] =
t (, ): b.construire(t)
(b.executions) == [, ]
b.executions.clear()
b.cibles[][][] =
t (, ): b.construire(t)
(b.executions) == [, , , ]
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
Dépendances flottantes (>=) en production | Le build d'hier ≠ celui d'aujourd'hui | Verrouillage versions + empreintes, mise à jour explicite |
| Horodatages et ordre aléatoire dans l'artefact | Impossible à comparer ou vérifier | Dates fixes, tri, SOURCE_DATE_EPOCH |
| Reconstruire par environnement | Ce qu'on teste n'est pas ce qu'on déploie | Construire une fois, promouvoir le même artefact |
| Cache indexé par le nom (pas le contenu) | Résultats périmés | Clé = haché de toutes les entrées |
🐉 Mini-boss (40 XP)
Chaîne de build vérifiable. Construis chaine_build.py pour un petit projet Python :
- un verrouillage avec empreintes, vérifié avant toute installation ;
- un build reproductible (archive à date fixe, ordre trié, permissions fixes) ;
- un cache par contenu avec compteur d'exécutions réelles ;
- un SBOM JSON (artefact + composants + empreintes) ;
- une vérification indépendante : un second script reconstruit l'artefact depuis les sources dans un autre dossier et compare l'empreinte avec celle publiée ;
- tests : modification d'une source, modification d'une dépendance, paquet altéré, horodatage glissé volontairement dans le build (le test de reproductibilité doit échouer).
✅ Pistes de correction
Un bon travail : fonctions verifier_lock, build_reproductible, Construction, sbom assemblées ; le second script (verifier_build.py) recalcule l'empreinte et compare avec le SBOM ; le test de « mauvais build » ajoute time.time() et vérifie que deux builds consécutifs diffèrent, ce qui déclenche l'échec de la porte de reproductibilité. Point de réflexion attendu : un build reproductible permet à un tiers de vérifier que l'artefact distribué correspond aux sources publiées.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un build reproductible produit :
- A. un artefact différent à chaque fois
- B. le même artefact à partir des mêmes sources et configuration
- C. uniquement des logs
2. Un fichier de verrouillage avec empreintes sert à :
- A. augmenter la vitesse du build
- B. remplacer les tests
- C. figer les versions exactes et refuser un paquet altéré
3. Une clé de cache adressée par le contenu change quand :
- A. une des entrées de l'étape change
- B. l'heure change
- C. le nom de la machine change
4. 🔁 Révision mission 02 : Une branche Git est :
- A. une copie complète du projet
- B. un pointeur mobile vers un commit
- C. un fichier de configuration
5. 🔁 Révision mission 02 : Pour annuler un changement déjà partagé, on utilise :
- A. git rebase sur la branche publique
- B. supprimer le dépôt
- C. git revert, qui crée un commit d'annulation
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Peux-tu reconstruire aujourd'hui, à l'identique, la version de ton projet d'il y a six mois ? Qu'est-ce qui manquerait ?
- Quelle entrée non verrouillée (version, outil, variable) est la plus risquée dans ton build ?
🎒 À retenir
- Reproductible : mêmes entrées, même artefact.
- Sources de variation : dépendances flottantes, horodatages, ordre, chemins, environnement.
- Verrouillage avec empreintes ; paquets altérés refusés.
- Cache adressé par le contenu ; construire une fois, déployer partout.
- SBOM : inventaire des composants relié à l'empreinte de l'artefact.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Constructeur déterministe
← Mission 02 — Git et stratégie de collaboration · Mission 04 — Conteneurs →
HEF-120 — DevOps et livraison

