Microsoft Fabric

Tutoriel Microsoft Fabric Notebook : du premier notebook à la production

Un tutoriel pratique sur les notebooks Microsoft Fabric : Lakehouse, PySpark, SQL, tables Delta, paramètres, pipelines, Git, supervision, performance et production.

Par JaviPublié 19 min de lectureIntermédiaire

Dans cet article

Un notebook Microsoft Fabric peut commencer par quelques cellules d’exploration et devenir rapidement une pièce d’une plateforme de données en production.

C’est dans cette transition que beaucoup d’équipes se heurtent à des difficultés.

Créer un notebook est facile. En construire un qui soit paramétré, observable, reproductible, versionné et sûr à exécuter depuis un pipeline demande une ingénierie plus réfléchie.

Ce tutoriel parcourt ce chemin complet.

L’objectif n’est pas seulement de montrer comment exécuter du PySpark dans Fabric. Il s’agit de montrer comment un notebook s’intègre dans un vrai workflow de data engineering :

  1. Espace de travail
  2. Lakehouse
  3. Notebook
  4. Transformation
  5. Tables Delta
  6. Pipeline
  7. Supervision
  8. Git / déploiement
La place d’un notebook dans un workflow de data engineering

À la fin, vous devriez savoir comment passer d’un notebook interactif à quelque chose que vous pouvez exploiter au sein d’une plateforme de données en production.

Qu’est-ce qu’un notebook Microsoft Fabric ?

Un notebook Fabric est une surface de développement interactive pour les charges de travail Apache Spark dans Microsoft Fabric.

Vous pouvez l’utiliser pour :

  • explorer des données ;
  • lire et écrire des données du Lakehouse ;
  • transformer de grands jeux de données avec PySpark ;
  • exécuter du Spark SQL ;
  • travailler avec des tables Delta ;
  • paramétrer les traitements ;
  • exécuter des notebooks depuis des pipelines Data Factory ;
  • intégrer le code source des notebooks à Git ;
  • industrialiser des transformations de données récurrentes.

Les notebooks Fabric sont particulièrement utiles lorsque la transformation nécessite Spark, un traitement distribué ou un workflow orienté code.

Un notebook n’est pas automatiquement le meilleur outil pour chaque tâche. De simples opérations de copie peuvent relever d’une activité de pipeline. Des transformations T-SQL peuvent mieux convenir à un Warehouse. De petites étapes d’orchestration n’ont parfois pas besoin de Spark du tout.

Le notebook est un outil parmi d’autres dans la plateforme.

Prérequis

Pour les exercices de ce tutoriel, vous avez besoin :

  • d’un accès à un tenant Microsoft Fabric ;
  • d’un espace de travail affecté à une capacité Fabric ou à un essai éligible ;
  • de l’autorisation de créer des éléments dans cet espace de travail ;
  • d’un Lakehouse ;
  • d’un notebook.

Un espace de travail de développement pratique pourrait ressembler à ceci :

Workspace: data-platform-dev
Lakehouse: lh_sales
Notebook: nb_transform_sales

Pour les environnements de production, utilisez des espaces de travail séparés pour le développement, les tests et la production, plutôt que de traiter un seul espace de travail comme tous les environnements à la fois.

Étape 1 : créer votre premier notebook Microsoft Fabric

Dans un espace de travail Fabric, sélectionnez Nouvel élément, recherchez Notebook, sélectionnez-le, puis donnez au notebook un nom explicite comme demo_javibuilds.

Panneau Nouvel élément de Microsoft Fabric avec Notebook comme élément sélectionnable

Créez un notebook depuis l’expérience Nouvel élément de l’espace de travail Fabric.

Étape 2 : comprendre l’espace de travail du notebook

Un nouveau notebook Fabric commence par une cellule de code. Le menu des langages propose PySpark (Python), Spark (Scala), Spark SQL, SparkR (R) et HTML. Ce tutoriel utilise surtout PySpark pour les DataFrames et la logique Python, et Spark SQL lorsque SQL exprime plus clairement la transformation.

