Parcourir les aide-mémoire · Microsoft Fabric

Technologie: Microsoft FabricCatégorie: ArchitectureNiveau: IntermédiaireMis à jour

Architecture Medallion dans Fabric

Concevoir une architecture Bronze, Silver et Gold pragmatique dans Microsoft Fabric, avec des contrats de données clairs, la possibilité de rejouer les chargements, un traitement incrémental, des contrôles qualité et des responsabilités de restitution bien définies.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Garder Bronze alignée sur la source
  5. 2. Ajouter des métadonnées d’ingestion dans Bronze
  6. 3. Conserver les colonnes sources brutes lorsque la conversion peut échouer
  7. 4. Déplacer la normalisation du schéma dans Silver
  8. 5. Valider les clés obligatoires dans Silver
  9. 6. Mettre en quarantaine les enregistrements invalides au lieu d’effacer les preuves
  10. 7. Dédupliquer dans Silver avec des règles déterministes
  11. 8. Utiliser MERGE pour les entités Silver modifiables
  12. 9. Garder Bronze en ajout seul lorsque c’est possible
  13. 10. Utiliser Silver pour les entités canoniques réutilisables
  14. 11. Construire Gold à partir de Silver fiable, pas directement à partir des données brutes
  15. 12. Placer les indicateurs métier dans Gold
  16. 13. Rendre explicite le grain des tables Gold
  17. 14. Valider l’unicité dans Gold
  18. 15. Rapprocher les totaux entre Silver et Gold
  19. 16. Utiliser une ingestion Bronze incrémentale
  20. 17. Ne pas faire avancer le watermark avant que les données soient durables
  21. 18. Rendre le chargement incrémental de Silver idempotent
  22. 19. Propager la traçabilité opérationnelle à travers les couches
  23. 20. Séparer les métadonnées techniques des colonnes métier
  24. 21. Privilégier une conception Medallion centrée sur le Lakehouse pour les charges d’ingénierie
  25. 22. Utiliser un Warehouse pour Gold lorsqu’une restitution centrée sur SQL est nécessaire
  26. 23. Gold ne signifie pas uniquement agrégation
  27. 24. Ne pas mélanger nettoyage de la source et mise en forme pour le consommateur
  28. 25. Utiliser des shortcuts lorsque les données ne doivent pas être copiées
  29. 26. Garder une répartition claire des responsabilités par domaine
  30. 27. Organiser d’abord par domaine lorsque l’échelle augmente
  31. 28. Placer des contrôles qualité entre les couches
  32. 29. Enregistrer les indicateurs de qualité
  33. 30. Éviter de recalculer la même logique Silver coûteuse pour chaque consommateur Gold
  34. 31. Rendre les contrats de couche versionnables
  35. 32. Privilégier des schémas explicites pour les couches stables
  36. 33. Ne pas écraser toute la table à chaque actualisation de Silver
  37. 34. Recourir délibérément aux reconstructions complètes pour les petites tables Gold déterministes
  38. 35. Conserver l’historique lorsque le métier en a besoin
  39. 36. Prévoir les données arrivant en retard dans la conception
  40. 37. Retraiter depuis Bronze lorsque la logique de transformation change
  41. 38. Séparer le temps métier et le temps d’ingestion
  42. 39. Utiliser les tables Gold pour stabiliser les contrats avec les consommateurs
  43. 40. Documenter chaque couche à l’aide de quatre questions
  44. Interpréter le résultat
  45. Points à vérifier
  46. Bronze contient une logique métier lourde
  47. Les tables Silver diffèrent pour chaque rapport
  48. Gold contient encore des codes sources bruts et une logique de nettoyage
  49. Relancer un lot crée des doublons
  50. Les données ne peuvent pas être rejouées après un bogue
  51. Les totaux Gold ne concordent pas avec Silver
  52. De nombreux consommateurs nettoient chacun les mêmes champs
  53. Notes de production
  54. L’architecture Medallion est logique, elle n’impose pas de séparation physique
  55. La rétention dans Bronze a un coût
  56. Silver doit être le principal contrat d’ingénierie réutilisable
  57. Gold peut être implémentée dans un Lakehouse ou un Warehouse
  58. Le traitement incrémental doit être de bout en bout
  59. Les contrôles qualité doivent correspondre à la couche
  60. OneLake réduit le besoin de copies
  61. Erreurs fréquentes
  62. 1. Traiter Bronze comme une décharge sans métadonnées
  63. 2. Nettoyer les données de manière destructive dans Bronze
  64. 3. Utiliser dropDuplicates() sans décider quel enregistrement doit être conservé
  65. 4. Placer toute la logique métier directement dans Gold
  66. 5. Rendre Silver spécifique à un consommateur
  67. 6. Reconstruire entièrement chaque grande table à chaque exécution
  68. 7. Faire avancer le watermark avant que l’écriture soit durable
  69. 8. Ignorer les données arrivant en retard
  70. 9. Créer un Warehouse simplement parce que « Gold doit être un warehouse »
  71. 10. Créer trois couches sans réelle différence de contrat
  72. Étape suivante
  73. Pour aller plus loin

