Parcourir les aide-mémoire · Microsoft Fabric
Performance des notebooks Fabric
Diagnostiquez 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.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Mesurer l’action Spark, pas seulement la construction du DataFrame
- 2. Inspecter le plan physique
- 3. Vérifier le nombre actuel de partitions
- 4. Inspecter la distribution des lignes par partition
- 5. Filtrer avant les transformations coûteuses
- 6. Éviter select("*") lorsque seules quelques colonnes sont nécessaires
- 7. Inspecter la stratégie de jointure
- 8. Diffuser (broadcast) une table de référence réellement petite
- 9. Vérifier les clés de jointure en double avant d’accuser Spark
- 10. Réduire les données avant une jointure volumineuse
- 11. Rechercher les clés de jointure ou de regroupement présentant du skew
- 12. Éviter collect() pour les résultats volumineux
- 13. Éviter les appels toPandas() inutiles
- 14. Éviter les boucles Python sur les lignes Spark
- 15. Préférer les expressions Spark intégrées aux UDF Python
- 16. Mettre en cache uniquement les DataFrames réutilisés
- 17. Vérifier l’état du cache
- 18. Éviter les actions répétées inutiles
- 19. Inspecter la configuration Spark pertinente pour la session
- 20. Inspecter les paramètres importants de l’exécution adaptative
- 21. Repartitionner lorsque vous avez besoin d’une véritable redistribution
- 22. Utiliser coalesce pour réduire les partitions sans shuffle complet
- 23. Éviter repartition(1) pour les sorties de production volumineuses
- 24. Vérifier si les petits fichiers font partie du problème
- 25. N’écrire que les colonnes nécessaires
- 26. Utiliser overwrite en connaissance de cause
- 27. Cesser de comparer des exécutions de notebook portant sur des volumes d’entrée différents
- 28. Distinguer la latence de démarrage de l’exécution Spark
- 29. Utiliser les starter pools Fabric pour accélérer le démarrage des sessions lorsque c’est pertinent
- 30. Utiliser High Concurrency lorsque des notebooks compatibles peuvent partager une session
- 31. Utiliser un session tag pour réutiliser les sessions des notebooks de pipeline lorsque High Concurrency est activé
- 32. Ne pas créer une activité de notebooks parallèle excessive
- 33. Utiliser l’autoscale et l’allocation dynamique des executors pour les charges variables lorsque c’est pertinent
- 34. N’envisager le Native Execution Engine que lorsqu’il est pris en charge et validé
- 35. Utiliser la supervision Spark pour trouver l’étape qui domine la durée d’exécution
- Interpréter le résultat
- Points à vérifier
- Le démarrage domine la durée totale
- Une étape comporte une ou quelques tâches retardataires
- Le shuffle domine la durée d’exécution
- Le driver échoue ou ralentit
- La durée d’exécution varie fortement pour un code similaire
- La sortie crée de nombreux petits fichiers
- Notes de production
- La performance des notebooks Fabric comporte deux couches distinctes
- High Concurrency obéit à des règles de compatibilité
- La densité actuelle de High Concurrency est configurable
- Il n’existe pas d’instantanés de type DMV pour Spark comme dans SQL Server
- La capacité et le dimensionnement des pools comptent une fois les problèmes de code compris
- La mise en file d’attente peut relever de la capacité plutôt que du code du notebook
- L’autotune dépend de la version et des fonctionnalités
- Mesurer avec des données représentatives de la volumétrie de production
- Erreurs fréquentes
- 1. Augmenter la capacité de calcul Spark avant d’avoir trouvé le goulot d’étranglement
- 2. Ne chronométrer que les transformations DataFrame
- 3. Utiliser repartition(1) pour obtenir un seul fichier de sortie
- 4. Mettre en cache chaque DataFrame
- 5. Diffuser (broadcast) une table sans vérifier sa taille
- 6. Utiliser des UDF Python pour des opérations que Spark prend déjà en charge
- 7. Ignorer le skew des données
- 8. Augmenter la concurrence des notebooks à l’aveugle
- 9. Confondre le démarrage de la session avec la durée d’exécution de la requête
- 10. Optimiser le code en ignorant l’organisation des fichiers
- Étape suivante
- Pour aller plus loin
Problème
Un notebook Microsoft Fabric est lent, irrégulier ou consomme plus de capacité Spark que prévu.
Le délai peut provenir de sources très différentes :
- le démarrage de la session Spark
- la lecture d’un volume de données trop important
- un trop grand nombre de petits fichiers
- un partitionnement inadapté
- des jointures ou agrégations générant beaucoup de shuffle
- le skew des données
- du code Python exécuté sur le driver
- des appels
collect()/toPandas()inutiles - des recalculs répétés
- une concurrence excessive entre notebooks
- une capacité de calcul Spark sous-dimensionnée ou surdimensionnée
- des écritures Delta lentes
- plusieurs notebooks qui démarrent inutilement des sessions Spark distinctes
L’objectif est d’identifier où le temps est consommé avant de modifier les paramètres Spark.
Réponse rapide
Suivez cette démarche :
1. Séparer le temps de démarrage de session du temps d’exécution du notebook
2. Identifier l’action / le stage Spark lent
3. Examiner le plan physique
4. Vérifier le volume de données lues
5. Vérifier les partitions et le shuffle
6. Vérifier la présence de skew
7. Vérifier les collectes côté driver / boucles Python
8. Vérifier les recalculs répétés
9. Vérifier l’organisation des fichiers et le mode d’écriture Delta
10. Vérifier le dimensionnement du pool, l’autoscale, la concurrence et la réutilisation de session
11. Modifier un seul élément et mesurer à nouveau
Commencez par l’opération que vous pensez lente :
from time import perf_counter
start = perf_counter()
result = (
spark.read.format("delta")
.load("Tables/sales")
.filter("sale_date >= '2026-10-01'")
.groupBy("merchant_id")
.sum("amount")
)
result.count() # force execution
elapsed = perf_counter() - start
print(f"Elapsed: {elapsed:.2f} seconds")
Inspectez ensuite le plan :
result.explain("formatted")
N’ajustez pas la configuration Spark tant que vous ne savez pas si le goulot d’étranglement se situe au niveau du scan, du shuffle, du skew, de la capacité de calcul, du démarrage ou du driver.
Code / commandes
1. Mesurer l’action Spark, pas seulement la construction du DataFrame
Les DataFrames Spark sont évalués de manière paresseuse (lazy).
Ce code :
start = perf_counter()
result = (
df.filter("amount > 100")
.groupBy("merchant_id")
.sum("amount")
)
print(perf_counter() - start)
mesure surtout la construction du plan logique.
Forcez une action :
from time import perf_counter
start = perf_counter()
result = (
df.filter("amount > 100")
.groupBy("merchant_id")
.sum("amount")
)
row_count = result.count()
elapsed = perf_counter() - start
print("Rows:", row_count)
print(f"Elapsed: {elapsed:.2f} seconds")
Utilisez une action représentative.
N’ajoutez pas un collect() volumineux uniquement pour faire un benchmark.
2. Inspecter le plan physique
result.explain("formatted")
Faites-le avant de modifier le nombre de partitions ou la taille de la capacité de calcul.
Recherchez :
- les scans
- les filtres
- les jointures
- les échanges (exchanges)
- les tris
- les agrégations
- les broadcast joins
- les scans répétés
Un Exchange signifie généralement que Spark doit redistribuer les données entre les partitions.
Ce n’est pas forcément un problème, mais les échanges volumineux ou répétés méritent votre attention.
3. Vérifier le nombre actuel de partitions
print(df.rdd.getNumPartitions())
Après un shuffle :
result = (
df.groupBy("merchant_id")
.sum("amount")
)
print(result.rdd.getNumPartitions())
Le nombre de partitions ne suffit pas à lui seul à dire si la charge de travail est saine.
Vous devez le comparer avec :
- le volume de données
- la distribution de la taille des partitions
- le nombre d’executors
- la durée des tâches
- le skew
4. Inspecter la distribution des lignes par partition
Pour un diagnostic ciblé :
from pyspark.sql import functions as F
partition_rows = (
df.withColumn(
"_partition_id",
F.spark_partition_id(),
)
.groupBy("_partition_id")
.count()
.orderBy(F.desc("count"))
)
partition_rows.show(50, truncate=False)
Utilisez cette requête lorsque vous soupçonnez du skew.
Si un petit nombre de partitions contient beaucoup plus de lignes que les autres, ces tâches peuvent dominer la durée de l’étape.
Le nombre de lignes n’est qu’un indicateur : des lignes de largeur variable peuvent avoir des tailles en octets différentes.
5. Filtrer avant les transformations coûteuses
Préférez :
filtered = (
spark.read.format("delta")
.load("Tables/sales")
.filter(F.col("sale_date") >= "2026-10-01")
.select(
"merchant_id",
"sale_date",
"amount",
)
)
au chargement de données larges dont toutes les colonnes sont transportées à travers les jointures et les agrégations.
Appliquez :
- les filtres
- la sélection des colonnes
aussi tôt que possible.
Cela réduit la quantité de données traitées en aval.
6. Éviter select("*") lorsque seules quelques colonnes sont nécessaires
Au lieu de :
df = (
spark.read.format("delta")
.load("Tables/sales")
.select("*")
)
préférez :
df = (
spark.read.format("delta")
.load("Tables/sales")
.select(
"sale_id",
"merchant_id",
"sale_date",
"amount",
)
)
L’élagage des colonnes compte surtout sur les tables analytiques larges.
7. Inspecter la stratégie de jointure
joined = sales.join(
merchants,
on="merchant_id",
how="left",
)
joined.explain("formatted")
Vérifiez si Spark choisit :
- un broadcast hash join
- un sort-merge join
- une autre stratégie
Ne forcez pas un broadcast tant que vous ne savez pas si le plus petit côté se prête au broadcast.
8. Diffuser (broadcast) une table de référence réellement petite
Lorsque vous avez vérifié que la table de référence est suffisamment petite :
from pyspark.sql import functions as F
joined = sales.join(
F.broadcast(merchants),
on="merchant_id",
how="left",
)
Inspectez à nouveau :
joined.explain("formatted")
Le broadcast évite de redistribuer par shuffle le côté volumineux pour certains types de jointures.
Ne diffusez pas une grande table simplement parce qu’une jointure est lente.
9. Vérifier les clés de jointure en double avant d’accuser Spark
Une jointure peut être lente parce qu’elle multiplie les lignes.
Vérifiez la cardinalité des clés :
duplicate_keys = (
merchants.groupBy("merchant_id")
.count()
.filter(F.col("count") > 1)
)
duplicate_keys.show(50, truncate=False)
Si une table censée être une dimension n’est pas unique, une jointure peut :
- multiplier les lignes
- augmenter le volume de shuffle
- accroître la pression mémoire
- gonfler les métriques en aval
Corrigez la relation entre les données avant d’ajuster le cluster.
10. Réduire les données avant une jointure volumineuse
Préférez :
sales_small = (
sales
.filter(F.col("sale_date") >= "2026-10-01")
.select(
"merchant_id",
"amount",
)
)
merchants_small = merchants.select(
"merchant_id",
"region",
)
joined = sales_small.join(
merchants_small,
"merchant_id",
"left",
)
Filtrer et projeter d’abord peut réduire sensiblement le travail de shuffle.
11. Rechercher les clés de jointure ou de regroupement présentant du skew
Commencez par :
(
df.groupBy("merchant_id")
.count()
.orderBy(F.desc("count"))
.show(50, truncate=False)
)
Une clé très « chaude » peut envoyer une quantité disproportionnée de données vers une seule partition.
Exemples courants :
- une clé par défaut ou inconnue
- un remplacement des valeurs nulles par une valeur comme
0 - un très gros client
- un commerçant dominant
- des données mal formées qui regroupent de nombreux enregistrements sur une seule clé
N’ajoutez pas immédiatement un salage aléatoire (salting).
Identifiez d’abord la clé concernée et confirmez la raison métier.
12. Éviter collect() pour les résultats volumineux
Risqué :
rows = df.collect()
Cela envoie l’intégralité du résultat au driver.
Plus sûr pour l’inspection :
df.show(20, truncate=False)
ou :
rows = df.limit(100).collect()
N’utilisez la collecte complète que lorsque le résultat est volontairement petit.
13. Éviter les appels toPandas() inutiles
Risqué :
pdf = df.toPandas()
Le DataFrame pandas obtenu doit tenir dans la mémoire du driver.
Pour l’inspection :
pdf = (
df.limit(1000)
.toPandas()
)
Pour les transformations volumineuses, gardez le traitement distribué dans Spark.
14. Éviter les boucles Python sur les lignes Spark
Mauvaise pratique :
for row in df.collect():
process(row)
Préférez les transformations Spark :
result = (
df.withColumn(
"net_amount",
F.col("amount") - F.col("discount"),
)
)
Faire passer les données dans Python ligne par ligne supprime l’avantage de l’exécution distribuée de Spark.
15. Préférer les expressions Spark intégrées aux UDF Python
Préférez :
df = df.withColumn(
"normalized_email",
F.lower(
F.trim(F.col("email"))
),
)
à une UDF Python pour les opérations déjà disponibles dans les fonctions Spark SQL.
Les expressions intégrées donnent à Spark davantage de possibilités d’optimiser l’exécution et évitent le coût de sérialisation Python.
N’utilisez une UDF que lorsque la logique requise ne peut pas être exprimée avec les fonctions Spark intégrées ou avec un autre mécanisme pris en charge plus efficace.
16. Mettre en cache uniquement les DataFrames réutilisés
Si le même résultat coûteux est réutilisé plusieurs fois :
filtered = (
df.filter(F.col("sale_date") >= "2026-10-01")
.select(
"merchant_id",
"amount",
)
.cache()
)
Matérialisez-le :
filtered.count()
Réutilisez-le :
by_merchant = (
filtered.groupBy("merchant_id")
.sum("amount")
)
total = filtered.agg(
F.sum("amount")
)
Une fois terminé :
filtered.unpersist()
Ne mettez pas en cache chaque DataFrame.
Mettre en cache des données utilisées une seule fois ajoute généralement du travail au lieu d’en supprimer.
17. Vérifier l’état du cache
print(filtered.storageLevel)
Utilisez cette commande pour vérifier si un DataFrame est réellement persisté.
N’oubliez pas que cache() reste paresseux tant qu’une action ne le matérialise pas.
18. Éviter les actions répétées inutiles
Ce code déclenche plusieurs jobs :
print(df.count())
print(df.filter(F.col("status") == "failed").count())
print(df.agg(F.sum("amount")).collect())
Cela peut être acceptable, mais chaque action peut recalculer la lineage en amont si l’entrée n’est pas mise en cache ou matérialisée d’une autre manière.
Si plusieurs actions réutilisent un préfixe commun coûteux, envisagez de matérialiser ce préfixe une seule fois.
19. Inspecter la configuration Spark pertinente pour la session
for key, value in sorted(
spark.sparkContext.getConf().getAll()
):
print(f"{key}={value}")
Utilisez ce code lorsque :
- les performances diffèrent d’un environnement à l’autre
- un notebook se comporte différemment d’un pipeline
- vous soupçonnez des différences de configuration de session
Ne modifiez pas la configuration simplement parce qu’une valeur vous semble inhabituelle.
20. Inspecter les paramètres importants de l’exécution adaptative
keys = [
"spark.sql.adaptive.enabled",
"spark.sql.shuffle.partitions",
"spark.sql.autoBroadcastJoinThreshold",
]
for key in keys:
try:
print(
key,
spark.conf.get(key),
)
except Exception:
print(
key,
"<not available>",
)
L’Adaptive Query Execution peut modifier la stratégie d’exécution physique en fonction des informations obtenues à l’exécution.
Considérez l’ajustement manuel de spark.sql.shuffle.partitions comme propre à chaque charge de travail, et non comme une solution universelle.
21. Repartitionner lorsque vous avez besoin d’une véritable redistribution
repartitioned = df.repartition(
200,
"merchant_id",
)
Utilisez repartition() lorsque vous devez volontairement redistribuer les données, par exemple avant une opération répétée utilisant la même clé de partitionnement.
Cela crée un shuffle.
Ne repartitionnez pas à l’aveugle.
22. Utiliser coalesce pour réduire les partitions sans shuffle complet
smaller = df.coalesce(20)
C’est utile pour réduire le nombre de partitions en sortie lorsque la charge de travail est déjà devenue petite.
coalesce() évite généralement un shuffle complet lors de la réduction du nombre de partitions.
Il peut produire des partitions déséquilibrées ; validez donc la charge de travail obtenue.
23. Éviter repartition(1) pour les sorties de production volumineuses
Risqué :
df.repartition(1).write.parquet(
"Files/export"
)
Cela fait passer toute la sortie par une seule partition et peut créer un goulot d’étranglement important.
Si un consommateur en aval exige un fichier unique, traitez-le comme une exigence d’export et utilisez un processus dédié et contrôlé après la transformation distribuée.
24. Vérifier si les petits fichiers font partie du problème
Une table contenant de nombreux fichiers minuscules peut augmenter le coût de planification et d’ouverture des fichiers.
Inspectez l’organisation de la source côté Lakehouse/OneLake lorsqu’un scan est anormalement coûteux.
Pour les tables Delta, utilisez les fonctionnalités de maintenance et d’optimisation appropriées prises en charge par Fabric plutôt que de fusionner manuellement les fichiers dans le code du notebook.
N’optimisez pas une table uniquement parce que le nombre de fichiers est élevé ; confirmez que la charge de travail est affectée.
25. N’écrire que les colonnes nécessaires
output = result.select(
"merchant_id",
"sale_date",
"amount",
)
(
output.write
.format("delta")
.mode("append")
.save("Tables/curated_sales")
)
Évitez de transporter des colonnes temporaires ou de débogage dans les tables de production.
26. Utiliser overwrite en connaissance de cause
Cette opération est destructrice pour les données cibles qu’elle couvre :
(
result.write
.format("delta")
.mode("overwrite")
.save("Tables/curated_sales")
)
N’utilisez pas overwrite simplement pour faciliter les réexécutions.
Choisissez entre :
- append
- merge/upsert
- remplacement de partitions
- reconstruction complète
en fonction du contrat de données du pipeline.
27. Cesser de comparer des exécutions de notebook portant sur des volumes d’entrée différents
Enregistrez le contexte d’exécution de base :
input_rows = df.count()
print(
"Input rows:",
input_rows,
)
Le nombre de lignes ne suffit pas à lui seul, mais les comparaisons de performances sont peu fiables lorsque les exécutions traitent des volumes de données sensiblement différents.
Suivez également, lorsque c’est utile :
- la plage de dates de la source
- le nombre de fichiers
- les partitions
- les lignes en sortie
- la cardinalité des jointures
28. Distinguer la latence de démarrage de l’exécution Spark
La durée réelle (wall-clock) d’un notebook peut inclure :
acquisition de la session
+ démarrage de Spark
+ initialisation de l’environnement
+ initialisation des bibliothèques
+ travail Spark réel
Si les étapes Spark d’un notebook s’exécutent rapidement mais que le notebook reste long de bout en bout, optimisez la réutilisation et le démarrage des sessions plutôt que de réécrire le code DataFrame.
29. Utiliser les starter pools Fabric pour accélérer le démarrage des sessions lorsque c’est pertinent
Les starter pools sont conçus pour réduire la latence de démarrage des sessions Spark en utilisant, lorsqu’elle est disponible, une capacité de calcul préchauffée gérée par Microsoft.
Ils sont surtout utiles lorsque :
- les notebooks sont courts
- le démarrage représente une part significative de la durée d’exécution
- le développement interactif nécessite une acquisition rapide de session
La disponibilité des starter pools relève du meilleur effort : une session peut encore basculer vers un provisionnement standard lorsque aucune capacité préchauffée n’est disponible.
Ne confondez pas l’optimisation du démarrage avec l’optimisation de l’exécution des requêtes.
30. Utiliser High Concurrency lorsque des notebooks compatibles peuvent partager une session
Le mode High Concurrency (forte concurrence) de Fabric permet à des charges de travail de notebooks compatibles de partager une application Spark en cours d’exécution au lieu de créer une session Spark distincte pour chacune.
C’est utile pour :
- les groupes d’activités de notebook
- les notebooks courts dont le démarrage domine
- l’orchestration de notebooks en parallèle
- l’amélioration de l’utilisation des ressources Spark
Le partage de session exige un contexte de charge de travail compatible, notamment le même périmètre utilisateur, le même Lakehouse par défaut et la même configuration de calcul Spark.
Ne supposez pas que chaque notebook partagera la même session.
31. Utiliser un session tag pour réutiliser les sessions des notebooks de pipeline lorsque High Concurrency est activé
Pour les activités Notebook des pipelines Fabric, un session tag peut diriger les activités compatibles vers la réutilisation d’une session Spark existante.
Utilisez un tag cohérent pour les notebooks destinés à partager la capacité de calcul.
Il s’agit avant tout d’une optimisation du démarrage et de la réutilisation des sessions.
Elle ne rend pas plus rapide une requête Spark lente en elle-même.
32. Ne pas créer une activité de notebooks parallèle excessive
L’exécution parallèle de notebooks partage toujours des ressources Spark limitées.
Si de nombreux notebooks enfants s’exécutent simultanément, ils peuvent se disputer :
- le CPU
- la mémoire
- les executors
- les ressources de shuffle
Plus de concurrence ne signifie pas automatiquement plus de débit.
Lorsque vous utilisez une orchestration de notebooks, comme l’exécution parallèle de notebooks, ajustez la concurrence en fonction de la capacité de calcul Spark disponible au lieu de la maximiser à l’aveugle.
33. Utiliser l’autoscale et l’allocation dynamique des executors pour les charges variables lorsque c’est pertinent
Les pools Spark de Fabric peuvent utiliser l’autoscale et l’allocation dynamique des executors.
Cela peut aider lorsque la taille de la charge de travail varie fortement.
Surveillez néanmoins :
- le comportement de mise à l’échelle
- la mise en file d’attente
- la durée d’exécution
- la consommation de capacité
L’autoscale ne peut pas compenser un code pathologique, comme des jointures cartésiennes accidentelles ou la collecte de résultats massifs vers le driver.
34. N’envisager le Native Execution Engine que lorsqu’il est pris en charge et validé
Fabric propose le Native Execution Engine pour les charges de travail Spark prises en charge.
Il peut améliorer les opérations prises en charge, mais doit être considéré comme une option de moteur d’exécution plutôt que comme un substitut à :
- une bonne organisation des données
- des jointures correctes
- l’élagage des partitions
- l’absence de skew
- une capacité de calcul correctement dimensionnée
Validez la compatibilité et mesurez votre charge de travail réelle avant d’en faire un standard.
35. Utiliser la supervision Spark pour trouver l’étape qui domine la durée d’exécution
Lorsqu’un notebook est lent, examinez les informations de supervision Spark de Fabric et de l’interface Spark UI concernant :
- la durée des étapes
- la durée des tâches
- la taille des entrées
- les lectures/écritures de shuffle
- les tâches échouées ou relancées
- l’utilisation des executors
- les tâches affectées par le skew
La cellule du notebook vous indique où, dans le notebook.
Les informations sur les étapes et les tâches Spark vous indiquent où, dans l’exécution distribuée.
Utilisez les deux.
Interpréter le résultat
| Signal | Ce qu’il indique généralement |
|---|---|
| Long délai avant le premier travail Spark | Acquisition ou démarrage de la session, initialisation de l’environnement |
| Scan volumineux | Trop de données en entrée ou élagage insuffisant |
Exchange dans le plan |
Redistribution des données / shuffle |
| Une tâche beaucoup plus lente que les autres | Skew possible ou taille de partition déséquilibrée |
| Lectures/écritures de shuffle élevées | Pression liée aux jointures, agrégations ou redistributions |
| Pression mémoire sur le driver | Trop de données déplacées vers le driver ou objets locaux volumineux |
| Étapes identiques répétées | Lineage recalculée ou actions répétées |
| Forte augmentation du nombre de lignes après une jointure | Problème de cardinalité de jointure |
| Nombreux fichiers de sortie minuscules | Écriture avec un nombre excessif de partitions |
| Notebook rapide en interactif mais lent dans un pipeline | Des différences de session, de démarrage, de configuration ou de concurrence peuvent jouer |
| Plusieurs notebooks courts démarrent chacun Spark | Opportunité de réutilisation de session / High Concurrency |
Points à vérifier
Le démarrage domine la durée totale
Si l’exécution Spark elle-même est courte, examinez :
- les starter pools
- High Concurrency
- les session tags de pipeline
- les activités de notebook distinctes inutiles
N’optimisez pas une requête Spark de 10 secondes pour résoudre un problème de démarrage de 2 minutes.
Une étape comporte une ou quelques tâches retardataires
Les causes probables sont notamment :
- le skew des clés
- des partitions déséquilibrées
- un fichier ou une partition anormalement volumineux
- la pression sur les executors
Inspectez la distribution des partitions et des clés.
Le shuffle domine la durée d’exécution
Examinez :
- la stratégie de jointure
- les clés de regroupement
- les repartitionnements inutiles
- le volume de données avant le shuffle
- la possibilité de diffuser (broadcast) une petite table de référence
- le skew
Le driver échoue ou ralentit
Recherchez :
collect()toPandas()- des listes ou dictionnaires Python volumineux
- un traitement Python ligne par ligne
- l’affichage de résultats volumineux dans le notebook
Gardez les données volumineuses distribuées.
La durée d’exécution varie fortement pour un code similaire
Comparez :
- le volume d’entrée
- le nombre de fichiers
- le plan
- la configuration Spark
- le pool et le mode de session
- les charges de travail concurrentes
- le skew
Ne comparez pas des durées réelles sans contexte de charge de travail équivalent.
La sortie crée de nombreux petits fichiers
Recherchez un nombre excessif de partitions lors de l’étape d’écriture.
Réduisez volontairement le nombre de partitions lorsque la sortie est déjà petite, mais évitez de forcer une seule partition pour les sorties volumineuses.
Notes de production
La performance des notebooks Fabric comporte deux couches distinctes
Traitez-les séparément :
surcoût de session/plateforme Fabric
exécution de la charge de travail Spark
Les optimisations au niveau de la plateforme et des sessions comprennent :
- les starter pools
- High Concurrency
- la réutilisation des sessions
- le dimensionnement des pools
Les optimisations Spark comprennent :
- l’élagage (pruning)
- la stratégie de jointure
- le partitionnement
- la réduction du skew
- l’absence de collecte vers le driver
- l’organisation des fichiers
Mélanger ces couches conduit à un mauvais diagnostic.
High Concurrency obéit à des règles de compatibilité
Les charges de travail compatibles peuvent partager une application Spark, mais le partage de session n’est pas universel.
Des différences de Lakehouse ou de configuration de calcul Spark peuvent entraîner des sessions distinctes.
Concevez l’orchestration des notebooks en tenant compte de cette contrainte.
La densité actuelle de High Concurrency est configurable
Fabric prend en charge une limite configurable de notebooks partagés grâce à la propriété Spark d’Environment :
spark.highConcurrency.max
La valeur par défaut est inférieure au maximum de la plateforme.
Augmenter la concurrence peut améliorer la densité des sessions, mais cela accroît aussi la concurrence pour les ressources au sein de la session Spark partagée.
Ajustez-la à partir du comportement mesuré de la charge de travail plutôt que de fixer automatiquement le maximum.
Il n’existe pas d’instantanés de type DMV pour Spark comme dans SQL Server
L’analyse des performances repose largement sur :
- les plans physiques
- les étapes et tâches Spark
- les métriques des executors
- la supervision Fabric
- l’historique des charges de travail et des exécutions
Capturez les métadonnées d’exécution si vous avez besoin de comparaisons avant/après.
La capacité et le dimensionnement des pools comptent une fois les problèmes de code compris
Un pool plus grand peut accélérer une charge de travail.
Il peut aussi rendre un code inefficace plus coûteux.
Corrigez les scans évitables, la multiplication des lignes, le skew et la collecte vers le driver avant de faire de la taille de la capacité de calcul votre principale stratégie d’optimisation.
La mise en file d’attente peut relever de la capacité plutôt que du code du notebook
Si les jobs passent du temps à attendre l’acquisition de ressources Spark, examinez :
- la concurrence au niveau de l’espace de travail et de la capacité
- la consommation Spark actuelle
- les jobs parallèles
- la pertinence de High Concurrency
- la configuration des pools
N’interprétez pas le temps d’attente en file comme du temps de transformation Spark.
L’autotune dépend de la version et des fonctionnalités
Fabric dispose de fonctionnalités d’ajustement automatique de Spark (autotune), mais leur disponibilité et leur compatibilité dépendent du runtime et de la configuration des fonctionnalités.
Ne bâtissez pas une stratégie de performance en production autour de l’autotune sans vérifier le runtime et le mode de charge de travail actuellement pris en charge.
Mesurer avec des données représentatives de la volumétrie de production
Un notebook rapide sur :
100 000 lignes
peut se comporter très différemment sur :
500 millions de lignes
en raison :
- du shuffle
- du skew
- du nombre de partitions
- de l’organisation des fichiers
- de la pression mémoire
Les tests de performance doivent ressembler à la charge de travail réelle.
Erreurs fréquentes
1. Augmenter la capacité de calcul Spark avant d’avoir trouvé le goulot d’étranglement
Davantage de capacité de calcul ne corrige pas :
- les mauvaises jointures
- l’explosion du nombre de lignes
collect()- le skew
- les scans répétés
Mesurez d’abord.
2. Ne chronométrer que les transformations DataFrame
Spark est paresseux (lazy).
Sans action, vous risquez de chronométrer la construction du plan plutôt que l’exécution.
3. Utiliser repartition(1) pour obtenir un seul fichier de sortie
Cela crée un goulot d’étranglement sur une seule partition.
Traitez l’export vers un fichier unique comme une exigence distincte.
4. Mettre en cache chaque DataFrame
La mise en cache a un coût de matérialisation et de mémoire.
Ne mettez en cache que les données coûteuses qui seront réutilisées.
5. Diffuser (broadcast) une table sans vérifier sa taille
Un broadcast trop volumineux peut créer une pression mémoire.
Validez d’abord le petit côté.
6. Utiliser des UDF Python pour des opérations que Spark prend déjà en charge
Les expressions Spark intégrées offrent généralement à l’optimiseur un meilleur chemin d’exécution.
7. Ignorer le skew des données
La taille moyenne des partitions peut sembler correcte alors qu’une seule clé « chaude » détermine la durée de l’étape.
Inspectez la distribution.
8. Augmenter la concurrence des notebooks à l’aveugle
Des notebooks parallèles peuvent se disputer les mêmes ressources limitées.
Optimisez le débit, pas le nombre maximal d’activités parallèles.
9. Confondre le démarrage de la session avec la durée d’exécution de la requête
Un notebook peut être lent avant même que la transformation Spark ne commence.
Mesurez séparément le démarrage et l’exécution.
10. Optimiser le code en ignorant l’organisation des fichiers
De nombreux petits fichiers ou une mauvaise organisation des partitions peuvent ralentir une transformation DataFrame pourtant bien écrite.
Inspectez le côté stockage lorsque la planification du scan domine.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
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.