Notebook Microsoft Fabric vide affichant le menu des langages PySpark, Spark SQL, Scala, R et HTML

Un notebook Fabric peut exécuter des cellules PySpark, Spark SQL, Scala, R et HTML.

Étape 3 : créer ou attacher un Lakehouse

Le Lakehouse stocke les tables Delta de ce tutoriel. Dans Éléments de données, sélectionnez Ajouter des éléments de données, puis attachez un Lakehouse existant ou créez-en un nommé demo. Une fois attaché, l’Explorateur affiche Tables et Files, accessibles directement depuis le code.

Notebook Microsoft Fabric affichant la boîte de dialogue Nouveau Lakehouse avec le nom demo

Créez ou attachez un Lakehouse depuis le volet Éléments de données du notebook.

Étape 4 : comment s’articulent le notebook, le Lakehouse et le point de terminaison d’analytique SQL

Avant d’écrire davantage de code, il est utile de voir comment les éléments que vous venez de créer sont liés entre eux.

Un espace de travail Fabric est un conteneur d’éléments Fabric. Dans ce tutoriel, il contient le Lakehouse et le notebook que vous avez créés, ainsi qu’un élément que Fabric a créé pour vous :

Espace de travail
  ├─ Lakehouse (demo)
  │   ├─ Tables
  │   ├─ Files
  │   └─ Point de terminaison d'analytique SQL
  └─ Notebook (demo_javibuilds)
      └─ lit/écrit des tables Delta dans le Lakehouse
  • Le Lakehouse est un élément Fabric qui stocke des données dans OneLake, sous forme de tables et de fichiers.
  • Lorsque vous créez un Lakehouse, Fabric crée automatiquement un point de terminaison d’analytique SQL pour celui-ci. Ce point de terminaison n’est pas une seconde copie des données : il expose les tables Delta du Lakehouse au SQL et lit les mêmes tables dans OneLake.
  • Le notebook est un élément distinct du même espace de travail. Il ne stocke pas les données lui-même ; une fois le Lakehouse attaché, le code du notebook lit et écrit les tables Delta et les fichiers du Lakehouse.
  • Le point de terminaison d’analytique SQL permet aux utilisateurs et outils SQL d’interroger ces mêmes tables du Lakehouse en SQL, sans ouvrir de notebook. L’étape 11 le montre en action.

Espace de travail Microsoft Fabric affichant un Lakehouse, son point de terminaison d’analytique SQL et un notebook dans le même espace de travail

Un espace de travail Fabric peut contenir le Lakehouse, son point de terminaison d’analytique SQL et le notebook qui traite ses données.

Étape 5 : Tables et Files dans un Lakehouse Fabric

L’Explorateur du Lakehouse affiche deux zones : Tables et Files. Les deux se trouvent dans OneLake, mais elles n’ont pas le même rôle.

Tables

  • des tables Delta managées que vous pouvez interroger ;
  • visibles par leur nom depuis Spark, par exemple spark.table("demo_customers") ;
  • interrogeables via le point de terminaison d’analytique SQL ;
  • adaptées aux données structurées et préparées, comme demo_customers et demo_sales.

Files

  • un stockage de fichiers généraliste dans OneLake ;
  • utile pour les fichiers CSV, JSON, Parquet et d’autres formats ;
  • souvent utilisé pour les données brutes d’atterrissage ou de staging ;
  • un fichier dans Files ne devient pas automatiquement une table managée du Lakehouse : vous le chargez dans une table, par exemple avec saveAsTable().
Tables Files
Contenu Tables Delta managées Fichiers de tout format (CSV, JSON, Parquet…)
Lecture depuis Spark spark.table("demo_customers") spark.read.csv("Files/raw/customers.csv")
Point de terminaison d’analytique SQL Interrogeables comme tables Non exposés comme tables
Usage typique Données structurées et préparées Données brutes d’atterrissage et de staging

