Parcourir les aide-mémoire · Ingénierie des données

Technologie: Ingénierie des donnéesCatégorie: ArchitectureNiveau: IntermédiaireMis à jour

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
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Bronze : préserver la fidélité à la source
  5. 2. Bronze : conserver le payload brut lorsque le parsing peut évoluer
  6. 3. Bronze : capturer l’identité de la source
  7. 4. Bronze : ne pas écraser à la légère les preuves de la source
  8. 5. Bronze : mettre en quarantaine séparément les entrées mal formées
  9. 6. Silver : définir d’abord le grain canonique
  10. 7. Silver : imposer les clés obligatoires
  11. 8. Silver : normaliser les types
  12. 9. Silver : dédupliquer de manière déterministe
  13. 10. Ne pas utiliser un dropDuplicates() arbitraire pour la déduplication métier
  14. 11. Silver : valider l’unicité de la source avant le MERGE
  15. 12. Silver : utiliser MERGE pour les entités modifiables
  16. 13. Silver : ne mettre à jour qu’avec des versions plus récentes si nécessaire
  17. 14. Silver : garder explicite la logique des arrivées tardives
  18. 15. Silver : utiliser les données de référence avec prudence
  19. 16. Silver : distinguer une référence manquante d’une référence invalide
  20. 17. Silver : créer des champs métier canoniques
  21. 18. Silver : garder une signification métier stable
  22. 19. Gold : modéliser pour un cas d’usage consommateur
  23. 20. Gold : définir explicitement le grain de sortie
  24. 21. Gold : rapprocher les totaux
  25. 22. Gold peut être détaillée, pas seulement agrégée
  26. 23. Gold peut être un modèle de warehouse
  27. 24. Gold peut rester dans le Lakehouse
  28. 25. Ne pas imposer un système physique distinct pour chaque couche
  29. 26. Bronze doit généralement être rejouable
  30. 27. Préserver les versions de la source si nécessaire
  31. 28. Silver doit être reproductible
  32. 29. Versionner les données de référence critiques
  33. 30. Gold doit avoir un contrat consommateur
  34. 31. Utiliser des contrôles qualité entre les couches
  35. 32. Ajouter des métadonnées d’exécution
  36. 33. Le watermark ne doit avancer qu’après un travail durable réussi
  37. 34. L’ingestion Bronze peut être en ajout seul
  38. 35. Silver n’a pas à être en ajout seul
  39. 36. Gold peut être reconstruite ou maintenue de façon incrémentale
  40. 37. Ne pas rendre chaque couche incrémentale simplement parce que la source l’est
  41. 38. Un rechargement historique doit avoir des bornes explicites
  42. 39. Les rechargements historiques et le traitement courant doivent coexister en toute sécurité
  43. 40. Séparer le checkpoint du traitement courant de l’état des rechargements historiques
  44. 41. Le streaming s’intègre à l’architecture Medallion
  45. 42. Le batch s’intègre à la même architecture
  46. 43. L’hybride est normal
  47. 44. Ne pas dupliquer la logique de transformation entre les chemins batch et streaming
  48. 45. Utiliser des noms Bronze alignés sur la source
  49. 46. Utiliser des noms Silver canoniques
  50. 47. Utiliser des noms Gold orientés consommateurs
  51. 48. Ne pas copier chaque table source dans les trois couches
  52. 49. Tous les jeux de données n’ont pas besoin des trois couches
  53. 50. Bronze peut conserver la dérive de schéma de la source
  54. 51. Silver doit échouer ou mettre en quarantaine en cas de changement de schéma cassant
  55. 52. Attribuer des identifiants stables aux règles de qualité des données
  56. 53. Garder la quarantaine hors des tables fiables
  57. 54. La quarantaine a besoin de métadonnées de correction
  58. 55. Silver peut préserver la traçabilité vers la source rejetée
  59. 56. Gold ne doit pas contourner Silver à la légère
  60. 57. Éviter la logique consommateur dans Bronze
  61. 58. Éviter que les particularités de la source ne se propagent dans Gold
  62. 59. Centraliser les indicateurs métier
  63. 60. Gold peut comporter plusieurs modèles consommateurs
  64. 61. Éviter une table « Gold d’entreprise » géante
  65. 62. Utiliser la modélisation dimensionnelle lorsque c’est pertinent
  66. 63. Gold peut servir des API
  67. 64. Précalculer la logique de reporting coûteuse lorsque c’est utile
  68. 65. Ne pas précalculer toutes les requêtes possibles
  69. 66. La fraîcheur de Gold doit être explicite
  70. 67. La traçabilité des données doit traverser les couches
  71. 68. Utiliser des clés métier stables
  72. 69. La logique SCD a sa place là où l’historique canonique est défini
  73. 70. Séparer l’historique des événements des entités d’état actuel
  74. 71. Stocker séparément le temps métier et le temps d’ingestion
  75. 72. La politique de données tardives doit être propre à chaque couche
  76. 73. Les corrections Gold doivent être déterministes
  77. 74. Le partitionnement peut différer selon la couche
  78. 75. Éviter le surpartitionnement de Bronze
  79. 76. Éviter le surpartitionnement de Silver/Gold
  80. 77. Compacter les petits fichiers si nécessaire
  81. 78. L’évolution du schéma doit être gouvernée par couche
  82. 79. Les changements cassants nécessitent un versionnement/une migration
  83. 80. Utiliser des contrats de table pour Gold
  84. 81. La rétention de Bronze doit correspondre aux besoins de rejeu
  85. 82. La rétention de Silver peut être différente
  86. 83. La rétention de Gold suit les besoins des consommateurs/les obligations légales
  87. 84. La sécurité peut différer selon la couche
  88. 85. Ne pas utiliser les noms de couche comme contrôles de sécurité
  89. 86. Masquer/tokeniser lorsque le modèle fiable l’exige
  90. 87. Éviter de stocker des secrets dans Bronze sauf si c’est nécessaire
  91. 88. Ne pas laisser Bronze devenir un stockage permanent de rebuts
  92. 89. Superviser chaque couche différemment
  93. 90. Utiliser des critères de réussite propres à chaque couche
  94. 91. Éviter les réactions en chaîne provoquées par un seul lot source défectueux
  95. 92. La promotion est une transition de contrat
  96. 93. Ne pas promouvoir en copiant aveuglément des fichiers
  97. 94. Utiliser des vues lorsque la duplication physique est inutile
  98. 95. Matérialiser lorsque cela apporte de la valeur
  99. 96. Ne pas confondre le nombre de dossiers avec la maturité de l’architecture
  100. 97. Définir la propriété par couche et par jeu de données
  101. 98. Garder un code modulaire par responsabilité
  102. 99. Tester explicitement le rejeu
  103. 100. Utiliser une liste de vérification d’architecture reproductible
  104. Interpréter le résultat
  105. Points à vérifier
  106. Bronze ne permet pas de reconstruire Silver
  107. Silver contient des clés métier en double
  108. Gold ne concorde pas avec Silver
  109. La logique Gold contient des particularités propres à la source
  110. Chaque table source existe dans les trois couches sans aucune transformation
  111. Les rechargements historiques interfèrent avec les jobs courants
  112. Notes de production
  113. L’architecture Medallion est un modèle de responsabilités
  114. La capacité de rejeu est l’un des tests de conception les plus solides
  115. La qualité se joue entre les couches
  116. La rétention et la sécurité varient selon la couche
  117. Gold est un produit de données
  118. Une conception incrémentale doit rester récupérable
  119. Erreurs fréquentes
  120. 1. Traiter Bronze comme un dépotoir non gouverné
  121. 2. Effectuer des transformations métier dans Bronze
  122. 3. Utiliser une déduplication arbitraire dans Silver
  123. 4. Laisser Gold contourner Silver de façon routinière
  124. 5. Supposer que Gold doit être agrégée
  125. 6. Copier chaque table dans les trois couches
  126. 7. Faire avancer les watermarks avant la réussite des contrôles qualité
  127. 8. Ignorer les données arrivant en retard
  128. 9. Utiliser les noms de couche comme mécanisme de sécurité
  129. 10. N’avoir aucun chemin de rejeu/de rechargement historique
  130. Étape suivante
  131. 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.

Étape suivante

Partez du symptôme observé dans la couche pour choisir l’action suivante.

  • Besoin de rejeu/d’audit des données brutes → renforcez la fidélité à la source et les métadonnées de Bronze.
  • Silver contient des doublons → corrigez le grain, l’ordre de déduplication ou la cardinalité des jointures.
  • Le schéma Silver dérive sans cesse → définissez des règles de compatibilité gouvernées.
  • Gold ne concorde pas → comparez le grain et les totaux métier avec Silver.
  • Les consommateurs ont besoin d’une latence plus faible → modifiez la cadence d’exécution, pas les responsabilités des couches.
  • Les rechargements historiques entrent en conflit avec le traitement courant → isolez l’état/les checkpoints et les périmètres cibles.
  • Gold sert la BI/le reporting → évaluez un Warehouse/une modélisation dimensionnelle lorsque c’est utile.
  • Gold sert Spark/la data science → le Lakehouse peut rester la bonne surface.
  • Chaque couche semble redondante → supprimez les copies physiques inutiles tout en conservant les frontières de responsabilité.
  • Besoin de détails de mise en œuvre → passez à Modèles de lecture et d’écriture Delta Lake ou à Modèles de chargement incrémental.

← Tous les aide-mémoire