Microsoft Fabric
Comment accélérer les notebooks Microsoft Fabric
Une méthode pratique pour réduire le temps de démarrage, de lecture, de shuffle, de transformation et d’écriture Delta des notebooks Fabric sans deviner.
Dans cet article
Réponse courte : un notebook Fabric lent l’est rarement partout. Sa durée se décompose en phases distinctes : attente en file pour obtenir de la capacité, démarrage d’une session Spark, lecture des données, transformation et shuffle, écriture du résultat, puis attente de ce qui s’exécute ensuite. Chaque phase a ses propres indices et ses propres remèdes. Trouvez la phase qui s’est allongée avant de changer le moindre paramètre : un shuffle plus rapide ne sert à rien si l’exécution a surtout attendu de la capacité.
- File d’attenteTâche de pipeline ou planifiée en attente de capacité Spark
- Démarrage de sessionStarter pool ou cluster à la demande, bibliothèques de l’environnement
- LectureOctets et fichiers lus, élagage, petits fichiers
- TransformationForme du plan, actions répétées, collectes côté driver
- ShuffleLecture et écriture de shuffle, tâches déséquilibrées, débordement
- ÉcritureFichiers et partitions en sortie, mode d’écriture, compactage
Après l’écriture, le pipeline peut encore attendre une activité en aval : ce temps relève de l’orchestration, pas de Spark.
Problème
Un pipeline de production appelle un notebook qui se termine parfois rapidement et parfois beaucoup plus lentement. Le notebook lit un historique étendu, effectue des jointures et des agrégations, puis remplace une cible Delta. Avant de modifier la capacité ou d’ajouter des appels au cache, séparez le délai d’orchestration, le démarrage de la session, l’exécution Spark et l’écriture de la sortie.
Enregistrez au minimum l’exécution du pipeline et du notebook, la fenêtre d’entrée, le nombre de lignes ou de fichiers lus, le nombre de lignes produites et la durée des principales étapes. Comparez une exécution lente à une exécution normale portant sur un volume similaire. Des volumes différents constituent des expériences différentes.
Pourquoi cela se produit
Spark est lazy : les transformations de DataFrame construisent un plan, tandis que des actions comme count, l’affichage, la collecte et les écritures l’exécutent. Plusieurs actions de débogage peuvent donc relancer la même lineage coûteuse. Les opérations larges — notamment les jointures, les regroupements, les opérations distinct et le repartitionnement — peuvent déplacer les données entre les executors par un shuffle. Si quelques partitions sont très volumineuses, la plupart des tâches peuvent être terminées alors que quelques tâches retardataires dominent la durée totale.
La conception des entrées compte aussi. Lire une table entière puis filtrer les lignes peut empêcher l’élagage des partitions ou le data skipping. Sélectionner toutes les colonnes augmente les E/S et la sérialisation. Des milliers de petits fichiers ajoutent du travail de listing et d’ordonnancement. En sortie, un repartitionnement forcé et des ajouts répétés de très petite taille peuvent remplacer un problème par un autre.
Fabric ajoute une couche de session. Les charges compatibles peuvent réutiliser des sessions à forte concurrence ; d’autres configurations nécessitent une nouvelle session. Les starter pools peuvent réduire le temps d’acquisition lorsque leurs contraintes correspondent à la charge, mais ils représentent une voie rapide au mieux et non une garantie. La configuration personnalisée, les bibliothèques, les environnements et le réseau peuvent modifier le comportement au démarrage. Les recommandations Microsoft pour la supervision Spark et les vues détaillées des sessions aident à distinguer ces causes.
Une séquence de diagnostic
- Établir une référence. Choisissez une exécution normale avec des données comparables et notez sa durée totale ainsi que les mesures ci-dessous. Sans référence, « lent » n’est qu’une impression.
- Séparer démarrage et exécution. Comparez le début de l’activité, le moment où la session est prête et le premier job Spark. Le temps avant le premier job relève de la file ou du démarrage de session ; voir réduire le temps de démarrage des notebooks.
- Vérifier la file d’attente et la concurrence. Les notebooks lancés par des pipelines ou le planificateur attendent dans une file premier entré, premier sorti quand les cœurs Spark de la capacité sont occupés ; les exécutions interactives sont rejetées. Si les exécutions ne sont lentes qu’à certaines heures, regardez ce qui partage la capacité avant d’optimiser le code : le runbook de saturation de capacité Fabric (en anglais) couvre cette investigation.
- Vérifier la lecture. Octets et fichiers lus par les étapes de scan, filtres bien poussés jusqu’au scan, présence de nombreux petits fichiers.
- Vérifier le shuffle et le déséquilibre. Lecture et écriture de shuffle par étape, débordement, dispersion des durées de tâches : une tâche bien plus longue que la médiane signale un déséquilibre.
- Vérifier la logique de transformation. Actions répétées sur la même lignée, jointures sur des données non filtrées,
collect()outoPandas()sur de gros résultats, UDF Python dans les chemins critiques. - Vérifier l’écriture. Nombre et taille des fichiers produits, colonnes de partition, ajout, écrasement ou fusion.
- Changer une seule chose et relancer avec des données comparables.
- Comparer à la référence sur la durée et sur l’exactitude : nombres de lignes, doublons, lignes rejetées.
Quoi mesurer
| Mesure | Où la trouver | Ce qu’elle indique |
|---|---|---|
| Durée totale | Exécution du pipeline, hub de supervision | Si l’exécution est vraiment plus lente que sa référence |
| Temps de file et de démarrage de session | Hub de supervision, détails de session | Si du temps est perdu avant votre code |
| Durée par étape | Spark UI (Stages), page de détail de l’application Spark | Quelle phase domine |
| Durée des tâches, médiane vs maximum | Métriques de synthèse de l’étape dans la Spark UI | Déséquilibre : une tâche qui retient toute l’étape |
| Octets et fichiers lus | Métriques d’entrée de l’étape, nœud de scan du plan | Sur-lecture, élagage manquant, petits fichiers |
| Lecture/écriture de shuffle, débordement | Métriques de l’étape | Opérations larges coûteuses, pression mémoire |
| Nombre de tâches par étape | Détail de l’étape | Trop peu (cœurs inactifs) ou trop (surcoût d’ordonnancement) |
| Nombre et taille des fichiers produits | DESCRIBE DETAIL, historique de la table |
Écritures qui laissent de petits fichiers à tous les lecteurs suivants |
Petits fichiers
De nombreux petits fichiers rendent une table Delta lente à lire et à maintenir. Chaque fichier doit être listé et ouvert, ajoute une entrée au journal Delta et devient en général sa propre tâche : une lecture qui demanderait quelques tâches en planifie des milliers de très courtes. Les fusions et suppressions ont aussi davantage de fichiers à réécrire. La cause se trouve le plus souvent à l’écriture : petits ajouts fréquents, micro-lots de streaming ou sortie partitionnée sur une colonne à forte cardinalité.
Vérifiez la taille moyenne des fichiers avant de choisir une correction :
detail = spark.sql("DESCRIBE DETAIL SalesLakehouse.silver.orders").first()
avg_mb = detail.sizeInBytes / max(detail.numFiles, 1) / 1024**2
print({"files": detail.numFiles, "avg_file_mb": round(avg_mb, 1)})Une moyenne de quelques mégaoctets sur une grande table est un signal d’alerte. Compactez avec OPTIMIZE, envisagez Optimize Write pour les écritures fréquentes et regroupez les ajouts quand le pipeline le permet. Maintenance des tables Delta : OPTIMIZE et VACUUM (en anglais) explique quand et comment les exécuter sans risque.
Recommandations pratiques
Commencez par décomposer le temps. Si l’essentiel du délai précède le premier job Spark, examinez l’acquisition de session et les bibliothèques. Si une étape domine, inspectez ses jobs, tâches, entrées, shuffle, spills, skew et sorties. Si l’écriture domine, examinez le nombre de partitions, la taille des fichiers, le mode d’écriture et la conception de la table en aval.
Ne lisez que les colonnes et la période nécessaires. Placez les filtres sélectifs au plus près de la lecture et utilisez des prédicats cohérents avec la conception physique de la table. Vérifiez dans le plan exécuté que l’élagage ou le skipping a bien eu lieu : la syntaxe seule ne le prouve pas.
Réduisez le volume avant les opérations larges. Agrégez à la granularité nécessaire avant une jointure si cela préserve la justesse. Ne diffusez (« broadcast ») que des données de référence réellement petites, après les avoir mesurées. Évitez collect() et toPandas() sur de gros résultats, car ils transfèrent les données vers le driver. Pour l’inspection, utilisez des échantillons limités.
Mettez en cache uniquement un DataFrame coûteux à recalculer et réutilisé par plusieurs actions. Matérialisez-le volontairement, vérifiez la pression sur le stockage, puis libérez-le à la fin. Mettre en cache un DataFrame utilisé une seule fois ajoute du travail et consomme de la mémoire sans éviter de recalcul.
Pour une sortie Delta, choisissez append, overwrite ou merge selon le contrat des données. Évitez de repartitionner uniquement pour obtenir un nombre de fichiers souhaité : repartition provoque un shuffle, tandis que coalesce réduit le nombre de partitions sans redistribution complète, mais peut créer un déséquilibre. Évaluez Optimize Write, la compaction, V-Order et Z-Order selon la fréquence des écritures et les consommateurs. Microsoft indique que V-Order peut améliorer les lectures entre moteurs tout en augmentant le coût d’écriture Spark ; ce n’est donc pas un bouton universel d’accélération des notebooks.
Exemple de modèle
L’exemple rapproche la projection et le filtrage de la source, effectue une agrégation réutilisable et valide la sortie sans collecter toutes les données.
from pyspark.sql import functions as F
from pyspark.storagelevel import StorageLevel
run_date = "2026-10-02"
orders = (
spark.read.table("SalesLakehouse.silver.orders")
.select("order_id", "customer_id", "order_date", "status", "amount")
.where(F.col("order_date") == F.lit(run_date))
.where(F.col("status") == F.lit("Completed"))
)
daily_customer = (
orders.groupBy("customer_id")
.agg(
F.countDistinct("order_id").alias("order_count"),
F.sum("amount").alias("revenue"),
)
.persist(StorageLevel.MEMORY_AND_DISK)
)
output_rows = daily_customer.count()
(
daily_customer.write
.format("delta")
.mode("append")
.saveAsTable("SalesLakehouse.gold.daily_customer_sales")
)
print({"run_date": run_date, "output_rows": output_rows})
daily_customer.unpersist()Il s’agit d’un modèle, pas d’une prescription. Si daily_customer n’est utilisé que par l’écriture, supprimez la persistance et le count séparé, ou remplacez cette validation par une métrique calculée ailleurs. Si le traitement peut être relancé, un ajout aveugle peut dupliquer la date ; l’écriture idempotente relève du contrat du pipeline.
Utilisez explain("formatted") avant et après une modification importante. Recherchez les filtres proches du scan, les échanges inattendus, les stratégies de jointure et les branches répétées. Confirmez ensuite avec les jobs Spark exécutés, car les estimations et les plans ne révèlent pas toutes les conditions d’exécution.
Erreurs fréquentes
- Modifier les paramètres d’executor ou de shuffle avant d’avoir identifié l’étape lente.
- Appeler
count, afficher le résultat puis écrire en relançant la même lineage coûteuse non mise en cache. - Lire tout l’historique pour un traitement incrémentiel.
- Sélectionner toutes les colonnes « au cas où ».
- Diffuser une table de correspondance d’après son nombre de lignes sans tenir compte du volume en octets.
- Tout mettre en cache et provoquer de l’éviction ou de la pression de spill.
- Repartitionner chaque sortie en un seul fichier, ce qui détruit le parallélisme.
- Considérer la réutilisation d’une session comme une isolation sans contrainte : le calcul partagé nécessite toujours une configuration compatible et une bonne planification des charges.
- Comparer des exécutions portant sur des volumes différents et qualifier l’écart de régression.
Symptôme, cause probable, première vérification
| Symptôme | Cause probable | Première vérification |
|---|---|---|
| Long délai avant le premier job Spark | File d’attente, ou démarrage de session lent (cluster à la demande, bibliothèques) | Détails de session : origine du pool et raison du délai ; temps de file dans la supervision |
| Démarrage rapide, exécution lente | Volume lu, opérations larges ou écriture | Durée des étapes dans la Spark UI |
| Une étape domine | Gros scan, jointure ou agrégation | Octets lus, shuffle et débordement de cette étape |
| Des milliers de tâches très courtes | Petits fichiers ou trop de partitions | numFiles dans DESCRIBE DETAIL ; tâches par étape |
| Une tâche dure bien plus que les autres | Clé déséquilibrée dans une jointure ou une agrégation | Durée maximale vs médiane ; nombre de lignes par clé |
| L’écriture est lente | Nombreux fichiers ou partitions ; fusion dans une grande cible | Nombre de fichiers produits ; condition de fusion et taille de la cible |
| La durée varie selon l’heure | Contention de capacité ou file d’attente | Utilisation de la capacité et temps de file à ces heures |
| Spark termine vite mais le pipeline est en retard | Dépendance en aval ou attente d’orchestration | La chronologie des activités du pipeline, pas la Spark UI |
Modifiez une variable comprise, relancez sur des données comparables et gardez des contrôles d’exactitude à côté des mesures de performance. Un notebook plus rapide qui perd des lignes sans correspondance, duplique une partition ou change le grain métier est une optimisation ratée.
Voir aussi
- Réduire le temps de démarrage des notebooks Fabric et utiliser les session tags dans les pipelines Fabric, quand le temps se perd avant le code
- Augmenter la limite de sessions en haute concurrence (en anglais)
- Dépanner les performances de Microsoft Fabric en production (en anglais), pour les problèmes qui dépassent un notebook
- Superviser les pipelines et notebooks Fabric, pour conserver la référence de comparaison
Sources
- Microsoft Learn : bonnes pratiques de supervision Spark, supervision détaillée des applications Spark, mise en file des jobs Spark, optimisation des tables Delta et V-Order
- Apache Spark : SQL performance tuning (exécution adaptative des requêtes, gestion du déséquilibre), Web UI
Comportement de Fabric vérifié sur Microsoft Learn en novembre 2026.
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émoirePerformance des notebooks FabricDiagnostiquez et améliorez les performances des notebooks Microsoft Fabric en distinguant les goulots d’étranglement liés au démarrage de la session Spark, au scan des données, au shuffle, au skew, à la pression sur le driver, à la concurrence et à l’écriture.Ouvrir l’aide-mémoire
- Feuille de routeMicrosoft Fabric Notebook PerformanceUne méthode pratique pour réduire le temps de démarrage, de lecture, de shuffle, de transformation et d’écriture Delta des notebooks Fabric sans deviner.Voir la feuille de route
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.