Tous les labs Fabric

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.

  1. 1Espace de travailws_demo
  2. 2Lakehousedemo
  3. 3Fichiers CSV brutsFiles/raw
  4. 4Tables Delta Bronzenb_02_bronze_ingestion
  5. 5Données Silver nettoyéesnb_03_silver_transformations
  6. 6Qualité des données et dépannageInspecter, corriger, relancer, vérifier
  7. 7Couche Gold de reportingnb_04_gold_model
  8. 8Orchestration par pipeline Fabricpl_sales_analytics
Le flux construit dans ce lab, des fichiers bruts jusqu’à une couche Gold orchestrée.

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.

Volet Espaces de travail de Microsoft Fabric listant l’espace ws_demo, avec le bouton New workspace en bas (ouvrir la capture en taille réelle)
Les espaces de travail se créent depuis le volet Espaces de travail ; ws_demo est le seul espace utilisé par ce lab.

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.

Page d’accueil de l’espace ws_demo avec New item, Manage access et Workspace settings, et dans la liste un Lakehouse demo, son point de terminaison SQL analytics et un notebook (ouvrir la capture en taille réelle)
La page d’accueil de l’espace regroupe tous les éléments du lab ; New item, Manage access et Workspace settings sont en haut.

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.

Options de type d’espace de travail dans Microsoft Fabric, avec Fabric Trial sélectionné parmi les types Power BI et Fabric (ouvrir la capture en taille réelle)
Choisissez un type d’espace Fabric (évaluation ou capacité) ; les types réservés à Power BI ne peuvent pas héberger de Lakehouse ni de notebooks.

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.

Panneau Add people de ws_demo montrant les rôles Admin, Member, Contributor et Viewer (ouvrir la capture en taille réelle)
Les rôles vont d’Admin à Viewer ; seuls les rôles Admin, Member et Contributor peuvent modifier les éléments.

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.

Workspace settings ouvert sur Git integration, proposant Azure DevOps et GitHub comme fournisseurs Git (ouvrir la capture en taille réelle)
L’intégration Git se trouve dans Workspace settings ; elle reste déconnectée dans ce lab et revient dans le lab consacré à Git et au déploiement.

É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.
Panneau New item de Microsoft Fabric filtré sur lake, montrant les éléments Lakehouse, Sample lakehouse et Warehouse (ouvrir la capture en taille réelle)
Créez un Lakehouse simple ; le Lakehouse d’exemple contient des données inutiles ici.
Explorateur du Lakehouse demo avec Tables et Files, affichant un aperçu de la table demo_customers (ouvrir la capture en taille réelle)
Tables contient les tables Delta et Files les fichiers bruts ; ce lab utilise les deux.

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.

Point de terminaison SQL analytics du Lakehouse demo montrant le schéma dbo, ses tables et un aperçu des données de demo_customers (ouvrir la capture en taille réelle)
Le point de terminaison SQL analytics lit les mêmes tables Delta en T-SQL, sans session Spark.

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.

Notebook Fabric avec le Lakehouse demo attaché dans l’explorateur, exécutant du PySpark qui écrit une table Delta demo_customers (ouvrir la capture en taille réelle)
Avec le Lakehouse attaché, les noms de tables en PySpark le désignent directement.

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.csv
  • products.csv
  • purchase_orders.csv
  • sales_orders.csv
  • sales_order_lines.csv

Créez un dossier raw sous Files, ouvrez son menu … et choisissez Upload › Upload files.

Menu contextuel du dossier raw dans l’explorateur du Lakehouse, avec Upload développé sur Upload files et Upload folder (ouvrir la capture en taille réelle)
Téléverser depuis le menu du dossier place les fichiers exactement là où les notebooks les attendent.

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.

Dossier Files/raw dans l’explorateur du Lakehouse listant customers.csv, products.csv, purchase_orders.csv, sales_order_lines.csv et sales_orders.csv (ouvrir la capture en taille réelle)
Les cinq fichiers sources sont côte à côte dans la zone d’atterrissage.

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.