La capture ci-dessous montre le Lakehouse après les étapes suivantes : demo_customers et demo_sales sous Tables, et un dossier raw sous Files.

Lakehouse Microsoft Fabric affichant demo_customers et demo_sales sous Tables et un dossier raw sous Files

Un Lakehouse Fabric sépare les tables managées du stockage de fichiers généraliste, tout en conservant les deux dans OneLake.

Étape 6 : créer une table Delta avec PySpark

Créez un petit DataFrame Spark et enregistrez-le comme table Delta managée dans le Lakehouse attaché :

PySpark
from pyspark.sql import Row

data = [
    Row(customer_id=1, customer_name="Alice", country="USA"),
    Row(customer_id=2, customer_name="Bob", country="Canada"),
    Row(customer_id=3, customer_name="Carlos", country="Spain"),
]

df = spark.createDataFrame(data)

df.write \
    .format("delta") \
    .mode("overwrite") \
    .saveAsTable("demo_customers")
PySpark14 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Vérifiez la table :

spark.table("demo_customers").show()

createDataFrame() crée le DataFrame Spark, format("delta") choisit le format Delta et saveAsTable("demo_customers") enregistre la table sous Tables dans le Lakehouse attaché.

Notebook Microsoft Fabric exécutant PySpark pour créer la table Delta demo_customers, visible dans l’Explorateur du Lakehouse

PySpark crée demo_customers comme table Delta dans le Lakehouse attaché.

Étape 7 : créer et interroger la table avec Spark SQL

Vous pouvez créer la même table Delta avec Spark SQL. Il s’agit de Spark SQL exécuté dans la session Spark du notebook, et non du point de terminaison SQL du Warehouse Fabric ni de T-SQL SQL Server. L’étape 11 présente le point de terminaison d’analytique SQL propre au Lakehouse.

%%sql

CREATE OR REPLACE TABLE demo_customers
USING DELTA
AS
SELECT 1 AS customer_id, 'Alice' AS customer_name, 'USA' AS country
UNION ALL
SELECT 2, 'Bob', 'Canada'
UNION ALL
SELECT 3, 'Carlos', 'Spain';
Spark SQL10 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Interrogez-la ensuite :

%%sql

SELECT *
FROM demo_customers;
Spark SQL4 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Notebook Microsoft Fabric utilisant Spark SQL pour créer et interroger la table Delta demo_customers et afficher les résultats

Spark SQL peut créer et interroger la même table Delta sans quitter le notebook.

PySpark ou Spark SQL : les deux s’exécutent sur Spark et utilisent les mêmes tables Delta. Choisissez PySpark pour les DataFrames et la logique Python, et Spark SQL lorsque SQL est plus clair.

Étape 8 : créer des données de vente d’exemple

Créez une deuxième table Delta pour disposer de données réalistes à transformer :

%%sql

CREATE OR REPLACE TABLE demo_sales
USING DELTA
AS
SELECT 1001 AS order_id, 1 AS customer_id, 125.50 AS amount, 'USA' AS country
UNION ALL
SELECT 1002, 2, 89.99, 'Canada'
UNION ALL
SELECT 1003, 1, 210.00, 'USA';
Spark SQL10 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Cellule Spark SQL de Microsoft Fabric créant la table Delta demo_sales dans le Lakehouse attaché

Une deuxième table Delta fournit des données à transformer avec PySpark.

Étape 9 : transformer les données du Lakehouse avec PySpark

Lisez demo_sales, ajoutez une classification métier dérivée et examinez le résultat :

PySpark
from pyspark.sql import functions as F

sales_df = spark.table("demo_sales")

enriched_df = (
    sales_df
    .withColumn(
        "order_size",
        F.when(F.col("amount") >= 150, "Large")
         .when(F.col("amount") >= 100, "Medium")
         .otherwise("Small")
    )
)

display(enriched_df)
PySpark15 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Le code lit une table Delta du Lakehouse attaché, ajoute order_size et affiche le DataFrame transformé de manière interactive.

