Lab 01
Analyse des ventes de bout en bout dans Microsoft Fabric
Construisez une solution d’analyse Microsoft Fabric complète : espace de travail et Lakehouse, transformations Bronze, Silver et Gold, puis orchestration par pipeline.
- Statut
- Disponible
- Niveau
- Intermédiaire
- Mis à jour
Objectif: Construire une solution d’analyse fonctionnelle, des fichiers bruts jusqu’à une couche Gold orchestrée.
Ce que vous aurez à la fin
- Un espace de travail Fabric et un Lakehouse
- Des fichiers CSV bruts déposés dans OneLake
- Des tables Delta Bronze, Silver et Gold construites avec des notebooks PySpark
- Un pipeline Fabric qui exécute les trois notebooks dans l’ordre
Avant de commencer
- Un accès à Microsoft Fabric : une version d’évaluation ou une capacité Fabric
- Des bases en Python ; une expérience de PySpark aide mais n’est pas indispensable
- Les cinq fichiers CSV d’exemple (clients, produits, commandes d’achat, commandes de vente, lignes de commande)
- Espace de travail
- Lakehouse
- PySpark
- Delta Lake
- Architecture médaillon
- Pipeline Fabric
Ce lab construit une solution d’analyse petite mais complète dans Microsoft Fabric. Chaque capture d’écran provient d’une vraie réalisation du projet et chaque nom d’objet est celui utilisé lors de cette réalisation : vous pouvez donc reproduire le tout dans votre propre locataire et comparer.
Le lab reste volontairement compact : un espace de travail, un Lakehouse, trois notebooks et un pipeline. Les modèles sémantiques, les rapports Power BI, le journal d’exécution et le déploiement avec Git viendront dans les labs suivants.
Ce que vous allez construire
Les fichiers CSV bruts arrivent dans le Lakehouse, trois notebooks les affinent couche par couche, et un pipeline exécute les notebooks dans l’ordre.
- 1Espace de travailws_demo
- 2Lakehousedemo
- 3Fichiers CSV brutsFiles/raw
- 4Tables Delta Bronzenb_02_bronze_ingestion
- 5Données Silver nettoyéesnb_03_silver_transformations
- 6Qualité des données et dépannageInspecter, corriger, relancer, vérifier
- 7Couche Gold de reportingnb_04_gold_model
- 8Orchestration par pipeline Fabricpl_sales_analytics
Les noms utilisés tout au long du lab :
| Objet | Nom |
|---|---|
| Espace de travail | ws_demo |
| Lakehouse | demo |
| Dossier d’atterrissage | Files/raw |
| Notebook Bronze | nb_02_bronze_ingestion |
| Notebook Silver | nb_03_silver_transformations |
| Notebook Gold | nb_04_gold_model |
| Pipeline | pl_sales_analytics |
Étape 1 — Créer l’espace de travail
Un espace de travail contient tout ce que ce lab produit : le Lakehouse, les notebooks et le pipeline. Créez-en un nommé ws_demo. Le tutoriel complet sur l’espace de travail détaille chaque paramètre ; ici, seul l’essentiel compte.
(ouvrir la capture en taille réelle)Un espace de travail vide s’ouvre sur sa page d’accueil. La liste d’éléments du bas se remplit à mesure que vous créez le Lakehouse, les notebooks et le pipeline dans les étapes suivantes.
(ouvrir la capture en taille réelle)Le type d’espace de travail détermine la capacité qui exécute le travail. Les éléments Fabric comme les Lakehouses, les notebooks et les pipelines exigent un type d’espace Fabric ; cette réalisation utilise Fabric Trial.
(ouvrir la capture en taille réelle)Manage access contrôle qui peut ouvrir et modifier l’espace de travail. Pour un lab personnel, vous pouvez rester le seul Admin ; en équipe, donnez à chacun le rôle le plus restreint dont il a besoin.
(ouvrir la capture en taille réelle)Enfin, regardez Workspace settings › Git integration. Vous ne connectez pas Git dans ce lab, mais savoir que l’espace est prêt pour Git comptera plus tard : le Lab 06 place cette solution sous contrôle de version. Pour prendre de l’avance, voyez comment connecter Fabric à Git.
(ouvrir la capture en taille réelle)Étape 2 — Créer le Lakehouse
Dans ws_demo, sélectionnez New item, cherchez Lakehouse et créez-en un nommé demo. Un Lakehouse stocke les données dans OneLake et comporte deux zones :
- Tables : des tables Delta gérées, lisibles par Spark, SQL et Power BI.
- Files : les fichiers de votre choix, dans les dossiers de votre choix. Les données brutes arrivent ici.
(ouvrir la capture en taille réelle)
(ouvrir la capture en taille réelle)Fabric crée aussi un point de terminaison SQL analytics pour chaque Lakehouse. Il expose les tables Delta en T-SQL, en lecture seule, ce qui permet de vérifier des résultats sans ouvrir Spark.
(ouvrir la capture en taille réelle)Les notebooks travaillent sur un Lakehouse attaché : spark.table("nom") et saveAsTable("nom") pointent vers sa zone Tables. Attachez demo à chaque notebook de ce lab.
(ouvrir la capture en taille réelle)Les tables demo_customers et demo_sales visibles sur ces captures viennent du tutoriel sur les notebooks Microsoft Fabric. Si vous ne l’avez pas suivi, vous ne les avez pas encore ; l’étape 7 explique où demo_sales sert. Pour aller plus loin sur la conception d’un Lakehouse, voyez créer votre premier Lakehouse Fabric.
Étape 3 — Charger les données brutes
Le projet utilise cinq fichiers CSV :
customers.csvproducts.csvpurchase_orders.csvsales_orders.csvsales_order_lines.csv
Créez un dossier raw sous Files, ouvrez son menu … et choisissez Upload › Upload files.
(ouvrir la capture en taille réelle)Files/raw est la zone d’atterrissage. Les fichiers y arrivent inchangés, tels que la source les a produits, et rien en aval ne les modifie. Si une transformation échoue, vous pouvez toujours tout reconstruire à partir de ce qui a atterri.
(ouvrir la capture en taille réelle)Ouvrez customers.csv pour vérifier ce qui est arrivé. L’en-tête montre deux colonnes distinctes, first_name et last_name ; retenez-le, car cela compte à l’étape 5.
(ouvrir la capture en taille réelle)Les données d’exemple sont synthétiques : les noms sont générés et toutes les adresses e-mail utilisent le domaine réservé example.com.
Étape 4 — Construire la couche Bronze
Créez un notebook nommé nb_02_bronze_ingestion dans ws_demo et attachez le Lakehouse demo.
(ouvrir la capture en taille réelle)Bronze est une copie fidèle de la source au format Delta, avec deux colonnes qui indiquent d’où vient chaque ligne et quand elle est arrivée :
from pyspark.sql import functions as F
customers_df = (
spark.read
.option("header", True)
.option("inferSchema", True)
.csv("Files/raw/customers.csv")
.withColumn("_source_file", F.input_file_name())
.withColumn("_ingested_at", F.current_timestamp())
)
(ouvrir la capture en taille réelle)Écrivez ensuite le DataFrame dans une table Delta :
(
customers_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("bronze_customers")
)
(ouvrir la capture en taille réelle)Actualisez Tables : bronze_customers apparaît avec les colonnes d’origine plus _source_file et _ingested_at.
(ouvrir la capture en taille réelle)Dans cette version du lab, Bronze n’ingère que customers.csv, pour que chaque étape reste visible de bout en bout. Les quatre autres fichiers sont déposés dans Files/raw mais pas encore chargés ; répéter les deux mêmes cellules pour eux est un bon exercice. Le guide Bronze, Silver, Gold explique ce qui relève de chaque couche.
Étape 5 — Construire la couche Silver
Créez nb_03_silver_transformations et attachez demo. Silver transforme Bronze en données propres, cohérentes et parlantes pour le métier :
- Dédoublonnage : une ligne par
customer_id. - Suppression des espaces : pas d’espaces parasites autour des noms, villes ou segments.
- Standardisation : e-mails en minuscules, codes d’état et de pays en majuscules.
- Colonnes métier : une seule colonne
customer_nameconstruite à partir defirst_nameetlast_name.
(ouvrir la capture en taille réelle)from pyspark.sql import functions as F
bronze_customers_df = spark.table("bronze_customers")
silver_customers_df = (
bronze_customers_df
.dropDuplicates(["customer_id"])
# Clean first and last name
.withColumn("first_name", F.trim(F.col("first_name")))
.withColumn("last_name", F.trim(F.col("last_name")))
# Create a business-friendly full name
.withColumn(
"customer_name",
F.concat_ws(
" ",
F.col("first_name"),
F.col("last_name")
)
)
# Standardize text fields
.withColumn("email", F.lower(F.trim(F.col("email"))))
.withColumn("city", F.trim(F.col("city")))
.withColumn("state", F.upper(F.trim(F.col("state"))))
.withColumn("country", F.upper(F.trim(F.col("country"))))
.withColumn("segment", F.trim(F.col("segment")))
)
display(silver_customers_df)
(ouvrir la capture en taille réelle)display() affiche 50 lignes et 13 colonnes : les dix colonnes sources, les deux colonnes d’ingestion et la nouvelle customer_name. Écrivez le résultat en Delta :
(
silver_customers_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("silver_customers")
)
(ouvrir la capture en taille réelle)Étape 6 — Qualité des données et dépannage
La première tentative Silver nettoyait une colonne qui n’a jamais existé dans la source :
silver_customers_df = (
spark.table("bronze_customers")
.dropDuplicates(["customer_id"])
.withColumn(
"customer_name",
F.trim(F.col("customer_name"))
)
.withColumn(
"country",
F.upper(F.trim(F.col("country")))
)
)
(ouvrir la capture en taille réelle)Spark l’a rejetée avant de traiter la moindre ligne :
(ouvrir la capture en taille réelle)L’erreur est [UNRESOLVED_COLUMN.WITH_SUGGESTION] : une colonne nommée customer_name ne peut pas être résolue, et Spark propose customer_id, last_name, first_name, segment et created_at. La correction suit une séquence courte et réutilisable :
- Inspecter le schéma. Exécutez
spark.table("bronze_customers").printSchema()ou développez la table dans l’explorateur. - Identifier la colonne manquante. Bronze contient
first_nameetlast_name, pascustomer_name. Le fichier brut ne l’avait pas non plus (étape 3). - Corriger la transformation. Construisez
customer_nameavecconcat_wsà partir des deux colonnes qui existent, au lieu de la lire. - Relancer la cellule.
- Vérifier la table Silver. Contrôlez les lignes affichées, puis confirmez que
silver_customersapparaît sous Tables avec les colonnes attendues.
La leçon dépasse une seule colonne : le code Silver doit être écrit pour le schéma que Bronze possède réellement, et c’est pour cela que l’étape 3 affiche le fichier brut avant que du code n’en dépende.
Ce lab s’arrête à la correction de la transformation. Les règles de validation, les tables de quarantaine pour les lignes invalides et les échecs récupérables sont le sujet du Lab 03.
Étape 7 — Construire la couche Gold
Créez nb_04_gold_model et attachez demo. Gold contient des tables conçues pour le reporting. Ce lab garde volontairement un modèle Gold compact, avec trois objets :
| Table | Rôle |
|---|---|
dim_customer |
Dimension client, à partir des clients Silver nettoyés |
fact_sales |
Une ligne par commande, avec le montant et une tranche de taille de commande |
gold_sales_by_country |
Ventes pré-agrégées par pays, prêtes pour le reporting |
(ouvrir la capture en taille réelle)dim_customer est construite à partir de silver_customers. Elle conserve les colonnes descriptives du client, dont la colonne customer_name dérivée dans Silver, laisse de côté les métadonnées d’ingestion et garantit une ligne par customer_id :
silver_customers_df = spark.table("silver_customers")
dim_customer_df = (
silver_customers_df
.select(
"customer_id",
"customer_name",
"email",
"segment",
"city",
"state",
"country",
"created_at",
"is_active"
)
.dropDuplicates(["customer_id"])
)
(
dim_customer_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("dim_customer")
)
display(dim_customer_df)
(ouvrir la capture en taille réelle)fact_sales est construite à partir de la petite table demo_sales créée dans le tutoriel sur les notebooks. Elle renomme amount en sales_amount et ajoute une tranche de taille de commande :
from pyspark.sql import functions as F
sales_df = spark.table("demo_sales")
fact_sales_df = (
sales_df
.select(
"order_id",
"customer_id",
"amount",
"country"
)
.withColumnRenamed(
"amount",
"sales_amount"
)
.withColumn(
"order_size",
F.when(F.col("sales_amount") >= 150, "Large")
.when(F.col("sales_amount") >= 100, "Medium")
.otherwise("Small")
)
)
display(fact_sales_df)
(ouvrir la capture en taille réelle)La table de synthèse agrège fact_sales par pays :
gold_sales_by_country_df = (
fact_sales_df
.groupBy("country")
.agg(
F.countDistinct("order_id").alias("order_count"),
F.round(F.sum("sales_amount"), 2).alias("total_sales"),
F.round(F.avg("sales_amount"), 2).alias("avg_order_amount")
)
.orderBy(F.desc("total_sales"))
)
display(gold_sales_by_country_df)
(ouvrir la capture en taille réelle)Écrivez-la avec saveAsTable("gold_sales_by_country"), comme pour les couches précédentes, puis listez les tables pour confirmer que tout existe :
(ouvrir la capture en taille réelle)Gardez en tête deux limites assumées de ce modèle Gold :
- C’est un point de départ, pas un schéma en étoile de production complet. Il n’y a ni dimension produit ni dimension date.
fact_salesprovient des trois commandes d’exemple dedemo_sales, dont les valeurscustomer_id(1,2) ne correspondent pas aux clésCUST…dedim_customer. Les deux tables ne sont donc pas encore joignables. Construirefact_salesà partir desales_orders.csvetsales_order_lines.csv, avec des clés cohérentes, est l’étape suivante naturelle, et un schéma en étoile complet est le point de départ du Lab 05.
Étape 8 — Orchestrer avec un pipeline Fabric
Exécuter trois notebooks à la main fonctionne une fois. Un pipeline les exécute dans le bon ordre à chaque fois et s’arrête si une couche échoue. Créez un pipeline nommé pl_sales_analytics dans ws_demo.
(ouvrir la capture en taille réelle)Ajoutez trois activités Notebook et, dans l’onglet Settings de chacune, sélectionnez son notebook :
| Activité | Notebook |
|---|---|
| Bronze Ingestion | nb_02_bronze_ingestion |
| Silver Transformations | nb_03_silver_transformations |
| Gold Model | nb_04_gold_model |
(ouvrir la capture en taille réelle)Reliez-les ensuite par des dépendances On success : faites glisser la coche verte de Bronze Ingestion vers Silver Transformations, puis de Silver Transformations vers Gold Model. Silver ne démarre que si Bronze a réussi, et Gold seulement si Silver a réussi : un échec ne laisse jamais une couche Gold à moitié actualisée.
(ouvrir la capture en taille réelle)Sélectionnez une activité et ouvrez son onglet Settings pour vérifier quel notebook elle exécute. Le même onglet comporte une section Base parameters, qui transmet des valeurs du pipeline au notebook. En guise d’aperçu, l’activité Bronze Ingestion ci-dessous en a trois : load_date (String, 2026-10-11), environment (String, dev) et full_reload (True, sans type encore sélectionné).
(ouvrir la capture en taille réelle)Le code Bronze de l’étape 4 ne lit pas ces valeurs ; elles ne changent donc rien pour l’instant : le notebook charge toujours customers.csv en entier. Faire utiliser ces valeurs par les notebooks, avec des types corrects et une cellule de paramètres, est le sujet du Lab 02.
Enregistrez le pipeline et sélectionnez Run. L’onglet Output suit chaque activité pendant l’exécution. Dans cette réalisation, les trois ont réussi : Bronze Ingestion en 49 secondes, Silver Transformations en 52 secondes et Gold Model en 1 minute 21 secondes.
(ouvrir la capture en taille réelle)L’onglet Parameters du pipeline lui-même est encore vide. C’est voulu : des chemins codés en dur et des rechargements complets gardent ce lab simple. Les paramètres de pipeline, les paramètres de notebook et les chargements incrémentaux pilotés par load_date, environment et full_reload sont le sujet du Lab 02 ; pour prendre de l’avance, voyez les paramètres de notebook Fabric.
Résultat
Vous disposez maintenant d’une petite solution d’analyse qui fonctionne de bout en bout dans Microsoft Fabric :
- un espace de travail Fabric,
ws_demo - un Lakehouse,
demo - des fichiers bruts dans OneLake, sous
Files/raw - une couche Bronze,
bronze_customers, avec ses métadonnées d’ingestion - une transformation Silver,
silver_customers, nettoyée et dédoublonnée - des tables Gold de reporting :
dim_customer,fact_salesetgold_sales_by_country - une orchestration par pipeline Fabric avec
pl_sales_analytics
- CSV bruts
- Files/rawZone d’atterrissage
- Bronze
- Silver
- Gold
- Orchestration par pipeline
Pour comprendre le raisonnement derrière les couches, lisez l’architecture médaillon expliquée. Quand la solution devra enregistrer ce que fait chaque exécution, concevoir un journal d’exécution pour les pipelines de données sert de base au Lab 04.
Continuer l’apprentissage
Les prochains labs s’appuient sur cette solution. Ils sont listés pour montrer où va le projet ; aucun n’est encore publié.
Pipelines paramétrés et traitement incrémental
Transmettre des valeurs du pipeline aux notebooks et ne charger que ce qui a changé au lieu de tout retraiter.
Pas encore publié
Qualité des données, quarantaine et gestion des erreurs
Valider les lignes avant la couche Silver, mettre en quarantaine celles qui échouent et rendre les échecs récupérables.
Pas encore publié
Supervision et journal d’exécution
Enregistrer chaque exécution dans un journal Delta pour savoir ce qui a tourné, ce qui a échoué et combien de lignes ont été traitées.
Pas encore publié
Modèles sémantiques et Power BI
Transformer la couche Gold en modèle sémantique avec relations et mesures DAX, puis créer un rapport Power BI.
Pas encore publié
Git, CI/CD et déploiement
Placer l’espace de travail sous Git et promouvoir la solution du développement au test puis à la production.
Pas encore publié