Le même artefact doit tourner partout. Ce qui change d'un environnement à l'autre, c'est la configuration — et certains réglages sont des secrets.
⏱️ Durée : environ 95 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Gardien des réglages
🎬 L'histoire
HashBox a trois environnements : développement, test, production. Dans le code, Kodi a écrit if host == "prod-db": .... Un jour, quelqu'un copie la clé de l'API de paiement de production dans un fichier de configuration… et le pousse sur le dépôt. Un autre jour, l'application démarre en production avec l'adresse de la base de test : la configuration avait une faute de frappe, et personne ne l'a détectée avant les premiers clients.
« La configuration est du code qu'on ne compile pas, dit Sam. Elle mérite les mêmes soins : validation, versionnement, revue. Et les secrets, eux, ne vont jamais au même endroit. »
Tu apprends les principes des applications « douze facteurs », à charger et valider une configuration par couches, à séparer les secrets, à détecter la dérive entre environnements et à faire tourner un secret sans interruption.
🎯 Ta mission
À la fin, je serai capable de :
- séparer le code, la configuration et les secrets
- charger la configuration par couches (défauts, fichier, environnement)
- valider la configuration au démarrage avec des types et des plages
- masquer les secrets dans les journaux et détecter la dérive entre environnements
- faire la rotation d'un secret sans interruption de service
🧩 Défi d'échauffement (5 XP)
Une maison a un code d'alarme, un thermostat réglé à 19 °C et une clé de la porte d'entrée. Lesquels peut-on afficher dans le salon ? Lesquels doivent rester secrets ? Lesquels changent d'une saison à l'autre sans changer la maison ? Fais le parallèle avec : URL de la base, mot de passe de la base, niveau de journalisation.
💡 Le concept
Code, configuration, secrets
| Définition | Exemples | Où | |
|---|---|---|---|
| Code | logique de l'application, identique partout | fonctions, règles | dépôt, artefact |
| Configuration | réglages qui varient selon l'environnement | URL de service, taille de pool, niveau de journalisation | environnement, fichier versionné |
| Secret | configuration sensible : sa fuite cause un dommage | mot de passe, clé d'API, certificat | coffre-fort / gestionnaire de secrets |
Test pratique : si tu pouvais publier ton dépôt demain en open source sans rien révéler de dangereux, tes secrets sont bien séparés.
Les douze facteurs : configuration
Le principe III de l'application « douze facteurs » : stocker la configuration dans l'environnement (variables d'environnement), pas dans le code. Un seul artefact, plusieurs configurations → la mission 3 (« construire une fois »).
Charger par couches
Ordre de priorité habituel, du plus faible au plus fort :
1. valeurs par défaut (dans le code)
2. fichier de configuration (par environnement, versionné)
3. variables d'environnement
4. arguments de la ligne de commande
Chaque couche remplace la précédente. Les valeurs par défaut doivent être sûres (journalisation modérée, aucune fonction dangereuse activée).
Valider au démarrage : échouer vite
Une configuration fausse doit empêcher le démarrage, pas faire planter une requête dans la nuit :
- types (entier, booléen, URL) ;
- plages (port entre 1 et 65535) ;
- obligatoire vs optionnel ;
- cohérences croisées (
debug=Trueinterdit en production) ; - message d'erreur clair qui nomme le réglage fautif (sans afficher un secret).
Les secrets
| Pratique | Détail |
|---|---|
| Jamais dans le dépôt | ni en clair, ni « temporairement », ni dans l'historique |
| Gestionnaire de secrets | coffre (Vault, gestionnaire du cloud) qui contrôle l'accès, journalise, fait tourner |
| Injection à l'exécution | variable d'environnement, fichier monté en mémoire, jamais dans l'image |
| Moindre privilège | un secret par service et par environnement, avec les droits strictement nécessaires |
| Masquage | jamais affichés dans les journaux ni les erreurs |
| Rotation | renouvelés régulièrement et après toute suspicion de fuite |
| Détection | analyse automatique des commits pour repérer les secrets (HEF-100, mission 5) |
Dérive de configuration
La dérive (drift) : des environnements qui devraient être semblables se différencient peu à peu (modification manuelle, réglage oublié). Remède : tout décrire dans des fichiers versionnés, appliqués automatiquement, et comparer régulièrement les environnements : seules les différences voulues (adresses, tailles) doivent subsister.
Rotation sans interruption
Changer brutalement un secret coupe les clients qui utilisent l'ancien. La méthode à chevauchement :
- créer un nouveau secret, accepter les deux ;
- mettre à jour les clients un par un ;
- vérifier qu'aucun client n'utilise plus l'ancien ;
- révoquer l'ancien.
Drapeaux de fonctionnalité
Les drapeaux (feature flags) activent ou non une fonctionnalité sans redéployer. Ils sont de la configuration dynamique : valeur modifiable à chaud, par environnement ou pourcentage d'utilisateurs (mission 7). Ils doivent être retirés une fois la fonctionnalité généralisée.
🧠 Astuce : écris un test qui charge la configuration de chaque environnement et vérifie qu'elle est valide. Une erreur de configuration détectée en CI ne coûte rien ; détectée en production, elle coûte cher.
🔍 Exemple pas à pas
Problème : écrire un chargeur de configuration par couches avec validation, masquage des secrets, comparaison d'environnements et rotation à chevauchement.
from dataclasses import dataclass, fields
# ---------------- 1. configuration typée et validée ----------------
@dataclass(frozen=True)
class Config:
environnement: str = "dev"
port: int = 8000
debug: bool = False
url_base: str = "sqlite:///local.db"
niveau_journal: str = "INFO"
mot_de_passe_base: str = "" # SECRET : jamais de valeur par défaut utile
cle_api: str = "" # SECRET
SECRETS = ("mot_de_passe_base", "cle_api")
def __repr__(self): # JAMAIS de secret dans les journaux
morceaux = [f"{f.name}={'***' if f.name in self.SECRETS and getattr(self, f.name) else repr(getattr(self, f.name))}" for f in fields(self)]
return f"Config({.join(morceaux)})"
():
():
type_ :
(valeur).lower() (, , , ):
(valeur).lower() (, , , ):
ValueError()
type_(valeur)
():
couches = {}
source (fichier {}, {k[:].lower(): v k, v (env {}).items() k.startswith()}, cli {}):
couches.update(source)
erreurs, valeurs = [], {}
noms = {f.name: f f fields(Config)}
cle couches:
cle noms:
erreurs.append()
nom, f noms.items():
nom couches:
:
valeurs[nom] = convertir(couches[nom], f. (f., ) (f.))
(ValueError, TypeError) e:
erreurs.append()
erreurs:
ConfigInvalide(.join(erreurs))
config = Config(**valeurs)
<= config.port <= :
erreurs.append()
config.niveau_journal (, , , ):
erreurs.append()
config.environnement == :
config.debug: erreurs.append()
config.mot_de_passe_base: erreurs.append()
config.cle_api: erreurs.append()
config.url_base.startswith(): erreurs.append()
erreurs:
ConfigInvalide(.join(erreurs))
config
FICHIER_PROD = {: , : , : }
ENV_PROD = {: , : , : , : }
c = charger(FICHIER_PROD, ENV_PROD)
(c)
c.port == c.mot_de_passe_base ==
(c) (c) (c)
mauvaise, motif (({: , : , : }, ),
({: }, ), ({: }, ), ({: }, )):
:
charger(mauvaise, {}); AssertionError(motif)
ConfigInvalide e:
motif (e), (motif, (e))
()
():
voulues, suspectes = {}, {}
f fields(Config):
va, vb = (a, f.name), (b, f.name)
va != vb:
(voulues f.name attendues suspectes)[f.name] = (va, vb)
voulues, suspectes
staging = charger({: , : , : }, {: })
voulues, suspectes = deriver(c, staging)
(, suspectes)
suspectes suspectes
:
():
.cles = {actuelle}
(): cle .cles
(): .cles.add(nouvelle)
(): .cles.discard(ancienne)
serveur = VerificateurCle()
clients = {: , : }
serveur.ajouter_nouvelle()
clients[] =
(serveur.accepter(k) k clients.values())
clients[] =
(k == k clients.values())
serveur.revoquer()
(serveur.accepter(k) k clients.values()) serveur.accepter()
()
Lecture :
- Couches : défauts < fichier < environnement < CLI. Le fichier de prod ne contient aucun secret ; ils arrivent par l'environnement au démarrage.
- Validation : types, plages, réglage inconnu (la faute de frappe
protest détectée), cohérences croisées (debug interdit en prod). Le message nomme le réglage fautif, jamais la valeur d'un secret. - Masquage :
repr(config)affiche***à la place des secrets — unprint(config)malencontreux ne les fuit pas. - Dérive : la comparaison sépare les différences voulues (adresse de base, secrets) des suspectes (le port diffère entre prod et staging).
- Rotation : les deux clés sont valides pendant la migration, la révocation vient en dernier : zéro coupure.
✍️ À toi, avec aide (10 XP)
Écris scanner_secrets(texte) qui repère des secrets probables dans des lignes de configuration ou de code :
- affectations à des noms contenant
password,secret,token,keyavec une valeur de 8 caractères ou plus ; - clés d'API au format connu :
sk_live_suivi de 10 caractères alphanumériques ou plus,AKIA+ 16 majuscules/chiffres ; - ignore les valeurs qui sont des références (
${VAR},os.environ[...],getenv).
Renvoie (numéro de ligne, type). Teste avec 8 lignes.
💡 Indice 1
Utilise deux expressions régulières : une pour les affectations, une pour les formats connus.
💡 Indice 2
Ignore la ligne si elle contient ${, environ ou getenv.
💡 Indice 3
Compte les lignes à partir de 1.
✅ Réponse
import re
AFFECTATION = re.compile(r"(?i)\b\w*(password|passwd|secret|token|key)\w*\s*[:=]\s*['\"]?([^'\"\s]{8,})")
FORMATS = [("clé API live", re.compile(r"sk_live_[A-Za-z0-9]{10,}")), ("clé AWS", re.compile(r"AKIA[0-9A-Z]{16}"))]
def scanner_secrets(texte):
trouves = []
for n, ligne in enumerate(texte.splitlines(), 1):
if "${" in ligne or "environ" in ligne or "getenv" in ligne:
continue
for nom, motif in FORMATS:
if motif.search(ligne):
trouves.append((n, nom))
if AFFECTATION.search(ligne) and not any(m.search(ligne) for _, m in FORMATS):
trouves.append((n, "secret en dur"))
return trouves
TEXTE = '''port = 8080
password = "hunter2hunter2"
api_token: abcdef123456
cle = os.environ["CLE_API"]
password = ${DB_PASSWORD}
STRIPE = "sk_live_ABCDEF1234567890"
niveau = "debug"
aws = AKIAABCDEFGHIJKLMNOP'''
res = scanner_secrets(TEXTE)
print(res)
assert res == [(, ), (, ), (, ), (, )]
🚀 À toi, en solo (20 XP)
Gestionnaire de secrets minimal avec audit. Écris Coffre :
ecrire(nom, valeur, par),lire(nom, par)avec une politique d'accès (qui peut lire quoi) ;- chaque accès (réussi ou refusé) est journalisé (qui, quoi, quand — horloge injectée) sans jamais enregistrer la valeur ;
- versions : écrire un secret crée une nouvelle version ; la lecture renvoie la dernière ;
lire_versionpermet la migration ; - expiration : un secret expiré (durée de vie fixée) est signalé ;
a_renouveler(maintenant)liste les secrets dont l'âge dépasse 80 % de leur durée de vie ;- teste : accès refusé, journal sans valeur, rotation avec chevauchement de versions.
✅ Pistes de correction
from datetime import datetime, timedelta
class AccesRefuse(Exception):
pass
class Coffre:
def __init__(self, politique, horloge):
self.politique, self.horloge = politique, horloge # politique : {secret: {identités autorisées}}
self.versions, self.journal = {}, []
def _noter(self, qui, quoi, resultat):
self.journal.append({"t": self.horloge(), "qui": qui, "quoi": quoi, "resultat": resultat}) # PAS de valeur
def ecrire(self, nom, valeur, par, duree=timedelta(days=90)):
if par not in self.politique.get(nom, ()):
self._noter(par, f"ecrire:{nom}", "refusé"); raise AccesRefuse(nom)
self.versions.setdefault(nom, []).append({"valeur": valeur, : .horloge(), : duree})
._noter(par, , )
():
par .politique.get(nom, ()):
._noter(par, , ); AccesRefuse(nom)
v = .versions[nom][- version version - ]
._noter(par, , )
v[]
():
(n n, vs .versions.items() maintenant - vs[-][] >= vs[-][] * )
t = {: datetime(, , )}
coffre = Coffre({: {, }}, : t[])
coffre.ecrire(, , )
coffre.lire(, ) ==
:
coffre.lire(, ); AssertionError
AccesRefuse:
coffre.ecrire(, , )
coffre.lire(, ) == coffre.lire(, , version=) ==
( (e) e coffre.journal)
coffre.a_renouveler(datetime(, , )) == []
coffre.a_renouveler(datetime(, , )) == []
(, [(e[], e[], e[]) e coffre.journal][:])
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Secrets dans le dépôt | Fuite définitive (l'historique garde tout) | Coffre, injection à l'exécution, détection de secrets |
if environnement == 'prod' dans le code | Chemins de code jamais testés avant la production | Même code partout, comportement piloté par la configuration |
| Configuration non validée | Erreur découverte en pleine charge | Validation complète au démarrage, échec immédiat |
| Rotation brutale | Coupure des clients | Chevauchement des versions |
🐉 Mini-boss (40 XP)
Système de configuration de HashBox. Construis un module complet :
- configuration typée avec couches (défauts, fichier JSON par environnement, variables d'environnement, CLI) ;
- validations croisées (par environnement) et messages d'erreur sans secret ;
- coffre simulé avec politique, audit, versions et rotation à chevauchement ;
- scanner de secrets pour un répertoire de configuration, appelable en pré-commit ;
- comparaison automatique de trois environnements avec séparation différences voulues / suspectes ;
- test qui charge chaque fichier d'environnement du dépôt et vérifie qu'il est valide ;
- simule un incident : un secret fuite dans un commit ; écris la procédure (révocation, rotation, recherche d'usage, nettoyage de l'historique, post-mortem).
✅ Pistes de correction
Un bon travail : classes Config, Coffre, fonctions charger, deriver, scanner_secrets ; un test paramétré (une exécution par fichier d'environnement) ; procédure d'incident : révoquer immédiatement (le secret est compromis même si le dépôt est privé), faire tourner, auditer les accès entre la fuite et la révocation, réécrire l'historique seulement en complément (jamais en remplacement de la révocation), ajouter la détection en pré-commit, écrire le post-mortem sans blâme.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un secret est :
- A. un nom de variable
- B. un commentaire dans le code
- C. une configuration sensible dont la fuite cause un dommage
2. La configuration d'une application douze facteurs est stockée :
- A. dans l'environnement, hors du code
- B. dans le code source
- C. dans l'image du conteneur
3. Pour changer un secret sans interruption, on :
- A. remplace brutalement le secret
- B. accepte l'ancien et le nouveau pendant la migration, puis révoque l'ancien
- C. attend la panne
4. 🔁 Révision mission 04 : Un conteneur est :
- A. une machine virtuelle complète
- B. un fichier de configuration
- C. un processus isolé par le noyau, instance d'une image
5. 🔁 Révision mission 04 : Une bonne pratique de sécurité d'un Dockerfile est :
- A. exécuter le processus avec un utilisateur non root
- B. utiliser
latest - C. copier les secrets dans l'image
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quels secrets de ton projet pourraient être déjà dans ton historique Git ?
- Combien de temps te faudrait-il pour faire tourner ta clé la plus critique sans interruption ?
🎒 À retenir
- Code, configuration, secrets : trois choses distinctes.
- Configuration dans l'environnement ; chargement par couches ; validation au démarrage.
- Secrets : coffre, injection à l'exécution, masquage, moindre privilège.
- Dérive : comparer les environnements, séparer le voulu du suspect.
- Rotation à chevauchement : ajouter, migrer, vérifier, révoquer.
flowchart LR
T(["Configuration et secrets"])
T --> R1["1. Code, configuration, secrets : trois choses distinctes."]
T --> R2["2. Configuration dans l'environnement ; chargement par couches ;…"]
T --> R3["3. Secrets : coffre, injection à l'exécution, masquage, moindre…"]
T --> R4["4. Dérive : comparer les environnements, séparer le voulu du suspect."]
T --> R5["5. Rotation à chevauchement : ajouter, migrer, vérifier, révoquer."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Gardien des réglages
← Mission 04 — Conteneurs · Mission 06 — Intégration continue (CI) →
HEF-120 — DevOps et livraison