Notebook Microsoft Fabric utilisant PySpark pour lire demo_sales, ajouter la classification order_size et afficher les lignes transformées

Lisez une table Delta du Lakehouse avec PySpark, ajoutez une colonne dérivée et examinez le résultat.

Le Lakehouse attaché reste visible dans l’Explorateur du notebook pendant que vous travaillez : vous voyez les tables Delta lues par le code, comme demo_sales, à côté des lignes transformées :

Notebook Microsoft Fabric avec le Lakehouse demo attaché, une transformation PySpark sur demo_sales et les résultats affichés

Avec le Lakehouse attaché, PySpark lit directement les tables Delta et affiche les résultats transformés dans le même notebook.

Agrégez ensuite le résultat par pays :

PySpark
country_summary_df = (
    enriched_df
    .groupBy("country")
    .agg(
        F.count("*").alias("order_count"),
        F.round(F.sum("amount"), 2).alias("total_sales"),
        F.round(F.avg("amount"), 2).alias("avg_order_amount")
    )
    .orderBy(F.desc("total_sales"))
)

display(country_summary_df)
PySpark12 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Enregistrez le résumé réutilisable dans le Lakehouse :

PySpark
(
    country_summary_df.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("demo_sales_by_country")
)
PySpark6 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

overwrite convient à ce tutoriel, mais une charge de production peut nécessiter un ajout, un remplacement de partition, un MERGE, un traitement incrémentiel ou des mises à jour idempotentes. Demandez-vous toujours ce qui se passe si le notebook est exécuté deux fois.

Étape 10 : déposer les fichiers bruts dans Files/raw

Les vrais pipelines partent rarement de lignes saisies à la main. Les systèmes sources livrent généralement des fichiers, et la zone Files du Lakehouse est l’endroit naturel où les déposer avant qu’ils ne deviennent des tables Delta.

Une organisation possible :

Files/raw/
  customers.csv
  products.csv
  purchase_orders.csv
  sales_order_lines.csv
  sales_orders.csv

Ce n’est qu’un exemple d’organisation, pas une exigence de Fabric. Choisissez des dossiers adaptés à vos sources et à vos besoins de conservation, par exemple par système source, par date de chargement ou par tenant.

Zone Files d’un Lakehouse Microsoft Fabric affichant un dossier raw contenant des fichiers source CSV

La zone Files est l’endroit naturel où déposer les fichiers source bruts avant de les transformer en tables Delta.

Lisez l’un des fichiers avec PySpark :

PySpark
raw_customers_df = (
    spark.read
    .option("header", True)
    .option("inferSchema", True)
    .csv("Files/raw/customers.csv")
)

display(raw_customers_df)
PySpark8 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

inferSchema est pratique pour explorer un fichier. Pour l’ingestion en production, déclarez un schéma explicite avec .schema(...), afin qu’un changement de type dans la source soit détecté au lieu d’être déduit en silence.

Chargez-le ensuite dans une table Delta managée :

PySpark
(
    raw_customers_df.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("demo_customers_from_file")
)
PySpark6 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Après cette écriture, demo_customers_from_file apparaît sous Tables, et le fichier CSV reste dans Files/raw/. Le fichier lui-même n’est pas devenu une table : le notebook a créé une nouvelle table Delta à partir de lui.

Étape 11 : interroger les tables du Lakehouse via le point de terminaison d’analytique SQL

Les tables Delta que vous avez créées ne servent pas qu’à Spark. Ouvrez le point de terminaison d’analytique SQL du Lakehouse depuis l’espace de travail, ou basculez la vue du Lakehouse sur Point de terminaison d’analytique SQL, puis interrogez les tables en SQL :

Requête SQL: Étape 11 : interroger les tables du Lakehouse via le point de terminaison d’analytique SQLT-SQL (Fabric Warehouse)
SELECT TOP (100)
    customer_id,
    customer_name,
    country
FROM dbo.demo_customers;
T-SQL (Fabric Warehouse)5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Point de terminaison d’analytique SQL Microsoft Fabric interrogeant la table demo_customers du Lakehouse et affichant les résultats

