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