Problème

Vous devez organiser une plateforme de données Microsoft Fabric de sorte que l’ingestion brute, le nettoyage, la transformation métier et le reporting ne finissent pas en un seul notebook géant ou en une seule table fragile.

Une architecture Medallion répartit les responsabilités en couches :

Bronze
→ ingestion alignée sur la source et rejouable

Silver
→ données validées, standardisées et dédupliquées

Gold
→ modèles de restitution prêts pour le métier

La difficulté ne réside pas dans le nom des couches.

Les vraies questions de conception sont :

  • Qu’est-ce qui doit exactement aller dans chaque couche ?
  • Bronze doit-elle être modifiable ou alimentée uniquement par ajout ?
  • Où faut-il dédupliquer ?
  • Où doivent résider les règles métier ?
  • Quand Gold doit-elle être un Lakehouse plutôt qu’un Warehouse ?
  • Comment les chargements incrémentaux traversent-ils les couches ?
  • Où vont les échecs de qualité des données ?
  • Comment relancer un traitement en toute sécurité sans dupliquer les données ?
  • Comment éviter de répéter les mêmes transformations chez chaque consommateur ?

Réponse rapide

Utilisez ce modèle de responsabilités :

Bronze
- préserver la fidélité à la source
- ajouter ou déposer les données sources
- conserver les métadonnées d’ingestion
- rendre le rejeu possible

Silver
- standardiser le schéma
- convertir les types
- dédupliquer
- valider les clés
- appliquer les règles métier propres à la source
- créer des entités fiables et réutilisables

Gold
- mettre en forme les données pour la consommation
- agréger
- modéliser les indicateurs métier
- construire des faits/dimensions ou des tables de reporting organisées
- optimiser pour un usage BI/API/reporting

Un flux Fabric pragmatique :

  1. Systèmes sources
  2. Pipelines / shortcuts / notebooks
  3. Lakehouse Bronze
  4. Lakehouse Silver
  5. GoldLakehouse Gold ou Fabric Warehouse
  6. Modèles sémantiques / Power BI / API / rapports
Un flux Medallion pratique dans Fabric

Ne créez pas une couche simplement parce que le schéma d’architecture dit qu’elle devrait exister.

Chaque couche doit supprimer un type précis d’ambiguïté ou de risque opérationnel.

Code / commandes

1. Garder Bronze alignée sur la source

Exemple d’événement source :

{
  "sale_id": "10001",
  "merchant_id": "501",
  "sale_time": "2026-10-04T15:30:00Z",
  "amount": "125.50"
}

Une représentation Bronze doit préserver le sens de la source et ajouter des métadonnées d’ingestion, plutôt que de tout remodeler immédiatement en agrégats métier.

Exemple PySpark :

from pyspark.sql import functions as F

bronze = (
    source_df
    .withColumn(
        "_ingested_at_utc",
        F.current_timestamp(),
    )
    .withColumn(
        "_source_file",
        F.input_file_name(),
    )
    .withColumn(
        "_pipeline_run_id",
        F.lit(pipeline_run_id),
    )
)

Écriture :

(
    bronze.write
    .format("delta")
    .mode("append")
    .saveAsTable("bronze_sales")
)

Utilisez Bronze pour conserver suffisamment d’éléments afin de pouvoir retraiter les données plus tard.


2. Ajouter des métadonnées d’ingestion dans Bronze

Les métadonnées utiles peuvent inclure :

_ingested_at_utc
_pipeline_run_id
_batch_id
_source_file
_source_system
_source_modified_at

Exemple :