Le point de terminaison d’analytique SQL du Lakehouse permet aux utilisateurs SQL d’interroger les mêmes tables sans ouvrir de notebook.

C’est une expérience différente des cellules %%sql de l’étape 7. Spark SQL s’exécute via Spark dans le notebook ; le point de terminaison d’analytique SQL offre une expérience de requête SQL en dehors du notebook, sur les mêmes tables du Lakehouse.

Spark SQL dans le notebook Point de terminaison d’analytique SQL
S’exécute via Spark Expérience du point de terminaison SQL
Utilisé dans les notebooks Utilisé depuis l’éditeur de requêtes SQL et les outils SQL
Adapté aux workflows mêlant PySpark et SQL Adapté aux requêtes orientées SQL
Fonctionne via l’exécution Spark Expose les tables du Lakehouse en SQL
Peut écrire des tables Delta Lecture seule pour les données des tables du Lakehouse

Les deux lisent les mêmes tables Delta dans OneLake ; rien n’est copié de l’un à l’autre. Les tables créées par le notebook, comme demo_sales_by_country à l’étape 9, deviennent elles aussi interrogeables depuis le point de terminaison, généralement après une courte synchronisation des métadonnées.

Étape 12 : paramétrer le notebook

Évitez les valeurs d’exécution codées en dur :

process_date = "2026-10-09"
tenant_id = 42

Les notebooks Fabric prennent en charge une cellule de paramètres dédiée.

Une cellule de paramètres peut définir des valeurs par défaut comme :

PySpark
process_date = "2026-10-09"
tenant_id = 0
full_reload = False
PySpark3 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Quand un pipeline Fabric appelle le notebook, l’activité Notebook peut fournir les valeurs des paramètres.

Les paramètres de notebook prennent en charge des types simples comme string, int, float et bool.

Une structure utile est la suivante :

  1. 1Paramètres
  2. 2Valider les paramètres
  3. 3Résoudre la configuration
  4. 4Exécuter la transformation
  5. 5Écrire le résultat
Un notebook paramétré

Étape 13 : exécuter le notebook depuis un pipeline Fabric

Créez un pipeline Fabric Data Factory et ajoutez une activité Notebook.

Le pipeline peut sélectionner le notebook et lui transmettre des paramètres de base.

  1. Pipeline
  2. Activité Notebook
  3. paramètres de base
    nb_transform_sales
    • process_date
    • tenant_id
Exécuter le notebook depuis un pipeline

Le pipeline doit généralement gérer les planifications, les dépendances, les nouvelles tentatives, l’enchaînement et l’état global de l’exécution.

Le notebook doit généralement gérer la logique de transformation, la validation, les contrôles de qualité des données et les écritures.

Étape 14 : ajouter une journalisation d’exécution

Un notebook de production doit vous permettre de répondre à ces questions :

Quelle exécution a échoué ?
Pour quel tenant ?
Pour quelle date de traitement ?
Quand a-t-elle commencé ?
Quand s'est-elle terminée ?
Combien de lignes ont été lues ?
Combien ont été écrites ?
Quelle erreur s'est produite ?

Au minimum, établissez un contexte d’exécution :

PySpark
from datetime import datetime, timezone
import uuid

run_id = str(uuid.uuid4())
started_at = datetime.now(timezone.utc)

print(f"run_id={run_id}")
print(f"tenant_id={tenant_id}")
print(f"process_date={process_date}")
print(f"started_at={started_at.isoformat()}")
PySpark10 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Pour une vraie plateforme, persistez les informations d’exécution dans une table de journal d’exécution.

Les champs utiles comprennent souvent :

run_id
parent_run_id
pipeline_name
notebook_name
tenant_id
process_date
status
started_at
ended_at
rows_read
rows_written
rows_rejected
error_code
error_message

Étape 15 : échouer volontairement quand la validation échoue

Un notebook dangereux détecte un problème et continue :

if invalid_count > 0:
    print("Warning: invalid rows found")