Aperçu du fichier customers.csv dans le Lakehouse avec les colonnes customer_id, first_name, last_name, email, segment, city, state, country, created_at et is_active (ouvrir la capture en taille réelle)
L’aperçu du fichier brut montre les vrais noms de colonnes avant que du code n’en dépende.

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.

Boîte de dialogue New Notebook dans l’espace ws_demo avec le nom nb_02_bronze_ingestion (ouvrir la capture en taille réelle)
Un notebook par couche garde chaque étape courte et permet au pipeline de les exécuter séparément.

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 :

PySpark
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())
)
PySpark10 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Cellule de notebook Fabric lisant Files/raw/customers.csv avec PySpark et ajoutant les colonnes _source_file et _ingested_at (ouvrir la capture en taille réelle)
Les métadonnées d’ingestion sont ajoutées à la lecture : chaque ligne Bronze peut être rattachée à son fichier.

Écrivez ensuite le DataFrame dans une table Delta :

PySpark
(
    customers_df.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("bronze_customers")
)
PySpark6 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Cellule de notebook Fabric écrivant customers_df dans la table Delta bronze_customers en mode overwrite, terminée avec succès (ouvrir la capture en taille réelle)
Le mode overwrite permet de relancer le notebook sans risque : chaque exécution remplace la table au lieu d’ajouter des doublons.

Actualisez Tables : bronze_customers apparaît avec les colonnes d’origine plus _source_file et _ingested_at.

Explorateur du Lakehouse montrant la table bronze_customers et ses colonnes, dont _source_file et _ingested_at (ouvrir la capture en taille réelle)
L’explorateur est le moyen le plus rapide de vérifier que la table existe avec le schéma attendu.

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_name construite à partir de first_name et last_name.
Boîte de dialogue New Notebook dans ws_demo avec le nom nb_03_silver_transformations (ouvrir la capture en taille réelle)
Le notebook Silver lit uniquement Bronze, jamais les fichiers bruts.
PySpark
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)
PySpark31 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Notebook Fabric exécutant le code de nettoyage Silver sur bronze_customers, avec le schéma de bronze_customers dans l’explorateur et les lignes nettoyées affichées en dessous (ouvrir la capture en taille réelle)
Bronze contient first_name et last_name ; Silver en dérive customer_name au lieu de l’attendre dans la source.

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 :

PySpark
(
    silver_customers_df.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("silver_customers")
)
PySpark6 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Tables du Lakehouse listant bronze_customers et silver_customers après la réussite de la cellule d’écriture Silver (ouvrir la capture en taille réelle)
silver_customers se trouve maintenant à côté de bronze_customers ; Bronze reste intact pour un retraitement.

É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 :

PySpark
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")))
    )
)
PySpark12 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Première version de la cellule Silver référençant une colonne customer_name, pendant que la cellule est encore en cours d’exécution (ouvrir la capture en taille réelle)
La première tentative semblait raisonnable, mais elle référençait customer_name, une colonne que Bronze n’a jamais eue.

Spark l’a rejetée avant de traiter la moindre ligne :

Notebook Fabric affichant une erreur AnalysisException UNRESOLVED_COLUMN.WITH_SUGGESTION : customer_name ne peut pas être résolue, avec customer_id, last_name et first_name suggérées (ouvrir la capture en taille réelle)
Lisez d’abord les dernières lignes de l’erreur : le nom de colonne et les suggestions de Spark mènent directement à la cause.

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 :

  1. Inspecter le schéma. Exécutez spark.table("bronze_customers").printSchema() ou développez la table dans l’explorateur.
  2. Identifier la colonne manquante. Bronze contient first_name et last_name, pas customer_name. Le fichier brut ne l’avait pas non plus (étape 3).
  3. Corriger la transformation. Construisez customer_name avec concat_ws à partir des deux colonnes qui existent, au lieu de la lire.
  4. Relancer la cellule.
  5. Vérifier la table Silver. Contrôlez les lignes affichées, puis confirmez que silver_customers apparaî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
Notebook nb_04_gold_model vide avec le Lakehouse demo attaché, listant bronze_customers, demo_customers, demo_sales et silver_customers (ouvrir la capture en taille réelle)
Gold part des tables déjà présentes dans le Lakehouse ; à ce stade, aucun fichier brut n’est lu.

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 :