bronze = (
    source_df
    .withColumn(
        "_source_system",
        F.lit("transaction-api"),
    )
    .withColumn(
        "_batch_id",
        F.lit(batch_id),
    )
    .withColumn(
        "_ingested_at_utc",
        F.current_timestamp(),
    )
)

Cela facilite :

  • la traçabilité (lineage)
  • le rejeu
  • l’analyse des doublons
  • le rapprochement avec la source
  • l’analyse des incidents

N’ajoutez jamais d’identifiants de connexion ni de secrets dans les métadonnées.


3. Conserver les colonnes sources brutes lorsque la conversion peut échouer

Supposons que Bronze contienne :

amount = "$125.50"
sale_time = "10/04/2026 15:30"

Dans Silver, conservez la valeur d’origine tout en créant la valeur typée pendant la validation :

silver_stage = (
    bronze
    .withColumn(
        "amount_decimal",
        F.regexp_replace(
            F.col("amount"),
            r"[\$,]",
            "",
        ).cast("decimal(18,2)"),
    )
    .withColumn(
        "sale_timestamp",
        F.to_timestamp(
            "sale_time",
            "MM/dd/yyyy HH:mm",
        ),
    )
)

Ne détruisez pas la valeur source d’origine avant de savoir si la conversion a réussi.


4. Déplacer la normalisation du schéma dans Silver

Exemple :

silver = (
    bronze
    .select(
        F.col("sale_id").cast("long").alias("sale_id"),
        F.col("merchant_id").cast("int").alias("merchant_id"),
        F.to_timestamp("sale_time").alias("sale_time"),
        F.col("amount").cast("decimal(18,2)").alias("amount"),
        "_ingested_at_utc",
        "_pipeline_run_id",
    )
)

C’est dans Silver que les particularités propres à chaque source doivent devenir un contrat interne stable.


5. Valider les clés obligatoires dans Silver

Exemple :

invalid_keys = (
    silver
    .filter(
        F.col("sale_id").isNull()
        | F.col("merchant_id").isNull()
    )
)

Comptage :

invalid_count = invalid_keys.count()

Si les clés obligatoires doivent toujours être présentes :

if invalid_count > 0:
    raise RuntimeError(
        f"Silver validation failed: "
        f"{invalid_count} rows have missing required keys"
    )

Le choix entre faire échouer le traitement et mettre en quarantaine dépend du contrat de la source.

Ne supprimez pas silencieusement les enregistrements invalides sans en garder la trace.


6. Mettre en quarantaine les enregistrements invalides au lieu d’effacer les preuves

Exemple :

valid = (
    silver
    .filter(
        F.col("sale_id").isNotNull()
        & F.col("merchant_id").isNotNull()
    )
)

invalid = (
    silver
    .filter(
        F.col("sale_id").isNull()
        | F.col("merchant_id").isNull()
    )
)

Écrivez les lignes invalides séparément :

(
    invalid.write
    .format("delta")
    .mode("append")
    .saveAsTable("quarantine_sales")
)

Utilisez la quarantaine lorsque les lignes erronées doivent être analysées plutôt que supprimées en silence.


7. Dédupliquer dans Silver avec des règles déterministes

Exemple :

from pyspark.sql import Window

w = (
    Window
    .partitionBy("sale_id")
    .orderBy(
        F.col("source_updated_at").desc(),
        F.col("_ingested_at_utc").desc(),
    )
)

silver_deduped = (
    silver
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(
        F.col("_rn") == 1
    )
    .drop("_rn")
)

C’est préférable à :

dropDuplicates(["sale_id"])

lorsque la ligne conservée a de l’importance.

Définissez quelle ligne l’emporte.


8. Utiliser MERGE pour les entités Silver modifiables

Pour les entités métier susceptibles de changer :

from delta.tables import DeltaTable

target = DeltaTable.forName(
    spark,
    "silver_sales",
)