Si le résultat ne doit pas être considéré comme fiable, échouez explicitement :

PySpark
if invalid_count > 0:
    raise ValueError(
        f"Validation failed: {invalid_count} invalid records found."
    )
PySpark4 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

La couche d’orchestration peut alors détecter l’échec.

Étape 16 : penser à la sécurité des nouvelles tentatives

Si un pipeline relance votre notebook, que se passe-t-il ?

Un notebook de production ne doit pas dupliquer les données parce que la première tentative a écrit avec succès avant l’échec de l’activité.

Les patterns courants sont :

  • des clés métier stables ;
  • le MERGE Delta ;
  • le remplacement de partition ;
  • l’ajout idempotent ;
  • le suivi des fichiers traités ;
  • un état de watermark/checkpoint.

Le principe est le suivant :

Une nouvelle tentative du pipeline ne doit pas corrompre la destination.

Étape 17 : versionner le notebook

Les notebooks Fabric prennent en charge l’intégration Git dans le cadre de la gestion du cycle de vie Fabric.

Le contrôle de version vous apporte :

  • un historique des versions ;
  • des branches ;
  • la revue de code ;
  • de la visibilité sur les changements ;
  • un chemin de promotion entre environnements.

Un modèle plus sain que l’édition directe en production :

  1. Modification du développeur
  2. Branche Git
  3. Revue
  4. DEV
  5. validation
    TEST / QA
  6. PROD
Promouvoir une modification du notebook

Votre mécanisme de déploiement peut utiliser l’intégration Git de Fabric, les pipelines de déploiement ou une CI/CD construite autour des APIs Fabric.

Étape 18 : séparer le code de la configuration d’environnement

Un notebook dont les cellules contiennent un peu partout des ID d’espace de travail, des ID de Lakehouse, des points de terminaison de production ou des secrets devient difficile à promouvoir.

Préférez une configuration propre à chaque environnement, en dehors de la logique de transformation principale.

Cela devient particulièrement important lorsque les notebooks passent entre :

DEV
QA
PROD

Étape 19 : comprendre ce que Git déploie et ne déploie pas

Le contrôle de version et le déploiement gèrent les métadonnées et le code des éléments pris en charge, pas vos données métier elles-mêmes.

Une séparation utile :

Git
→ définitions / code / métadonnées

OneLake
→ données réelles

Traitez la migration des données et le déploiement applicatif comme des sujets liés, mais distincts.

Étape 20 : superviser l’exécution du notebook

Un notebook n’est pas terminé parce qu’il a réussi une fois.

Suivez au minimum :

  • la durée ;
  • le succès ou l’échec ;
  • le nombre de lignes ;
  • la taille des entrées ;
  • la taille des sorties ;
  • les nouvelles tentatives ;
  • les enregistrements rejetés ;
  • les ralentissements répétés.

Un notebook qui se termine normalement en 4 minutes et prend soudain 25 minutes peut techniquement réussir, mais sur le plan opérationnel il mérite une analyse.

Étape 21 : bases de la performance

Commencez par :

Où le temps passe-t-il réellement ?

Les possibilités incluent :

démarrage de la session Spark
lecture des données
shuffle
jointure
sérialisation
écriture
petits fichiers
latence de la source
attente d'orchestration

N’optimisez pas la syntaxe Python quand la charge passe l’essentiel de son temps à redistribuer des données dans Spark.

Éviter les actions inutiles

Les actions déclenchent l’exécution :

PySpark
df.count()
display(df)
df.collect()
PySpark3 lignesCellule d’exemple en lecture seule. Rien sur cette page n’exécute de code.

Utilisez-les à bon escient.

Éviter les grosses collectes sur le driver

rows = df.collect()

peut saturer le driver pour de gros dataframes.

Surveiller les jointures

Avant de joindre de gros jeux de données, comprenez :

  • le nombre de lignes ;
  • la cardinalité des clés ;
  • l’asymétrie (skew) ;
  • les clés en double ;
  • la cardinalité de sortie attendue.