PySpark
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)
PySpark26 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Notebook Fabric lisant silver_customers, sélectionnant neuf colonnes client dans dim_customer et l’écrivant en table Delta, avec dim_customer et ses colonnes dans l’explorateur et 50 lignes de clients affichées (ouvrir la capture en taille réelle)
La dimension ne lit que Silver : neuf colonnes, 50 clients, ni _source_file ni _ingested_at.

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 :

PySpark
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)
PySpark25 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Notebook Fabric construisant fact_sales à partir de demo_sales, avec dim_customer déjà listée dans le Lakehouse et trois lignes de résultat classées Small, Medium et Large (ouvrir la capture en taille réelle)
fact_sales renomme amount en sales_amount et classe chaque commande ; dim_customer apparaît déjà sous Tables.

La table de synthèse agrège fact_sales par pays :

PySpark
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)
PySpark12 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.
Notebook Fabric agrégeant fact_sales par pays : USA avec 2 commandes et 335.50 de ventes totales, Canada avec 1 commande et 89.99 (ouvrir la capture en taille réelle)
Une petite table pré-agrégée répond à la question la plus fréquente sans aucun calcul côté rapport.

Écrivez-la avec saveAsTable("gold_sales_by_country"), comme pour les couches précédentes, puis listez les tables pour confirmer que tout existe :

Tables du Lakehouse listant dim_customer, fact_sales et gold_sales_by_country, avec la sortie de SHOW TABLES confirmant les tables dans l’espace de noms demo (ouvrir la capture en taille réelle)
SHOW TABLES et l’explorateur concordent : les tables Bronze, Silver et Gold vivent toutes dans le même Lakehouse.

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_sales provient des trois commandes d’exemple de demo_sales, dont les valeurs customer_id (1, 2) ne correspondent pas aux clés CUST… de dim_customer. Les deux tables ne sont donc pas encore joignables. Construire fact_sales à partir de sales_orders.csv et sales_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.

Boîte de dialogue New Pipeline dans ws_demo avec le nom pl_sales_analytics, au-dessus des trois notebooks de la liste de l’espace (ouvrir la capture en taille réelle)
Le pipeline vit dans le même espace de travail que les notebooks qu’il exécute.

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
Canevas du pipeline avec trois activités Notebook non reliées nommées Bronze Ingestion, Silver Transformations et Gold Model (ouvrir la capture en taille réelle)
Trois activités Notebook, une par couche, encore non reliées.

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.

Canevas du pipeline avec Bronze Ingestion relié à Silver Transformations et Silver Transformations relié à Gold Model par des flèches On success (ouvrir la capture en taille réelle)
Les flèches On success traduisent l’ordre du médaillon : chaque couche ne s’exécute qu’après la réussite de la précédente.

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é).

Onglet Settings de l’activité Notebook Bronze Ingestion, pointant vers nb_02_bronze_ingestion, avec les paramètres de base load_date à 2026-10-11, environment à dev et full_reload à True (ouvrir la capture en taille réelle)
Les paramètres de base sont l’endroit où les valeurs du pipeline atteignent un notebook ; ce lab montre seulement où ils se trouvent.

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.

Onglet Output du pipeline avec le statut Succeeded et les activités Bronze Ingestion, Silver Transformations et Gold Model toutes marquées Succeeded (ouvrir la capture en taille réelle)
Une exécution verte sur les trois activités : toute la solution s’actualise désormais en un clic ou selon une planification.

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_sales et gold_sales_by_country
  • une orchestration par pipeline Fabric avec pl_sales_analytics
  1. CSV bruts
  2. Files/rawZone d’atterrissage
  3. Bronze
  4. Silver
  5. Gold
  6. Orchestration par pipeline
L’architecture finale du Lab 01.

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é.

  1. Lab 02Bientôt disponible

    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é

  2. Lab 03Bientôt disponible

    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é

  3. Lab 04Bientôt disponible

    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é

  4. Lab 05Bientôt disponible

    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é

  5. Lab 06Bientôt disponible

    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é