(
    target.alias("t")
    .merge(
        silver_deduped.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedUpdateAll()
    .whenNotMatchedInsertAll()
    .execute()
)

Utilisez MERGE lorsque des clés existantes peuvent recevoir des corrections ou des mises à jour ultérieures.

N’ajoutez pas aveuglément des entités modifiables.


9. Garder Bronze en ajout seul lorsque c’est possible

Un bon choix par défaut :

Bronze = historique de la source en ajout seul
Silver = rapprochement de l’état fiable actuel

Il devient alors plus facile de :

  • rejouer les transformations
  • analyser les défauts de la source
  • comparer l’ancienne et la nouvelle logique
  • réparer les couches en aval

Il existe des exceptions légitimes, mais modifier Bronze doit être une décision délibérée.


10. Utiliser Silver pour les entités canoniques réutilisables

Exemples de tables Silver :

silver_sales
silver_customers
silver_merchants
silver_products
silver_commissions

Ces tables doivent pouvoir être réutilisées par plusieurs consommateurs en aval.

Évitez la logique propre à un consommateur, par exemple :

mise en forme des tableaux de bord Power BI
libellés de rapports ponctuels
nommage de colonnes propre à une API

dans les tables Silver partagées, sauf si elle fait réellement partie de la définition métier de l’entreprise.


11. Construire Gold à partir de Silver fiable, pas directement à partir des données brutes

Exemple :

gold_daily_sales = (
    spark.table("silver_sales")
    .groupBy(
        "sale_date",
        "merchant_id",
    )
    .agg(
        F.sum("amount").alias("revenue"),
        F.countDistinct("sale_id").alias("sales"),
    )
)

Écriture :

(
    gold_daily_sales.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("gold_daily_sales")
)

Pour les grandes tables Gold, utilisez un modèle incrémental maîtrisé au lieu de les reconstruire systématiquement.


12. Placer les indicateurs métier dans Gold

Exemples :

chiffre d’affaires quotidien par marchand
valeur vie client
synthèse des commissions
clients actifs mensuels
indicateurs de conversion
faits et dimensions de reporting

Gold est l’endroit approprié pour définir une sémantique métier prête à l’emploi, qui doit rester cohérente d’un consommateur à l’autre.


13. Rendre explicite le grain des tables Gold

Pour chaque table Gold, documentez :

Une ligne représente :
marchand + date calendaire

ou :

Une ligne représente :
client + mois de reporting

Exemple :

gold_merchant_daily_sales
grain = merchant_id + sale_date

Cela évite les doubles comptages en aval.


14. Valider l’unicité dans Gold

Si le grain est :

merchant_id + sale_date

validez-le :

duplicates = (
    gold_daily_sales
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .count()
    .filter(
        F.col("count") > 1
    )
)

if duplicates.limit(1).count() > 0:
    raise RuntimeError(
        "Gold grain validation failed"
    )

Une table Gold doit garantir son grain logique par des contrôles opérationnels, même si la couche de stockage n’applique pas de contrainte d’unicité.


15. Rapprocher les totaux entre Silver et Gold

Exemple :

silver_total = (
    spark.table("silver_sales")
    .filter(
        F.col("sale_date") == "2026-10-04"
    )
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

gold_total = (
    spark.table("gold_daily_sales")
    .filter(
        F.col("sale_date") == "2026-10-04"
    )
    .agg(
        F.sum("revenue").alias("amount")
    )
    .first()["amount"]
)

Puis comparez :

if silver_total != gold_total:
    raise RuntimeError(
        "Silver-to-Gold reconciliation failed"
    )

Appliquez des tolérances lorsque l’arithmétique en virgule flottante ou des règles de transformation légitimes l’exigent.

Pour les données financières, privilégiez des types décimaux exacts lorsque c’est possible.


16. Utiliser une ingestion Bronze incrémentale

Exemple de modèle :

dernier watermark traité
→ enregistrements sources postérieurs au watermark
→ ajout dans Bronze
→ enregistrer le nouveau watermark uniquement après succès

Un watermark peut être :

source_modified_at
ID incrémental
séquence CDC
heure d’arrivée du fichier
ID de lot

Choisissez celui qui correspond à la sémantique de la source.


17. Ne pas faire avancer le watermark avant que les données soient durables

Mauvais ordre :

1. mettre à jour le watermark
2. écrire dans Bronze

Ordre plus sûr :

1. lire la source
2. écrire dans Bronze
3. valider l’écriture
4. mettre à jour le watermark

Sinon, une panne entre deux étapes peut faire sauter définitivement des données.


18. Rendre le chargement incrémental de Silver idempotent

Exemple :

Lot Bronze
→ dédupliquer la source
→ MERGE dans Silver par clé métier

Le même lot Bronze peut ainsi être retraité en toute sécurité.

Utilisez des clés métier stables et un ordre de mise à jour stable.


19. Propager la traçabilité opérationnelle à travers les couches

Exemples de colonnes :

_source_system
_batch_id
_pipeline_run_id
_ingested_at_utc
_source_updated_at

Vous n’avez pas besoin de toutes les métadonnées dans chaque table Gold.

Mais conservez suffisamment de traçabilité pour répondre à :

D’où vient cette ligne ?
Quel chargement l’a produite ?
Quel horodatage source l’a emporté ?

20. Séparer les métadonnées techniques des colonnes métier

Une convention claire aide :

Colonnes métier
sale_id
merchant_id
amount

Colonnes techniques
_ingested_at_utc
_batch_id
_pipeline_run_id

Les champs opérationnels deviennent ainsi évidents.

Appliquez une convention de nommage de manière cohérente.


21. Privilégier une conception Medallion centrée sur le Lakehouse pour les charges d’ingénierie

Une implémentation Fabric courante :

Lakehouse
  bronze_*
  silver_*
  gold_*

Utilisez-la lorsque :

  • Spark est le moteur principal
  • les tables Delta constituent le stockage principal
  • les équipes d’ingénierie sont responsables de la logique de transformation
  • Power BI peut consommer les données préparées du Lakehouse

C’est souvent suffisant, sans ajouter de Warehouse.


22. Utiliser un Warehouse pour Gold lorsqu’une restitution centrée sur SQL est nécessaire

Exemple :

Lakehouse Bronze
→ Lakehouse Silver
→ Fabric Warehouse Gold

Utilisez cette approche lorsque la couche de restitution a besoin :

  • du DML T-SQL complet
  • de procédures stockées
  • de modélisation dimensionnelle
  • d’une restitution relationnelle
  • de transactions SQL multitables

Ne copiez pas de données dans un Warehouse si la couche de restitution SQL n’apporte pas une valeur évidente.


23. Gold ne signifie pas uniquement agrégation

Une table Gold peut être :

table de faits
dimension
table de reporting large
entité métier
agrégat
jeu de données servi par API

La propriété qui la définit est :

sémantique métier prête pour les consommateurs

et pas simplement :

données agrégées

24. Ne pas mélanger nettoyage de la source et mise en forme pour le consommateur

Exemple :

Silver :
country_code = "US"

Gold/rapport :
country_display = "États-Unis"

Séparez la normalisation de la source et la présentation pour le consommateur lorsqu’elles répondent à des objectifs différents.

Cela réduit le couplage entre l’ingénierie des données et un rapport particulier.


25. Utiliser des shortcuts lorsque les données ne doivent pas être copiées

Si des données externes ou d’un autre domaine existent déjà et ne nécessitent pas de duplication physique :

Emplacement source
→ OneLake shortcut
→ consommateur Bronze/Silver

Utilisez des shortcuts lorsque :

  • la propriété des données reste ailleurs
  • la fraîcheur doit rester liée à la source
  • dupliquer les données apporte peu de valeur

N’utilisez pas de shortcut à l’aveugle lorsque vous avez besoin :

  • d’instantanés stables
  • d’isolation par rapport à la source
  • d’une rétention maîtrisée
  • d’un rejeu reproductible

26. Garder une répartition claire des responsabilités par domaine

Exemple :

Domaine Ventes
- bronze_sales
- silver_sales
- gold_sales_daily

Domaine Clients
- bronze_customers
- silver_customers
- gold_customer_360

Évitez un espace de travail ou un espace de noms de tables géant où personne ne sait à qui appartient un jeu de données.

Les couches Medallion ne remplacent pas la propriété par domaine.


27. Organiser d’abord par domaine lorsque l’échelle augmente

Un modèle évolutif peut être :

Lakehouse Ventes
  Bronze
  Silver
  Gold

Lakehouse Commissions
  Bronze
  Silver
  Gold

au lieu de :

Un Lakehouse Bronze d’entreprise
Un Lakehouse Silver d’entreprise
Un Lakehouse Gold d’entreprise

Les deux approches peuvent fonctionner.

Choisissez en fonction :

  • des frontières entre équipes
  • de la sécurité
  • du déploiement
  • de la propriété des données
  • de l’isolation des charges de travail

N’imposez pas une topologie unique à toutes les organisations.


28. Placer des contrôles qualité entre les couches

Exemples de contrôles Bronze → Silver :

champs obligatoires présents
schéma analysable
clé métier valide
horodatage valide
règles de doublons de la source appliquées

Exemples de contrôles Silver → Gold :

unicité du grain
rapprochement des indicateurs
jointures de référence valides
aucune clé orpheline là où c’est interdit
couverture des dates de reporting

Ne promouvez les données que lorsque le contrat de la couche est respecté.


29. Enregistrer les indicateurs de qualité

Exemple :

metrics = {
    "rows_in": bronze.count(),
    "rows_valid": valid.count(),
    "rows_invalid": invalid.count(),
}

Pour les gros volumes, évitez de déclencher inutilement plusieurs analyses coûteuses.

Privilégiez une seule passe de qualité agrégée lorsque c’est possible.

Les indicateurs opérationnels doivent inclure :

lignes lues
lignes écrites
lignes rejetées
clés en double
clés obligatoires nulles
ID de lot
ID d’exécution

30. Éviter de recalculer la même logique Silver coûteuse pour chaque consommateur Gold

Mauvais :

Rapport Gold A
→ analyser les données brutes
→ dédupliquer
→ normaliser

Rapport Gold B
→ analyser les données brutes
→ dédupliquer
→ normaliser

Mieux :

Bronze
→ Silver partagée
   ├→ Rapport Gold A
   └→ Rapport Gold B

Silver doit éliminer la répétition de la logique de transformation au niveau de la source.


31. Rendre les contrats de couche versionnables

Si Silver change :

customer_id int
→ customer_id string

cela peut casser les consommateurs Gold en aval.

Traitez les changements de schéma importants comme des contrats.

Utilisez :

  • un déploiement versionné
  • des contrôles de compatibilité
  • une validation du schéma
  • des modifications coordonnées en aval

Ne laissez pas une évolution de schéma non maîtrisée tenir lieu d’architecture.


32. Privilégier des schémas explicites pour les couches stables

Exemple :

from pyspark.sql.types import (
    StructType,
    StructField,
    LongType,
    IntegerType,
    DecimalType,
    TimestampType,
)

sales_schema = StructType([
    StructField("sale_id", LongType(), False),
    StructField("merchant_id", IntegerType(), False),
    StructField("amount", DecimalType(18, 2), False),
    StructField("sale_time", TimestampType(), False),
])

Les schémas explicites sont particulièrement utiles aux frontières d’ingestion dont les contrats sont connus.


33. Ne pas écraser toute la table à chaque actualisation de Silver

Pour les grandes tables modifiables, préférez :

source incrémentale
→ dédupliquer
→ MERGE dans Silver

à :

lire tout l’historique Bronze
→ reconstruire toute la couche Silver
→ écraser

Les reconstructions complètes peuvent servir pour les rechargements historiques (backfills) ou les petites tables, mais ne doivent pas être la norme si un état incrémental est réalisable.


34. Recourir délibérément aux reconstructions complètes pour les petites tables Gold déterministes

Exemple :

(
    gold_dimension.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("gold_dim_date")
)

Une reconstruction complète est raisonnable lorsque :

  • la table est petite
  • la logique est déterministe
  • le coût est faible
  • un remplacement atomique est acceptable sur le plan opérationnel

Toutes les tables n’ont pas besoin de la complexité de l’incrémental.


35. Conserver l’historique lorsque le métier en a besoin

Pour les entités qui évoluent, comme les attributs client, décidez si Silver représente :

état actuel uniquement

ou :

versions historiques

N’écrasez pas l’historique par accident si le métier exige des dimensions à évolution lente ou une auditabilité.

Ce choix a un impact sur :

  • le modèle Silver
  • les dimensions Gold
  • la logique de fusion (merge)
  • les dates d’effet

36. Prévoir les données arrivant en retard dans la conception

Exemple :

sale_date = 2026-10-01
arrivée = 2026-10-04

Si Gold est partitionnée ou agrégée par date métier, le pipeline doit pouvoir mettre à jour les périodes antérieures.

Ne partez pas du principe que :

l’ingestion du jour n’affecte que la Gold du jour

Utilisez explicitement les horodatages métier et des règles de gestion des arrivées tardives.


37. Retraiter depuis Bronze lorsque la logique de transformation change

L’un des principaux avantages de la rétention dans Bronze est le rejeu.

Exemple :

Bug dans la normalisation Silver
→ corriger la logique
→ rejouer la plage de dates Bronze concernée
→ reconstruire/MERGE Silver
→ reconstruire la Gold concernée

C’est bien plus sûr que d’essayer de reconstituer les valeurs sources d’origine à partir de données Gold déjà transformées.


38. Séparer le temps métier et le temps d’ingestion

Exemple :

sale_time
→ moment où l’événement métier s’est produit

_ingested_at_utc
→ moment où Fabric l’a reçu

Les deux peuvent compter.

Ne remplacez pas l’un par l’autre.

Cette distinction est importante pour :

  • les arrivées tardives
  • la supervision des SLA
  • le rejeu
  • l’analyse de la latence des sources

39. Utiliser les tables Gold pour stabiliser les contrats avec les consommateurs

Un rapport ne devrait pas avoir à comprendre :

codes sources bruts
comportement des doublons de la source
séquencement CDC
horodatages propres à la source
colonnes de staging temporaires

Gold doit exposer une signification métier stable.

Cela réduit la duplication et le couplage en aval.


40. Documenter chaque couche à l’aide de quatre questions

Pour chaque table, documentez :

1. Que représente une ligne ?
2. Quelle est la clé métier ?
3. Comment la table est-elle chargée ?
4. Quelles règles de qualité doivent être respectées ?

Exemple :

Table :
silver_sales

Grain :
une ligne par sale_id

Clé métier :
sale_id

Chargement :
MERGE incrémental

Qualité :
sale_id non nul
merchant_id non nul
amount >= 0 lorsque les règles métier l’exigent
la dernière mise à jour de la source l’emporte

C’est plus utile qu’un schéma qui se contente d’indiquer Bronze / Silver / Gold.

Interpréter le résultat

Couche Responsabilité principale
Bronze Préserver les données sources et la possibilité de rejouer
Silver Standardiser, valider, dédupliquer et produire des données fiables et réutilisables
Gold Exposer une sémantique métier prête pour les consommateurs
Quarantaine Conserver les enregistrements invalides ou rejetés pour analyse
Gold dans un Warehouse Restitution relationnelle centrée sur SQL, si nécessaire
Gold dans un Lakehouse Restitution orientée Delta, Spark et Direct Lake

La distinction la plus importante est :

Bronze = vérité de la source
Silver = vérité opérationnelle fiable
Gold = vérité du consommateur

Il s’agit d’un principe de conception, pas d’une règle universelle imposée par le produit.

Points à vérifier

Bronze contient une logique métier lourde

La couche brute en fait probablement trop.

Demandez-vous si ces transformations ont leur place dans Silver.

Les tables Silver diffèrent pour chaque rapport

Silver est probablement trop spécifique aux consommateurs.

Déplacez la logique canonique réutilisable dans des entités Silver partagées.

Gold contient encore des codes sources bruts et une logique de nettoyage

Gold n’est probablement pas prête pour les consommateurs.

Remontez la normalisation de la source vers l’amont.

Relancer un lot crée des doublons

Le chemin incrémental n’est pas idempotent.

Vérifiez :

  • le comportement en ajout
  • la clé métier
  • l’identifiant de lot
  • la logique de fusion
  • la gestion du watermark

Les données ne peuvent pas être rejouées après un bogue

La rétention ou la traçabilité de Bronze est insuffisante.

Conservez des données alignées sur la source et les métadonnées d’exécution.

Les totaux Gold ne concordent pas avec Silver

Vérifiez :

  • la cardinalité des jointures
  • les doublons de grain
  • les données arrivées en retard
  • les filtres
  • les jointures avec les dimensions
  • la logique d’agrégation

De nombreux consommateurs nettoient chacun les mêmes champs

Il manque à Silver un contrat canonique réutilisable.

Notes de production

L’architecture Medallion est logique, elle n’impose pas de séparation physique

Bronze, Silver et Gold peuvent résider dans :

  • un seul Lakehouse
  • plusieurs Lakehouses
  • des espaces de travail distincts
  • une combinaison de Lakehouse et de Warehouse

Choisissez la séparation physique en fonction :

  • de la sécurité
  • de la propriété des données
  • du déploiement
  • de l’isolation des charges de travail
  • de l’échelle opérationnelle

N’assimilez pas une couche à un élément Fabric obligatoire.

La rétention dans Bronze a un coût

Conserver tout l’historique brut améliore la capacité de rejeu, mais consomme du stockage.

Définissez la rétention en fonction :

  • de la possibilité de relire la source
  • de la conformité
  • des besoins d’audit
  • de la stratégie de reprise
  • du coût du stockage

Silver doit être le principal contrat d’ingénierie réutilisable

Si chaque consommateur contourne Silver et lit directement Bronze, l’architecture perd l’essentiel de sa valeur.

Restreignez ou découragez la consommation de Bronze lorsque c’est pertinent.

Gold peut être implémentée dans un Lakehouse ou un Warehouse

Choisissez en fonction des besoins de restitution.

Utilisez Gold dans un Lakehouse lorsque :

  • Delta, Spark et Direct Lake conviennent
  • la sémantique d’écriture T-SQL complète n’est pas nécessaire

Utilisez Gold dans un Warehouse lorsque :

  • une restitution relationnelle centrée sur SQL est importante
  • des procédures stockées ou des transactions SQL multitables sont nécessaires

Le traitement incrémental doit être de bout en bout

Il ne suffit pas que seule Bronze soit incrémentale.

Réfléchissez à l’ensemble du parcours :

Source → Bronze → Silver → Gold

Chaque couche doit définir comment les relances, les données tardives et les corrections se propagent.

Les contrôles qualité doivent correspondre à la couche

Bronze peut tolérer des valeurs mal formées afin de préserver les preuves.

Silver doit appliquer une validité structurelle et des clés métier plus strictes.

Gold doit garantir le grain attendu par les consommateurs et la cohérence des indicateurs.

OneLake réduit le besoin de copies

Utilisez des shortcuts et des modèles de stockage partagé lorsqu’ils sont compatibles avec le modèle de propriété.

Ne copiez des données que lorsque la couche cible a besoin :

  • d’un cycle de vie indépendant
  • d’une isolation du schéma
  • d’une organisation physique adaptée aux performances
  • d’une frontière de reprise
  • d’une frontière de propriété

Erreurs fréquentes

1. Traiter Bronze comme une décharge sans métadonnées

Sans métadonnées de source et d’exécution, le rejeu et l’analyse des incidents deviennent difficiles.

2. Nettoyer les données de manière destructive dans Bronze

Vous risquez de perdre les éléments nécessaires pour comprendre plus tard les défauts de la source.

3. Utiliser dropDuplicates() sans décider quel enregistrement doit être conservé

La déduplication doit être déterministe.

4. Placer toute la logique métier directement dans Gold

Chaque consommateur en aval dépend alors d’un seul grand chemin de transformation, et la réutilisation devient plus difficile.

5. Rendre Silver spécifique à un consommateur

Silver doit représenter des entités fiables et réutilisables, pas la présentation exacte d’un rapport.

6. Reconstruire entièrement chaque grande table à chaque exécution

Utilisez des modèles incrémentaux lorsque la source et les clés métier le permettent.

7. Faire avancer le watermark avant que l’écriture soit durable

Cela peut créer des trous définitifs dans les données après une panne.

8. Ignorer les données arrivant en retard

Les agrégats par date métier peuvent devoir mettre à jour des périodes passées.

9. Créer un Warehouse simplement parce que « Gold doit être un warehouse »

Gold peut rester dans un Lakehouse si cela répond bien aux besoins des consommateurs.

10. Créer trois couches sans réelle différence de contrat

Renommer des tables :

bronze_x
silver_x
gold_x

ne crée pas, à lui seul, une architecture.

Chaque couche doit avoir une responsabilité distincte.

Étape suivante

Partez de la question de conception pour choisir l’action suivante.

  • Besoin de pouvoir rejouer les données brutes → gardez Bronze alignée sur la source, avec des métadonnées d’ingestion.
  • Les données sources sont désordonnées → normalisez et validez dans Silver.
  • Des clés sources en double existent → définissez une déduplication Silver déterministe.
  • Les entités existantes peuvent changer → utilisez un MERGE incrémental dans Silver.
  • Les consommateurs ont besoin d’indicateurs stables → définissez explicitement le grain et la sémantique métier de Gold.
  • Gold nécessite une restitution T-SQL complète → envisagez un Fabric Warehouse.
  • Gold sert principalement Delta, Power BI et Direct Lake → Gold dans un Lakehouse peut suffire.
  • Les relances créent des doublons → concevez l’idempotence à travers toutes les couches.
  • Des données tardives modifient des périodes passées → définissez le comportement de rechargement et de mise à jour.
  • Un bogue de transformation apparaît → rejouez la plage concernée depuis Bronze et reconstruisez les couches en aval.

← Tous les aide-mémoire