Étape 22 : garder des cellules adaptées à la production

Une bonne structure :

1. Paramètres
2. Imports
3. Configuration
4. Contexte d'exécution / journalisation
5. Lecture
6. Validation des entrées
7. Transformation
8. Validation des sorties
9. Écriture
10. Métriques finales

L’exécution en production ne doit pas dépendre de cellules lancées manuellement dans un ordre caché.

Étape 23 : éviter l’état caché du notebook

Un notebook peut sembler fonctionner parce qu’une variable a été créée dans une cellule exécutée plus tôt.

Avant de le considérer comme prêt, testez :

nouvelle session
→ Tout exécuter
→ succès

Si cela échoue, le notebook n’est pas encore reproductible.

Étape 24 : traiter le notebook comme un composant

Un seul notebook ne doit pas forcément gérer l’ingestion, toutes les transformations, l’orchestration, la journalisation, les notifications et le serving.

Une frontière plus nette pourrait être :

Pipeline
├── Copier les données brutes
├── Notebook : valider + standardiser
├── Notebook : transformation métier
├── Activité de qualité des données
└── Publier / notifier

La frontière doit refléter les responsabilités opérationnelles.

Liste de contrôle avant la production

Données

  • Le contrat d’entrée est-il explicite ?
  • Les clés importantes sont-elles validées ?
  • Les doublons sont-ils gérés ?
  • Les enregistrements invalides sont-ils comptabilisés ?

Reproductibilité

  • S’exécute-t-il depuis une nouvelle session ?
  • Peut-il être relancé sans risque ?
  • Les écritures sont-elles idempotentes ?

Configuration

  • Les valeurs propres à l’environnement sont-elles externalisées ?
  • Les valeurs d’exécution sont-elles des paramètres plutôt que des valeurs codées en dur ?

Exploitation

  • Chaque exécution a-t-elle une identité ?
  • Le début, la fin et le statut sont-ils enregistrés ?
  • Le nombre de lignes est-il capturé ?
  • Un problème de validation critique fait-il échouer l’activité ?

Performance

  • Les grosses jointures ont-elles été vérifiées ?
  • Les actions Spark inutiles ont-elles été supprimées ?
  • La collecte sur le driver est-elle évitée ?
  • La stratégie d’écriture est-elle appropriée ?

Cycle de vie

  • Le notebook est-il sous contrôle de version ?
  • Peut-il passer par DEV/TEST/PROD ?
  • Les Lakehouses et environnements dont il dépend sont-ils bien identifiés ?

Du premier notebook à la production

  1. 1Le notebook fonctionne en interactif
  2. 2Le notebook s’exécute depuis une session propre
  3. 3Les entrées et sorties sont validées
  4. 4Des paramètres remplacent les valeurs codées en dur
  5. 5Les écritures supportent les nouvelles tentatives
  6. 6Le pipeline gère l’orchestration
  7. 7L’exécution est journalisée
  8. 8Git gère l’historique des changements
  9. 9Le déploiement promeut entre les environnements
  10. 10La supervision mesure le comportement en production
Du premier notebook à la production

C’est toute la différence entre utiliser un notebook et concevoir une véritable charge de travail à base de notebook.

Conclusion

Microsoft Fabric permet de créer facilement un notebook, de le connecter à un Lakehouse et de commencer à transformer des données.

Mais le travail d’ingénierie commence après la première exécution réussie.

Un notebook de production a besoin de dépendances claires, de paramètres, de validation, d’écritures sûres en cas de nouvelle tentative, d’une journalisation de l’exécution, d’un contrôle de version, d’une discipline de déploiement et de supervision.

L’objectif n’est pas de supprimer la flexibilité qui rend les notebooks utiles.

L’objectif est de conserver cette flexibilité tout en ajoutant assez de structure pour que le notebook soit digne de confiance en production.

Références Microsoft officielles

Étiquettes

  • Microsoft Fabric
  • Fabric Notebook
  • PySpark