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.
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 :
- Espace de travail
- Lakehouse
- Notebook
- Transformation
- Tables Delta
- Pipeline
- Supervision
- Git / déploiement
À 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.

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.

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.

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.

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

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

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.
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';Interrogez-la ensuite :
SELECT *
FROM demo_customers;
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 :
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';
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 :
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)Le code lit une table Delta du Lakehouse attaché, ajoute order_size et affiche le DataFrame transformé de manière interactive.

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 :

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 :
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)Enregistrez le résumé réutilisable dans le Lakehouse :
(
country_summary_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("demo_sales_by_country")
)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.

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 :
raw_customers_df = (
spark.read
.option("header", True)
.option("inferSchema", True)
.csv("Files/raw/customers.csv")
)
display(raw_customers_df)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 :
(
raw_customers_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("demo_customers_from_file")
)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 :
SELECT TOP (100)
customer_id,
customer_name,
country
FROM dbo.demo_customers;
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 :
process_date = "2026-10-09"
tenant_id = 0
full_reload = FalseQuand 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 :
- 1Paramètres
- 2Valider les paramètres
- 3Résoudre la configuration
- 4Exécuter la transformation
- 5Écrire le résultat
É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.
- Pipeline
- Activité Notebook
- paramètres de basenb_transform_sales
- process_date
- tenant_id
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 :
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()}")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 :
if invalid_count > 0:
raise ValueError(
f"Validation failed: {invalid_count} invalid records found."
)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
MERGEDelta ; - 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 :
- Modification du développeur
- Branche Git
- Revue
- DEV
- validationTEST / QA
- PROD
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 :
df.count()
display(df)
df.collect()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
- 1Le notebook fonctionne en interactif
- 2Le notebook s’exécute depuis une session propre
- 3Les entrées et sorties sont validées
- 4Des paramètres remplacent les valeurs codées en dur
- 5Les écritures supportent les nouvelles tentatives
- 6Le pipeline gère l’orchestration
- 7L’exécution est journalisée
- 8Git gère l’historique des changements
- 9Le déploiement promeut entre les environnements
- 10La supervision mesure le comportement en 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
- Développer, exécuter et gérer des notebooks Fabric : https://learn.microsoft.com/en-us/fabric/data-engineering/author-execute-notebook
- Explorer les données d’un Lakehouse avec un notebook : https://learn.microsoft.com/fabric/data-engineering/lakehouse-notebook-explore
- Charger des données dans un Lakehouse avec un notebook : https://learn.microsoft.com/en-us/fabric/data-engineering/lakehouse-notebook-load-data
- Tutoriel Lakehouse : https://learn.microsoft.com/en-us/fabric/data-engineering/tutorial-build-lakehouse
- Activité Notebook dans Fabric Data Factory : https://learn.microsoft.com/en-us/fabric/data-factory/notebook-activity
- Contrôle de version et déploiement des notebooks : https://learn.microsoft.com/en-us/fabric/data-engineering/notebook-source-control-deployment
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireSuperviser les pipelines et notebooks FabricSupervisez les pipelines et notebooks Microsoft Fabric avec le Monitoring hub, Workspace Monitoring, la supervision Spark, KQL, les alertes et la télémétrie de capacité afin de rendre observables les échecs et les régressions de performances.Ouvrir l’aide-mémoire
- RessourceContenu en anglaisFabric Notebook Performance ChecklistA practical pre-run, read, transform, write and orchestration checklist for faster and more reliable Microsoft Fabric notebooks.Voir la ressource
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
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.