Parcourir les aide-mémoire · Ingénierie des données
Architecture Medallion : référence rapide
Concevoir des couches de données Bronze, Silver et Gold avec des responsabilités clairement attribuées, la possibilité de rejouer les chargements, des contrôles qualité, un traitement incrémental et des contrats de restitution, sans réduire l’architecture Medallion à une convention rigide de nommage de dossiers.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Bronze : préserver la fidélité à la source
- 2. Bronze : conserver le payload brut lorsque le parsing peut évoluer
- 3. Bronze : capturer l’identité de la source
- 4. Bronze : ne pas écraser à la légère les preuves de la source
- 5. Bronze : mettre en quarantaine séparément les entrées mal formées
- 6. Silver : définir d’abord le grain canonique
- 7. Silver : imposer les clés obligatoires
- 8. Silver : normaliser les types
- 9. Silver : dédupliquer de manière déterministe
- 10. Ne pas utiliser un dropDuplicates() arbitraire pour la déduplication métier
- 11. Silver : valider l’unicité de la source avant le MERGE
- 12. Silver : utiliser MERGE pour les entités modifiables
- 13. Silver : ne mettre à jour qu’avec des versions plus récentes si nécessaire
- 14. Silver : garder explicite la logique des arrivées tardives
- 15. Silver : utiliser les données de référence avec prudence
- 16. Silver : distinguer une référence manquante d’une référence invalide
- 17. Silver : créer des champs métier canoniques
- 18. Silver : garder une signification métier stable
- 19. Gold : modéliser pour un cas d’usage consommateur
- 20. Gold : définir explicitement le grain de sortie
- 21. Gold : rapprocher les totaux
- 22. Gold peut être détaillée, pas seulement agrégée
- 23. Gold peut être un modèle de warehouse
- 24. Gold peut rester dans le Lakehouse
- 25. Ne pas imposer un système physique distinct pour chaque couche
- 26. Bronze doit généralement être rejouable
- 27. Préserver les versions de la source si nécessaire
- 28. Silver doit être reproductible
- 29. Versionner les données de référence critiques
- 30. Gold doit avoir un contrat consommateur
- 31. Utiliser des contrôles qualité entre les couches
- 32. Ajouter des métadonnées d’exécution
- 33. Le watermark ne doit avancer qu’après un travail durable réussi
- 34. L’ingestion Bronze peut être en ajout seul
- 35. Silver n’a pas à être en ajout seul
- 36. Gold peut être reconstruite ou maintenue de façon incrémentale
- 37. Ne pas rendre chaque couche incrémentale simplement parce que la source l’est
- 38. Un rechargement historique doit avoir des bornes explicites
- 39. Les rechargements historiques et le traitement courant doivent coexister en toute sécurité
- 40. Séparer le checkpoint du traitement courant de l’état des rechargements historiques
- 41. Le streaming s’intègre à l’architecture Medallion
- 42. Le batch s’intègre à la même architecture
- 43. L’hybride est normal
- 44. Ne pas dupliquer la logique de transformation entre les chemins batch et streaming
- 45. Utiliser des noms Bronze alignés sur la source
- 46. Utiliser des noms Silver canoniques
- 47. Utiliser des noms Gold orientés consommateurs
- 48. Ne pas copier chaque table source dans les trois couches
- 49. Tous les jeux de données n’ont pas besoin des trois couches
- 50. Bronze peut conserver la dérive de schéma de la source
- 51. Silver doit échouer ou mettre en quarantaine en cas de changement de schéma cassant
- 52. Attribuer des identifiants stables aux règles de qualité des données
- 53. Garder la quarantaine hors des tables fiables
- 54. La quarantaine a besoin de métadonnées de correction
- 55. Silver peut préserver la traçabilité vers la source rejetée
- 56. Gold ne doit pas contourner Silver à la légère
- 57. Éviter la logique consommateur dans Bronze
- 58. Éviter que les particularités de la source ne se propagent dans Gold
- 59. Centraliser les indicateurs métier
- 60. Gold peut comporter plusieurs modèles consommateurs
- 61. Éviter une table « Gold d’entreprise » géante
- 62. Utiliser la modélisation dimensionnelle lorsque c’est pertinent
- 63. Gold peut servir des API
- 64. Précalculer la logique de reporting coûteuse lorsque c’est utile
- 65. Ne pas précalculer toutes les requêtes possibles
- 66. La fraîcheur de Gold doit être explicite
- 67. La traçabilité des données doit traverser les couches
- 68. Utiliser des clés métier stables
- 69. La logique SCD a sa place là où l’historique canonique est défini
- 70. Séparer l’historique des événements des entités d’état actuel
- 71. Stocker séparément le temps métier et le temps d’ingestion
- 72. La politique de données tardives doit être propre à chaque couche
- 73. Les corrections Gold doivent être déterministes
- 74. Le partitionnement peut différer selon la couche
- 75. Éviter le surpartitionnement de Bronze
- 76. Éviter le surpartitionnement de Silver/Gold
- 77. Compacter les petits fichiers si nécessaire
- 78. L’évolution du schéma doit être gouvernée par couche
- 79. Les changements cassants nécessitent un versionnement/une migration
- 80. Utiliser des contrats de table pour Gold
- 81. La rétention de Bronze doit correspondre aux besoins de rejeu
- 82. La rétention de Silver peut être différente
- 83. La rétention de Gold suit les besoins des consommateurs/les obligations légales
- 84. La sécurité peut différer selon la couche
- 85. Ne pas utiliser les noms de couche comme contrôles de sécurité
- 86. Masquer/tokeniser lorsque le modèle fiable l’exige
- 87. Éviter de stocker des secrets dans Bronze sauf si c’est nécessaire
- 88. Ne pas laisser Bronze devenir un stockage permanent de rebuts
- 89. Superviser chaque couche différemment
- 90. Utiliser des critères de réussite propres à chaque couche
- 91. Éviter les réactions en chaîne provoquées par un seul lot source défectueux
- 92. La promotion est une transition de contrat
- 93. Ne pas promouvoir en copiant aveuglément des fichiers
- 94. Utiliser des vues lorsque la duplication physique est inutile
- 95. Matérialiser lorsque cela apporte de la valeur
- 96. Ne pas confondre le nombre de dossiers avec la maturité de l’architecture
- 97. Définir la propriété par couche et par jeu de données
- 98. Garder un code modulaire par responsabilité
- 99. Tester explicitement le rejeu
- 100. Utiliser une liste de vérification d’architecture reproductible
- Interpréter le résultat
- Points à vérifier
- Bronze ne permet pas de reconstruire Silver
- Silver contient des clés métier en double
- Gold ne concorde pas avec Silver
- La logique Gold contient des particularités propres à la source
- Chaque table source existe dans les trois couches sans aucune transformation
- Les rechargements historiques interfèrent avec les jobs courants
- Notes de production
- L’architecture Medallion est un modèle de responsabilités
- La capacité de rejeu est l’un des tests de conception les plus solides
- La qualité se joue entre les couches
- La rétention et la sécurité varient selon la couche
- Gold est un produit de données
- Une conception incrémentale doit rester récupérable
- Erreurs fréquentes
- 1. Traiter Bronze comme un dépotoir non gouverné
- 2. Effectuer des transformations métier dans Bronze
- 3. Utiliser une déduplication arbitraire dans Silver
- 4. Laisser Gold contourner Silver de façon routinière
- 5. Supposer que Gold doit être agrégée
- 6. Copier chaque table dans les trois couches
- 7. Faire avancer les watermarks avant la réussite des contrôles qualité
- 8. Ignorer les données arrivant en retard
- 9. Utiliser les noms de couche comme mécanisme de sécurité
- 10. N’avoir aucun chemin de rejeu/de rechargement historique
- Étape suivante
- Pour aller plus loin
Problème
Une plateforme de données a besoin de frontières claires entre l’ingestion brute, la transformation fiable et les données prêtes pour les consommateurs.
Les équipes adoptent souvent les libellés Bronze, Silver et Gold, mais ces libellés ne suffisent pas à résoudre les vraies questions d’ingénierie :
- Qu’est-ce qui est autorisé dans chaque couche ?
- Quelle couche fait autorité pour le rejeu ?
- Où faut-il dédupliquer ?
- Où doivent résider les règles métier ?
- Comment gérer la dérive de schéma et les enregistrements invalides ?
- Comment fonctionnent les chargements incrémentaux et les rechargements historiques (backfills) ?
- Le streaming et le batch peuvent-ils coexister ?
- Quand Gold doit-elle être une table de Lakehouse plutôt qu’un modèle de warehouse/reporting ?
- Comment éviter que la même transformation soit réimplémentée différemment dans plusieurs couches ?
L’objectif est d’utiliser le modèle Medallion comme un modèle de responsabilités, et non comme une hiérarchie de dossiers décorative.
Réponse rapide
Utilisez ce modèle mental :
Bronze
→ préserver la vérité de la source et la possibilité de rejouer
Silver
→ créer des données fiables, nettoyées et harmonisées à un grain métier défini
Gold
→ publier des données prêtes pour les consommateurs, avec une sémantique métier stable
Un flux pragmatique :
source
→ Bronze : ingestion + métadonnées + normalisation minimale
→ Silver : validation + déduplication + harmonisation + enrichissement
→ Gold : agrégation/modélisation/restitution pour les consommateurs
Bon principe par défaut :
Bronze répond à :
« Qu’a envoyé la source ? »
Silver répond à :
« Que signifient les données canoniques fiables ? »
Gold répond à :
« Que doit utiliser un consommateur ? »
Code / commandes
1. Bronze : préserver la fidélité à la source
Responsabilités typiques de Bronze :
ajouter les enregistrements sources
préserver les champs bruts
capturer les métadonnées du fichier/de l’événement source
capturer l’horodatage d’ingestion
capturer l’identifiant de lot/d’exécution
éviter les transformations métier destructives
Exemple de modèle PySpark :
from pyspark.sql import functions as F
bronze = (
source_df
.withColumn(
"_ingested_at",
F.current_timestamp(),
)
.withColumn(
"_source_file",
F.input_file_name(),
)
.withColumn(
"_batch_id",
F.lit(batch_id),
)
)
Écrivez ensuite les données en mode ajout :
(
bronze.write
.format("delta")
.mode("append")
.saveAsTable("bronze.orders_raw")
)
Utilisez une sémantique d’ajout lorsque la source représente des arrivées immuables.
2. Bronze : conserver le payload brut lorsque le parsing peut évoluer
Pour les payloads d’événements/d’API :
champs analysés
+
raw_payload
peuvent être précieux.
Exemple :
bronze = source_df.withColumn(
"_raw_payload",
F.to_json(F.struct("*")),
)
N’appliquez pas cela aveuglément si le payload contient des secrets ou des données réglementées.
Ne conservez que ce que votre politique de rétention/sécurité autorise.
3. Bronze : capturer l’identité de la source
Métadonnées utiles :
_source_system
_source_file
_source_event_id
_ingested_at
_batch_id
_pipeline_run_id
_source_partition
Ces champs facilitent :
- le rejeu
- la détection des doublons
- la traçabilité
- l’analyse des incidents
4. Bronze : ne pas écraser à la légère les preuves de la source
Mauvais modèle :
lire la source
→ convertir les valeurs invalides en null
→ supprimer l’original
Mieux :
champ brut
+
champ analysé
+
statut/motif du parsing
Cela conserve les preuves nécessaires à la correction.
5. Bronze : mettre en quarantaine séparément les entrées mal formées
Exemple :
valid = parsed.filter(
F.col("_parse_error").isNull()
)
invalid = parsed.filter(
F.col("_parse_error").isNotNull()
)
Écrivez les lignes invalides avec :
motif
emplacement dans la source
lot
horodatage d’ingestion
Ne supprimez pas silencieusement les enregistrements mal formés.
6. Silver : définir d’abord le grain canonique
Avant de transformer Silver, énoncez la signification d’une ligne.
Exemple :
une ligne par order_id
ou :
une ligne par ligne de commande
Ne laissez pas les jointures ou les relances modifier ce grain en silence.
7. Silver : imposer les clés obligatoires
Exemple :
silver_candidate = bronze.filter(
F.col("order_id").isNotNull()
)
Si les clés nulles sont invalides, envoyez-les en quarantaine plutôt que de les supprimer discrètement sans laisser de trace.
8. Silver : normaliser les types
Exemple :
silver_candidate = (
bronze
.withColumn(
"order_date",
F.to_date("order_date_raw"),
)
.withColumn(
"amount",
F.col("amount_raw").cast("decimal(18,2)"),
)
)
Validez explicitement les échecs de conversion.
9. Silver : dédupliquer de manière déterministe
Si la source peut renvoyer le même enregistrement métier, choisissez une version gagnante documentée.
Exemple :
from pyspark.sql.window import Window
w = (
Window
.partitionBy("order_id")
.orderBy(
F.col("source_updated_at").desc(),
F.col("_ingested_at").desc(),
F.col("_source_event_id").desc(),
)
)
deduped = (
silver_candidate
.withColumn(
"_rn",
F.row_number().over(w),
)
.filter(F.col("_rn") == 1)
.drop("_rn")
)
Les critères de départage doivent être déterministes.
10. Ne pas utiliser un dropDuplicates() arbitraire pour la déduplication métier
Mauvais :
df.dropDuplicates(["order_id"])
Cela n’indique pas quelle version l’emporte.
Utilisez une logique de fenêtre ordonnée ou le versionnement de la source.
11. Silver : valider l’unicité de la source avant le MERGE
duplicates = (
deduped
.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
)
if duplicates.limit(1).count() > 0:
raise ValueError(
"Silver source is not unique by order_id"
)
Cela protège le grain de la cible.
12. Silver : utiliser MERGE pour les entités modifiables
from delta.tables import DeltaTable
target = DeltaTable.forName(
spark,
"silver.orders",
)
(
target.alias("t")
.merge(
deduped.alias("s"),
"t.order_id = s.order_id",
)
.whenMatchedUpdateAll()
.whenNotMatchedInsertAll()
.execute()
)
Utilisez des correspondances de colonnes explicites lorsque vous avez besoin d’un contrôle plus strict du schéma.
13. Silver : ne mettre à jour qu’avec des versions plus récentes si nécessaire
Condition conceptuelle :
source.source_updated_at > target.source_updated_at
Exemple :
(
target.alias("t")
.merge(
deduped.alias("s"),
"t.order_id = s.order_id",
)
.whenMatchedUpdateAll(
condition=(
"s.source_updated_at > t.source_updated_at"
)
)
.whenNotMatchedInsertAll()
.execute()
)
Cela évite que des enregistrements plus anciens rejoués écrasent un état plus récent.
14. Silver : garder explicite la logique des arrivées tardives
Exemple :
commande créée le 1er octobre
arrivée le 4 octobre
Décidez si Silver :
- met à jour la partition historique
- ajoute un événement
- modifie l’état actuel de l’entité
- envoie l’enregistrement vers un circuit de rapprochement
Le comportement face aux données tardives fait partie du contrat.
15. Silver : utiliser les données de référence avec prudence
Exemple :
orders = (
orders.alias("o")
.join(
customers.alias("c"),
on="customer_id",
how="left",
)
)
Vérifiez que la clé de dimension/de référence est unique avant la jointure.
Sinon, Silver peut multiplier les lignes de façon inattendue.
16. Silver : distinguer une référence manquante d’une référence invalide
Un client manquant peut signifier :
une clé erronée
un client arrivé en retard
un retard d’actualisation des données de référence
Ne classez pas chaque absence comme une corruption sans comprendre le calendrier de la source.
17. Silver : créer des champs métier canoniques
Exemples :
code pays normalisé
devise canonique
horodatage d’événement fiable
statut métier
ID de commerçant harmonisé
Évitez ici la logique de présentation propre à un consommateur, sauf si elle est réellement canonique.
18. Silver : garder une signification métier stable
Si une table Silver signifie :
une ligne par compte actif
ne la changez pas plus tard en :
une ligne par événement de compte
sans changement délibéré de contrat/de version.
19. Gold : modéliser pour un cas d’usage consommateur
Gold n’est pas simplement :
Silver avec des noms plus jolis
Gold doit répondre à un besoin du consommateur/du métier.
Exemples :
ventes quotidiennes par commerçant
vue client 360
synthèse financière mensuelle
modèle faits/dimensions prêt pour le reporting
table de features
table de restitution pour une API
20. Gold : définir explicitement le grain de sortie
Exemple :
une ligne par :
report_date + merchant_id + currency
Agrégez ensuite :
gold = (
silver_orders
.groupBy(
"order_date",
"merchant_id",
"currency",
)
.agg(
F.count("*").alias("order_count"),
F.sum("amount").alias("gross_amount"),
)
)
Validez l’unicité à ce grain.
21. Gold : rapprocher les totaux
Avant la publication :
silver_total = (
silver_orders
.filter(
(F.col("order_date") >= "2026-10-01") &
(F.col("order_date") < "2026-11-01")
)
.agg(
F.sum("amount").alias("amount")
)
)
gold_total = (
gold
.filter(
(F.col("order_date") >= "2026-10-01") &
(F.col("order_date") < "2026-11-01")
)
.agg(
F.sum("gross_amount").alias("amount")
)
)
Gold doit concorder avec la sémantique fiable en amont pour le même périmètre.
22. Gold peut être détaillée, pas seulement agrégée
Gold peut contenir :
une table de faits détaillée prête pour les consommateurs
si le consommateur a besoin de données au niveau de la ligne.
N’imposez pas d’agrégation simplement parce que la couche s’appelle Gold.
23. Gold peut être un modèle de warehouse
Bon choix :
Lakehouse Bronze/Silver
→ Warehouse Gold
lorsque les consommateurs ont besoin :
- d’une restitution SQL
- de modèles dimensionnels
- de BI/reporting
- de procédures stockées ou d’une sémantique de warehouse, lorsqu’elles sont prises en charge
Ne dupliquez pas les données dans un warehouse, sauf si la valeur de restitution le justifie.
24. Gold peut rester dans le Lakehouse
Bon choix lorsque les consommateurs utilisent :
- Spark
- des notebooks
- un accès direct au lake
- les surfaces SQL du Lakehouse
- des charges d’ingénierie en aval
L’architecture doit suivre les besoins des consommateurs.
25. Ne pas imposer un système physique distinct pour chaque couche
Vous pouvez avoir :
Bronze Lakehouse
Silver Lakehouse
Gold Lakehouse
ou :
Bronze/Silver Lakehouse
Gold Warehouse
Le concept Medallion porte sur des frontières de responsabilité, pas sur des produits obligatoires.
26. Bronze doit généralement être rejouable
Un test clé :
Puis-je reconstruire Silver si la logique de transformation change ?
Sinon, Bronze ne préserve peut-être pas assez d’historique de la source.
27. Préserver les versions de la source si nécessaire
Si la source n’envoie que des instantanés modifiables, demandez-vous si vous avez besoin :
de l’historique des arrivées
de la date d’instantané
de la version de la source
pour l’audit/le rejeu.
Ne supposez pas que l’état actuel de la source suffit pour reconstruire la logique historique.
28. Silver doit être reproductible
À partir :
du même périmètre Bronze
du même code/de la même version de transformation
des mêmes données/de la même version de référence
vous devez pouvoir reproduire le même résultat Silver, dans la mesure du possible.
Les dépendances modifiables cachées réduisent la capacité de rejeu.
29. Versionner les données de référence critiques
Si Silver dépend :
de la hiérarchie des commerçants
du mapping des devises
du mapping des pays
et que ces données évoluent dans le temps, conservez des dates d’effet ou des versions lorsque l’exactitude historique compte.
30. Gold doit avoir un contrat consommateur
Documentez :
le grain
les clés
les indicateurs
les dimensions
la fréquence d’actualisation
la fraîcheur attendue
le comportement face aux données tardives
la propriété
Cela fait de Gold un produit, et pas simplement une table de plus.
31. Utiliser des contrôles qualité entre les couches
Exemple :
Contrôle Bronze → Silver :
schéma requis
clé obligatoire présente
parsing réussi
politique de doublons
Contrôle Silver → Gold :
grain fiable
intégrité référentielle
rapprochement des indicateurs
fraîcheur
Ne reportez pas toute la validation sur la couche finale.
32. Ajouter des métadonnées d’exécution
Métadonnées utiles par exécution de pipeline :
run_id
batch_id
watermark source
watermark cible
nombre de lignes
statut
version du code
started_at
completed_at
Cela facilite la traçabilité et le rejeu.
33. Le watermark ne doit avancer qu’après un travail durable réussi
Correct :
lire
→ transformer
→ valider
→ écrire
→ rapprocher
→ faire avancer le watermark
Mauvais :
faire avancer le watermark
→ l’écriture échoue
Ce dernier cas peut faire sauter des données.
34. L’ingestion Bronze peut être en ajout seul
Utile lorsque la source est constituée :
d’événements
de fichiers
d’enregistrements CDC
d’instantanés d’API avec des métadonnées de lot
L’ajout préserve l’historique.
La logique Silver décide ensuite de l’état actuel/canonique.
35. Silver n’a pas à être en ajout seul
Les entités canoniques modifiables ont souvent besoin de :
MERGE
mise à jour
suppression
gestion des SCD
Le bon mode d’écriture découle de la sémantique de l’entité.
36. Gold peut être reconstruite ou maintenue de façon incrémentale
Une reconstruction complète peut être préférable lorsque :
- Gold est suffisamment petite
- la logique change souvent
- la simplicité au service de l’exactitude compte
Une Gold incrémentale peut être préférable lorsque :
- la table est volumineuse
- les changements quotidiens sont faibles
- le coût de reconstruction est élevé
Choisissez de façon délibérée.
37. Ne pas rendre chaque couche incrémentale simplement parce que la source l’est
Parfois :
Bronze en ajout
Silver en MERGE
Gold en reconstruction complète
est la conception correcte la plus simple.
Le mode d’exécution peut différer selon la couche.
38. Un rechargement historique doit avoir des bornes explicites
Exemple :
rechargement historique :
2026-09-01
jusqu’au
2026-09-07
N’utilisez pas une formulation vague comme :
reconstruire les données récentes
pour des corrections en production.
39. Les rechargements historiques et le traitement courant doivent coexister en toute sécurité
Conflit potentiel :
le job courant met à jour le 4 octobre
le rechargement historique réécrit du 1er septembre au 4 octobre
Définissez :
- les règles de chevauchement
- les clés de fusion
- la coordination des jobs
- le comportement en cas de relance
- les attentes en matière de concurrence
40. Séparer le checkpoint du traitement courant de l’état des rechargements historiques
L’état du streaming/du traitement courant ne doit pas être ramené en arrière par une réparation historique.
Gardez les mécanismes de contrôle des rechargements historiques indépendants.
41. Le streaming s’intègre à l’architecture Medallion
Exemple :
flux d’événements
→ table d’événements Bronze durable
→ transformation Silver en streaming
→ agrégats Gold
Les couches représentent toujours des responsabilités.
42. Le batch s’intègre à la même architecture
Exemple :
fichier quotidien
→ chargement brut dans Bronze
→ nettoyage/merge dans Silver
→ table de reporting Gold
L’architecture Medallion est indépendante de la cadence d’exécution.
43. L’hybride est normal
Exemple :
Bronze ingérée en continu
Silver mise à jour toutes les quelques minutes
Gold reconstruite toutes les heures
Cela peut être tout à fait valable si cela respecte les SLA.
44. Ne pas dupliquer la logique de transformation entre les chemins batch et streaming
Si possible, centralisez les règles de transformation métier afin que :
le traitement courant
et
le rejeu historique
produisent des résultats cohérents.
45. Utiliser des noms Bronze alignés sur la source
Exemples :
bronze.salesforce_accounts
bronze.orders_api_events
bronze.erp_invoice_files
Bronze est généralement centrée sur la source.
46. Utiliser des noms Silver canoniques
Exemples :
silver.customer
silver.order
silver.merchant
Silver passe souvent d’une dénomination propre à la source à des concepts métier.
47. Utiliser des noms Gold orientés consommateurs
Exemples :
gold.daily_merchant_sales
gold.finance_monthly_summary
gold.customer_360
Le nommage Gold doit révéler l’usage prévu.
48. Ne pas copier chaque table source dans les trois couches
Mauvais modèle :
bronze.table_a
silver.table_a
gold.table_a
pour chaque table, quel que soit le besoin.
Ne créez Gold que lorsqu’il existe un véritable contrat consommateur.
49. Tous les jeux de données n’ont pas besoin des trois couches
Un petit jeu de données de référence peut suivre :
source
→ Silver
avec l’audit des données brutes ailleurs.
Un flux de staging temporaire n’a pas forcément besoin de Gold.
Appliquez les responsabilités, pas un cérémonial rigide.
50. Bronze peut conserver la dérive de schéma de la source
Selon la plateforme :
nouveaux champs
champs inconnus
payload brut
peuvent être acceptés dans Bronze.
Silver doit décider si le nouveau schéma est compatible.
51. Silver doit échouer ou mettre en quarantaine en cas de changement de schéma cassant
Exemples :
une clé obligatoire est supprimée
un décimal devient une chaîne mal formée
la signification d’un horodatage change
Il ne s’agit pas de dérives anodines.
Échouez de manière sûre ou mettez en quarantaine selon la gravité de la règle.
52. Attribuer des identifiants stables aux règles de qualité des données
Exemple :
DQ_ORDER_001
→ order_id obligatoire
DQ_ORDER_002
→ une ligne Silver par order_id
DQ_ORDER_003
→ la devise doit être prise en charge
Cela rend les contrôles entre couches observables.
53. Garder la quarantaine hors des tables fiables
Les enregistrements invalides ne doivent pas se mêler silencieusement à :
silver.orders
si Silver est présentée comme fiable.
Utilisez une table dédiée :
quarantine.orders_invalid
ou un équivalent.
54. La quarantaine a besoin de métadonnées de correction
Incluez :
rule_id
reason
source_file
batch_id
ingested_at
la clé métier si elle est disponible
Cela transforme les échecs en travail exploitable.
55. Silver peut préserver la traçabilité vers la source rejetée
Pour les lignes corrigées, conservez :
_source_system
_source_event_id
_source_file
lorsque c’est utile.
Canonique ne signifie pas sans traçabilité.
56. Gold ne doit pas contourner Silver à la légère
Mauvais :
Gold lit directement Bronze brut
parce que le rapport est urgent
Cela crée une sémantique incohérente.
Ne contournez Silver que lorsque l’architecture définit explicitement un autre chemin fiable.
57. Éviter la logique consommateur dans Bronze
Mauvaise transformation Bronze :
renommer les champs selon les libellés des rapports
appliquer les filtres des tableaux de bord
calculer les définitions des KPI
Cela relève des couches suivantes.
Bronze doit rester orientée source.
58. Éviter que les particularités de la source ne se propagent dans Gold
Gold ne doit pas obliger les consommateurs à comprendre que :
l’indicateur X du système source signifie actif
le statut source 7 signifie annulé
Silver doit d’abord normaliser cette signification.
59. Centraliser les indicateurs métier
Si gross_revenue est défini dans Gold, documentez la formule une seule fois.
Ne laissez pas chaque rapport le redéfinir différemment.
60. Gold peut comporter plusieurs modèles consommateurs
Exemple :
gold.sales_daily
gold.finance_monthly
gold.marketing_attribution
Chacun peut être valable, même s’il dérive des mêmes données Silver.
Gold est orientée consommateurs/cas d’usage.
61. Éviter une table « Gold d’entreprise » géante
Une table énorme qui tente de satisfaire tous les consommateurs devient généralement :
- difficile à gouverner
- difficile à optimiser
- ambiguë sur le plan sémantique
Privilégiez des modèles stables conçus pour un usage précis.
62. Utiliser la modélisation dimensionnelle lorsque c’est pertinent
Gold peut utiliser :
des tables de faits
des tables de dimensions
un schéma en étoile
lorsque le consommateur est la BI/le reporting.
L’architecture Medallion et la modélisation dimensionnelle sont complémentaires.
63. Gold peut servir des API
Exemple :
données canoniques Silver
→ table de restitution Gold
→ service de rapports/d’API
Cela permet d’isoler les transformations coûteuses de la restitution au moment des requêtes.
64. Précalculer la logique de reporting coûteuse lorsque c’est utile
Exemple :
agrégat quotidien Gold
peut éviter de recalculer les mêmes jointures coûteuses à chaque requête d’API.
À réserver aux modèles de requêtes stables et répétitifs.
65. Ne pas précalculer toutes les requêtes possibles
Si les dimensions/filtres des consommateurs sont très dynamiques, un modèle de restitution plus flexible peut être préférable.
Trouvez l’équilibre :
précalcul
ou
flexibilité des requêtes
66. La fraîcheur de Gold doit être explicite
Exemple :
actualisation toutes les 15 minutes
ou :
disponible chaque jour au plus tard à 06:00 UTC
Les consommateurs doivent connaître la fraîcheur attendue.
67. La traçabilité des données doit traverser les couches
Au minimum, vous devez pouvoir répondre à :
Quelle source/quel lot a créé cette ligne Silver ?
Quelles données Silver ont produit ce résultat Gold ?
Quelle version du pipeline/du code a été utilisée ?
Les outils de traçabilité exacts varient selon la plateforme.
68. Utiliser des clés métier stables
Les clés de substitution peuvent être utiles pour les modèles de warehouse.
Conservez néanmoins les identifiants source/métier nécessaires à la traçabilité.
69. La logique SCD a sa place là où l’historique canonique est défini
Pour les dimensions :
Silver
ou
Gold
peuvent être valables selon l’architecture.
L’important est la cohérence.
N’implémentez pas le SCD de type 2 différemment dans plusieurs couches consommateurs.
70. Séparer l’historique des événements des entités d’état actuel
Exemple :
silver.order_events
→ historique en ajout
silver.orders
→ état canonique actuel
Les deux peuvent être utiles.
N’obligez pas une seule table à représenter les deux sémantiques de façon ambiguë.
71. Stocker séparément le temps métier et le temps d’ingestion
Colonnes utiles :
event_time
source_updated_at
ingested_at
processed_at
Elles répondent à des questions différentes.
72. La politique de données tardives doit être propre à chaque couche
Bronze :
accepter/préserver les arrivées tardives
Silver :
appliquer la correction canonique
Gold :
recalculer les agrégats concernés
C’est souvent plus propre que de faire comme si les arrivées tardives n’existaient pas.
73. Les corrections Gold doivent être déterministes
Si un enregistrement Silver tardif affecte :
l’agrégat commerçant/jour
reconstruisez ou mettez à jour exactement ce périmètre Gold.
Évitez les réécritures larges et inexpliquées.
74. Le partitionnement peut différer selon la couche
Exemple :
Bronze
→ ingestion_date
Silver
→ event_date
Gold
→ report_month
Cela peut être valable, car chaque couche a des modèles d’accès différents.
Ne réutilisez pas mécaniquement la stratégie de partitionnement.
75. Éviter le surpartitionnement de Bronze
Les identifiants sources à forte cardinalité peuvent créer de minuscules fichiers/répertoires.
Utilisez des partitions opérationnelles grossières, par exemple par date/source, lorsque c’est justifié.
76. Éviter le surpartitionnement de Silver/Gold
Utilisez des colonnes de partition alignées sur :
- les filtres courants
- les rechargements historiques
- la rétention
- la maintenance
et non sur chaque dimension.
77. Compacter les petits fichiers si nécessaire
Pour Delta, la maintenance prise en charge par la plateforme peut inclure :
OPTIMIZE silver.orders;
À utiliser en fonction de la fragmentation des fichiers observée.
Ne planifiez pas de maintenance coûteuse sans éléments probants.
78. L’évolution du schéma doit être gouvernée par couche
Bronze peut tolérer une dérive additive.
Silver doit imposer le schéma canonique.
Gold doit protéger fermement les contrats consommateurs.
Chaque couche peut avoir sa propre politique d’évolution.
79. Les changements cassants nécessitent un versionnement/une migration
Exemple :
la définition d’un indicateur Gold change
Ne modifiez pas silencieusement la sémantique historique si des consommateurs dépendent de l’ancienne définition.
Options :
- une nouvelle version/table
- une migration coordonnée
- un rechargement historique documenté
80. Utiliser des contrats de table pour Gold
Documentez :
le propriétaire
le SLA
le grain
les clés
l’actualisation
le schéma
les indicateurs
la rétention
la politique de changements cassants
Cela rend Gold fiable pour les consommateurs.
81. La rétention de Bronze doit correspondre aux besoins de rejeu
Si Bronze est la seule source de rejeu et que vous ne conservez que trois jours, vous ne pourrez pas reconstruire six mois de Silver plus tard.
La rétention est une décision d’architecture.
82. La rétention de Silver peut être différente
Les tables Silver d’état actuel n’ont pas forcément besoin du même modèle de rétention que l’historique Bronze en ajout seul.
Définissez chacune explicitement.
83. La rétention de Gold suit les besoins des consommateurs/les obligations légales
Exemples :
13 mois pour le reporting
7 ans pour la finance
90 jours pour un tableau de bord opérationnel
N’héritez pas automatiquement de la rétention de Silver.
84. La sécurité peut différer selon la couche
Exemple :
Bronze
→ données personnelles brutes à accès très restreint
Silver
→ données masquées/harmonisées
Gold
→ accès des consommateurs selon le moindre privilège
L’architecture Medallion peut permettre une exposition progressive des données.
85. Ne pas utiliser les noms de couche comme contrôles de sécurité
Qu’une table s’appelle :
gold.*
ne la rend pas sûre pour autant.
Utilisez de vraies autorisations, le masquage, la sécurité au niveau des lignes et des politiques.
86. Masquer/tokeniser lorsque le modèle fiable l’exige
Silver peut être le bon endroit pour :
- normaliser les identifiants sensibles
- tokeniser
- masquer
- supprimer les secrets bruts inutiles
selon la gouvernance.
87. Éviter de stocker des secrets dans Bronze sauf si c’est nécessaire
La fidélité à la source brute ne justifie pas de conserver :
des mots de passe
des jetons d’accès
des clés privées
Supprimez ou protégez les données sensibles conformément à la politique.
88. Ne pas laisser Bronze devenir un stockage permanent de rebuts
Préserver les données brutes ne signifie pas :
aucun schéma
aucune métadonnée
aucune rétention
aucun propriétaire
Bronze a toujours besoin de gouvernance.
89. Superviser chaque couche différemment
Bronze :
arrivée
schéma
nombre de fichiers/d’événements
latence d’ingestion
Silver :
déduplication
qualité
intégrité référentielle
watermark
santé du MERGE
Gold :
rapprochement
fraîcheur
SLA consommateur
performances des requêtes
90. Utiliser des critères de réussite propres à chaque couche
Un pipeline peut réussir techniquement alors que Gold est obsolète.
Définissez la réussite par couche, et pas seulement par « job terminé ».
91. Éviter les réactions en chaîne provoquées par un seul lot source défectueux
Dans la mesure du possible :
mettre en quarantaine le lot Bronze défectueux
empêcher la promotion vers Silver
maintenir en fonctionnement les jeux de données non concernés
Ne laissez pas un seul fichier mal formé arrêter toute une plateforme si l’isolation est possible.
92. La promotion est une transition de contrat
Sur le plan conceptuel :
Bronze → Silver
signifie :
les données alignées sur la source ont satisfait aux règles de qualité canoniques
et :
Silver → Gold
signifie :
les données canoniques fiables ont satisfait à la validation consommateur/métier
93. Ne pas promouvoir en copiant aveuglément des fichiers
Le passage d’une couche à l’autre doit correspondre à une responsabilité de transformation/de validation.
Si Bronze et Silver restent identiques octet pour octet indéfiniment, demandez-vous si les deux couches apportent de la valeur.
94. Utiliser des vues lorsque la duplication physique est inutile
Une vue Gold logique sur une couche Silver fiable peut suffire pour certains consommateurs.
Ne matérialisez pas chaque couche/table s’il n’y a aucun bénéfice en performances ou en isolation.
95. Matérialiser lorsque cela apporte de la valeur
Raisons :
performances
isolation des consommateurs
instantané stable
sécurité
modèle simplifié
logique coûteuse répétée
La matérialisation doit résoudre un problème concret.
96. Ne pas confondre le nombre de dossiers avec la maturité de l’architecture
Ceci :
/bronze/
/silver/
/gold/
ne garantit pas :
- la capacité de rejeu
- la qualité
- les contrats
- l’observabilité
- l’idempotence
Ce sont les comportements d’ingénierie qui comptent.
97. Définir la propriété par couche et par jeu de données
Pour chaque table de production, sachez :
qui est propriétaire de l’ingestion ?
qui est propriétaire de la sémantique canonique ?
qui est propriétaire des définitions d’indicateurs pour les consommateurs ?
Une propriété floue produit des données obsolètes et contradictoires.
98. Garder un code modulaire par responsabilité
Séparation utile :
ingérer
valider
normaliser
dédupliquer
fusionner
agréger
rapprocher
publier
Cela facilite la réutilisation et les tests.
99. Tester explicitement le rejeu
Prenez un intervalle Bronze connu :
2026-10-01
reconstruisez Silver/Gold dans une cible de test et comparez avec les résultats attendus.
Ne supposez pas que le rejeu fonctionne parce que le code est « déterministe ».
100. Utiliser une liste de vérification d’architecture reproductible
Avant d’ajouter un jeu de données :
1. Quelle est la vérité de la source ?
2. Que doit préserver Bronze ?
3. Quel est le grain métier de Silver ?
4. Quelle règle de déduplication/de version s’applique ?
5. Quels contrôles qualité sont bloquants ?
6. Quelle politique de données tardives s’applique ?
7. Quel contrat consommateur Gold est nécessaire ?
8. Quel est le chemin de rejeu/de rechargement historique ?
9. Quelles sont les règles de rétention/de sécurité ?
10. Quels indicateurs prouvent que le jeu de données est sain ?
Interpréter le résultat
| Couche | Responsabilité principale | Mode d’écriture typique |
|---|---|---|
| Bronze | Préserver des données alignées sur la source et rejouables | Ajout / instantanés de la source |
| Silver | Produire des données canoniques fiables | MERGE, déduplication, normalisation, validation |
| Gold | Publier une sémantique prête pour les consommateurs | Agrégation, modélisation, restitution, reconstruction/incrémental |
L’idée centrale est :
Bronze
→ preuves
Silver
→ confiance
Gold
→ consommation
Points à vérifier
Bronze ne permet pas de reconstruire Silver
Vous ne préservez peut-être pas assez d’historique/de métadonnées de la source.
Silver contient des clés métier en double
Vérifiez les relances de la source, l’ordre de déduplication, la cardinalité des jointures et l’unicité des données en entrée du MERGE.
Gold ne concorde pas avec Silver
Vérifiez :
- le grain
- les filtres
- les jointures
- les règles de devise/de signe
- les lignes dupliquées/supprimées
- les données tardives
La logique Gold contient des particularités propres à la source
Silver n’est probablement pas assez canonique.
Chaque table source existe dans les trois couches sans aucune transformation
L’architecture est peut-être cérémonielle plutôt que fonctionnelle.
Les rechargements historiques interfèrent avec les jobs courants
Vérifiez le chevauchement, l’isolation des checkpoints, la concurrence d’écriture et le périmètre de la cible.
Notes de production
L’architecture Medallion est un modèle de responsabilités
Ne traitez pas Bronze/Silver/Gold comme des niveaux de stockage physiques obligatoires.
La capacité de rejeu est l’un des tests de conception les plus solides
Si un défaut est découvert, la plateforme doit disposer d’un moyen crédible de reconstruire les données fiables concernées.
La qualité se joue entre les couches
Le passage d’une couche à l’autre doit correspondre à des contrôles explicites, et pas simplement à l’exécution réussie d’un notebook.
La rétention et la sécurité varient selon la couche
La rétention des données sources brutes et l’accès à celles-ci peuvent devoir être bien plus stricts que pour Gold.
Gold est un produit de données
La stabilité de la sémantique, la fraîcheur, la propriété et la gestion des changements comptent autant que les performances des requêtes.
Une conception incrémentale doit rester récupérable
Les watermarks/checkpoints font partie de l’exactitude.
Traitez-les comme un état de production.
Erreurs fréquentes
1. Traiter Bronze comme un dépotoir non gouverné
Les données brutes ont toujours besoin d’un propriétaire, de métadonnées, d’une rétention et de sécurité.
2. Effectuer des transformations métier dans Bronze
Cela réduit la capacité de rejeu et la fidélité à la source.
3. Utiliser une déduplication arbitraire dans Silver
L’état canonique exige une version gagnante déterministe.
4. Laisser Gold contourner Silver de façon routinière
Cela crée une sémantique métier contradictoire.
5. Supposer que Gold doit être agrégée
Des tables Gold détaillées et prêtes pour les consommateurs peuvent être valables.
6. Copier chaque table dans les trois couches
Tous les jeux de données n’ont pas besoin de chaque couche.
7. Faire avancer les watermarks avant la réussite des contrôles qualité
Cela risque de faire sauter des données.
8. Ignorer les données arrivant en retard
Les corrections historiques dans Silver/Gold doivent être planifiées.
9. Utiliser les noms de couche comme mécanisme de sécurité
Des autorisations/politiques restent nécessaires.
10. N’avoir aucun chemin de rejeu/de rechargement historique
Tôt ou tard, des défauts ou des changements de logique nécessiteront une réparation historique.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.