Parcourir les aide-mémoire · PySpark

Technologie: PySparkCatégorie: PerformanceNiveau: IntermédiaireMis à jour

PySpark : référence rapide des performances

Diagnostiquez et optimisez les charges de travail PySpark en distinguant les problèmes de scan, de shuffle, de skew, de partitionnement, de cache, de jointures, de pression sur le driver et d’organisation des fichiers avant de modifier la taille du cluster.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Mesurer une action, pas la construction de transformations lazy
  5. 2. Inspecter le plan physique
  6. 3. Réduire les colonnes au plus tôt
  7. 4. Filtrer au plus tôt
  8. 5. Inspecter le nombre de partitions
  9. 6. Inspecter la distribution des lignes par partition
  10. 7. Vérifier le skew des clés
  11. 8. Ne pas corriger le skew en ajoutant d’abord de la capacité de calcul
  12. 9. Vérifier la cardinalité de la jointure avant d’en optimiser les performances
  13. 10. Diffuser (broadcast) une table de référence réellement petite
  14. 11. Projeter avant le broadcast
  15. 12. Éviter de collecter les données de référence sur le driver
  16. 13. Éviter les collect() volumineux
  17. 14. Éviter les toPandas() inutiles
  18. 15. Préférer les fonctions intégrées aux UDF Python
  19. 16. N’utiliser les UDF Python qu’en cas de nécessité
  20. 17. Ne mettre en cache que les résultats intermédiaires coûteux et réutilisés
  21. 18. Ne pas mettre en cache les résultats intermédiaires utilisés une seule fois
  22. 19. Vérifier si les données sont persistées
  23. 20. Éviter les actions répétées sur la même lineage coûteuse
  24. 21. Agréger plusieurs métriques en une seule passe
  25. 22. Ne repartitionner que lorsqu’une redistribution est nécessaire
  26. 23. Repartitionner par clé pour des opérations répétées sur cette clé
  27. 24. Utiliser coalesce() pour réduire le nombre de partitions
  28. 25. Éviter repartition(1)
  29. 26. Vérifier le paramètre des partitions de shuffle
  30. 27. Inspecter l’Adaptive Query Execution
  31. 28. Vérifier le seuil de broadcast
  32. 29. Éviter les tris inutiles
  33. 30. Éviter les partitions de fenêtre trop larges
  34. 31. Filtrer avant les fonctions de fenêtrage lorsque la sémantique le permet
  35. 32. Vérifier le nombre de fichiers et les problèmes de petits fichiers
  36. 33. Compacter les petits fichiers Delta lorsque c’est justifié
  37. 34. Utiliser l’élagage des partitions
  38. 35. Éviter d’envelopper inutilement les colonnes de partition
  39. 36. Éviter un partitionnement physique à forte cardinalité
  40. 37. Comparer les formats de fichiers
  41. 38. Conserver des décimaux exacts pour les charges de travail financières
  42. 39. Éviter si possible d’éclater les tableaux avant de filtrer
  43. 40. Valider l’augmentation du nombre de lignes après explode()
  44. 41. Utiliser les semi/anti joins pour les contrôles d’existence
  45. 42. Éviter les jointures complètes lorsque seule l’existence compte
  46. 43. Vérifier le comportement des étapes et des tâches, pas seulement la durée du notebook
  47. 44. Interpréter avec prudence les tâches retardataires
  48. 45. Suivre la taille des entrées pour comparer les exécutions
  49. 46. Distinguer le démarrage de l’exécution
  50. 47. Ne pas commencer par augmenter la taille du cluster
  51. 48. Ajuster une seule variable à la fois
  52. 49. Conserver les contrôles d’exactitude pendant l’optimisation
  53. 50. Utiliser une démarche de diagnostic compacte
  54. Interpréter le résultat
  55. Points à vérifier
  56. Le temps d’exécution a augmenté après une jointure
  57. Une tâche domine une étape
  58. La mémoire du driver augmente
  59. La même lineage s’exécute plusieurs fois
  60. Les lectures sont lentes alors que les transformations sont simples
  61. Le shuffle comporte des milliers de très petites tâches
  62. Le shuffle comporte quelques tâches énormes
  63. Notes de production
  64. L’optimisation des performances dépend de la charge de travail
  65. Spark est lazy
  66. L’AQE peut déjà corriger certains problèmes à l’exécution
  67. La mise en cache est en concurrence pour la mémoire
  68. Le shuffle n’est pas mauvais en soi
  69. L’organisation des fichiers fait partie des performances
  70. L’échelle change la réponse
  71. Erreurs fréquentes
  72. 1. Augmenter la taille du cluster avant de vérifier l’exactitude des résultats
  73. 2. Chronométrer des transformations lazy
  74. 3. Tout mettre en cache
  75. 4. Utiliser le broadcast parce qu’une table a moins de lignes
  76. 5. Repartitionner partout
  77. 6. Utiliser repartition(1) pour obtenir un seul fichier de sortie
  78. 7. Ignorer le skew
  79. 8. Utiliser des UDF Python pour des opérations intégrées
  80. 9. Comparer des durées d’exécution sans comparer la taille des entrées
  81. 10. Modifier plusieurs variables d’optimisation à la fois
  82. Étape suivante
  83. Pour aller plus loin

Problème

Un job PySpark est lent, irrégulier, gourmand en mémoire ou coûteux.

La cause peut être :

  • la lecture d’un volume de données trop important
  • le transport d’un trop grand nombre de colonnes
  • des jointures ou agrégations générant beaucoup de shuffle
  • des clés présentant du skew
  • un nombre de partitions trop élevé ou trop faible
  • un repartitionnement inutile
  • des recalculs répétés
  • un usage excessif de cache()
  • le surcoût des UDF Python
  • des opérations collect() / toPandas() volumineuses
  • de nombreux petits fichiers
  • une mauvaise organisation des tables Delta
  • des charges de travail concurrentes qui se disputent les ressources
  • tout simplement, le traitement d’un volume de données supérieur à celui des exécutions précédentes

L’objectif est d’identifier le coût dominant avant de modifier la configuration Spark ou d’ajouter de la capacité de calcul.

Réponse rapide

Suivez cet ordre :

1. Vérifier d’abord l’exactitude
2. Mesurer une véritable action Spark
3. Inspecter le plan physique
4. Réduire tôt les lignes et les colonnes
5. Vérifier la stratégie de jointure
6. Vérifier le volume de shuffle
7. Vérifier le skew / les tâches retardataires
8. Vérifier le nombre de partitions
9. Supprimer la collecte côté driver
10. Ne mettre en cache que les résultats intermédiaires coûteux réutilisés
11. Inspecter l’organisation des fichiers / les petits fichiers
12. Comparer au volume d’entrée et à la concurrence
13. Modifier une seule chose et mesurer à nouveau

Commencez par :

from time import perf_counter

start = perf_counter()

result = (
    spark.table("sales")
    .filter("sale_date >= '2026-10-01'")
    .groupBy("merchant_id")
    .sum("amount")
)

result.count()

elapsed = perf_counter() - start

print(f"Elapsed: {elapsed:.2f} seconds")

Inspectez ensuite le plan :

result.explain("formatted")

N’ajustez pas Spark à l’aveugle.

Code / commandes

1. Mesurer une action, pas la construction de transformations 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 l’exécution :

start = perf_counter()

result = (
    df
    .filter("amount > 100")
    .groupBy("merchant_id")
    .sum("amount")
)

row_count = result.count()

print(
    "Rows:",
    row_count,
)

print(
    "Elapsed:",
    perf_counter() - start,
)

Utilisez une action représentative de la charge de travail réelle.


2. Inspecter le plan physique

result.explain("formatted")

Recherchez :

  • les scans de tables ou de fichiers
  • les filtres
  • Exchange
  • les tris
  • les broadcast joins
  • les sort-merge joins
  • les agrégations par hachage (hash aggregations)
  • les scans répétés
  • les opérateurs de fenêtrage

Exchange signifie généralement une redistribution des données.

Ce n’est pas forcément un problème, mais les échanges volumineux et répétés méritent votre attention.


3. Réduire les colonnes au plus tôt

Préférez :

sales = (
    spark.table("sales")
    .select(
        "sale_id",
        "merchant_id",
        "sale_date",
        "amount",
    )
)

à :

sales = spark.table("sales")

lorsque la table est large et que la plupart des colonnes ne sont pas utilisées.

Des DataFrames plus étroits réduisent :

  • les E/S de scan
  • la sérialisation
  • la largeur du shuffle
  • la pression sur la mémoire

4. Filtrer au plus tôt

sales = (
    spark.table("sales")
    .filter(
        "sale_date >= '2026-10-01'"
    )
    .select(
        "merchant_id",
        "sale_id",
        "amount",
    )
)

Placez les filtres avant les jointures et les agrégations lorsque la logique métier le permet.

N’éliminez pas par filtrage des lignes historiques si la logique en aval en a besoin.


5. Inspecter le nombre de partitions

print(
    df.rdd.getNumPartitions()
)

Utilisez cette valeur comme élément de contexte, pas comme un verdict.

Un « bon » nombre de partitions dépend :

  • du volume de données
  • des ressources des executors
  • de la taille des tâches
  • du type de charge de travail
  • de l’étape de shuffle
  • du skew

6. Inspecter la distribution des lignes par partition

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(
    100,
    truncate=False,
)

Utilisez cette requête lorsque vous soupçonnez des partitions déséquilibrées.

Le nombre de lignes n’est qu’un indicateur, car les lignes peuvent avoir des tailles différentes.


7. Vérifier le skew des clés

(
    df
    .groupBy("merchant_id")
    .count()
    .orderBy(
        F.desc("count")
    )
    .show(
        50,
        truncate=False,
    )
)

Recherchez un petit nombre de clés qui concentrent une part disproportionnée des lignes.

Sources fréquentes de skew :

  • un client (tenant) très volumineux
  • des clés nulles ou sentinelles
  • "UNKNOWN"
  • 0
  • des clés malformées
  • des clients dominants

8. Ne pas corriger le skew en ajoutant d’abord de la capacité de calcul

Si une seule tâche traite une clé chaude énorme, ajouter des executors ne résoudra peut-être pas le goulot d’étranglement.

Déterminez d’abord si vous pouvez :

  • filtrer les clés invalides ou sentinelles
  • pré-agréger
  • isoler la clé chaude
  • utiliser une autre clé métier
  • appliquer du salting uniquement à la distribution problématique

N’ajoutez pas de salting tant que le skew n’est pas prouvé.


9. Vérifier la cardinalité de la jointure avant d’en optimiser les performances

Si une jointure multiplie les lignes de manière inattendue :

(
    right
    .groupBy("merchant_id")
    .count()
    .filter(
        F.col("count") > 1
    )
    .show(
        50,
        truncate=False,
    )
)

Une mauvaise jointure many-to-many peut générer plus de travail qu’aucun paramètre Spark ne pourra compenser.

La justesse des résultats d’abord.


10. Diffuser (broadcast) une table de référence réellement petite

result = sales.join(
    F.broadcast(merchants),
    on="merchant_id",
    how="left",
)

Vérifiez ensuite :

result.explain("formatted")

Recherchez :

BroadcastHashJoin

Le broadcast peut éviter de redistribuer par shuffle le côté volumineux.

Ne diffusez pas un DataFrame volumineux ou très large.


11. Projeter avant le broadcast

Préférez :

merchant_lookup = merchants.select(
    "merchant_id",
    "merchant_name",
)

Puis :

result = sales.join(
    F.broadcast(merchant_lookup),
    "merchant_id",
    "left",
)

La taille d’un broadcast se mesure en octets, pas seulement en nombre de lignes.


12. Éviter de collecter les données de référence sur le driver

À éviter :

merchant_ids = [
    row["merchant_id"]
    for row in merchants.collect()
]

Puis :

sales.filter(
    F.col("merchant_id").isin(
        merchant_ids
    )
)

Mieux :

sales.join(
    merchants.select("merchant_id"),
    "merchant_id",
    "left_semi",
)

Gardez distribuées les données distribuées.


13. Éviter les collect() volumineux

Risqué :

rows = df.collect()

Cette instruction transfère toutes les lignes du résultat vers le driver.

Pour inspecter les données :

df.show(
    20,
    truncate=False,
)

ou :

rows = (
    df.limit(100)
    .collect()
)

Ne collectez que lorsque le résultat est volontairement petit.


14. Éviter les toPandas() inutiles

Risqué :

pdf = df.toPandas()

L’intégralité du résultat doit tenir dans la mémoire du driver.

Pour inspecter les données :

pdf = (
    df.limit(1000)
    .toPandas()
)

Pour les transformations volumineuses, restez dans Spark.


15. Préférer les fonctions intégrées aux UDF Python

Préférez :

df = df.withColumn(
    "email_normalized",
    F.lower(
        F.trim(
            F.col("email")
        )
    ),
)

à une UDF Python pour les opérations déjà disponibles dans les fonctions Spark SQL.

Les fonctions intégrées évitent le surcoût de sérialisation Python et offrent à Spark davantage de possibilités d’optimisation.


16. N’utiliser les UDF Python qu’en cas de nécessité

Si une logique personnalisée ne peut pas être exprimée avec les fonctions intégrées, une UDF Python peut être appropriée.

Mais demandez-vous d’abord si cette logique peut être exprimée à l’aide :

  • des fonctions Spark SQL
  • des fonctions d’ordre supérieur sur les tableaux et les maps
  • d’expressions SQL
  • de pandas UDF lorsque la vectorisation est adaptée

N’utilisez pas les UDF Python comme mécanisme de transformation par défaut.


17. Ne mettre en cache que les résultats intermédiaires coûteux et réutilisés

filtered = (
    df
    .filter(
        F.col("sale_date") >= "2026-10-01"
    )
    .select(
        "merchant_id",
        "amount",
    )
    .cache()
)

Matérialisez :

filtered.count()

Réutilisez :

by_merchant = (
    filtered
    .groupBy("merchant_id")
    .sum("amount")
)

totals = (
    filtered
    .agg(
        F.sum("amount")
    )
)

Une fois terminé :

filtered.unpersist()

18. Ne pas mettre en cache les résultats intermédiaires utilisés une seule fois

Modèle à éviter :

df = df.cache()
df.count()
# use once

La mise en cache entraîne :

  • un coût de matérialisation
  • une consommation de mémoire
  • un éventuel spill

Ne l’utilisez que lorsque la réutilisation justifie ce coût.


19. Vérifier si les données sont persistées

print(
    filtered.storageLevel
)

N’oubliez pas que cache() reste lazy jusqu’à l’exécution d’une action.


20. Éviter les actions répétées sur la même lineage coûteuse

Ce code peut déclencher des recalculs répétés :

print(df.count())

print(
    df
    .filter("status = 'failed'")
    .count()
)

print(
    df
    .agg(
        F.sum("amount")
    )
    .collect()
)

Si le même préfixe coûteux est réutilisé plusieurs fois, envisagez une mise en cache ou une restructuration en un nombre réduit de scans.


21. Agréger plusieurs métriques en une seule passe

Au lieu de jobs distincts :

row_count = df.count()

null_count = (
    df.filter(
        F.col("merchant_id").isNull()
    )
    .count()
)

préférez :

metrics = (
    df
    .agg(
        F.count("*").alias("row_count"),
        F.sum(
            F.when(
                F.col("merchant_id").isNull(),
                1,
            ).otherwise(0)
        ).alias("null_merchant_count"),
        F.sum("amount").alias("amount_total"),
    )
)

Cela peut réduire les scans répétés.


22. Ne repartitionner que lorsqu’une redistribution est nécessaire

df = df.repartition(
    200,
    "merchant_id",
)

Cette opération crée un shuffle.

Utilisez-la lorsque la redistribution apporte un bénéfice clair en aval.

Ne repartitionnez pas à l’aveugle avant chaque jointure ou écriture.


23. Repartitionner par clé pour des opérations répétées sur cette clé

Si plusieurs opérations coûteuses utilisent la même clé :

by_merchant = df.repartition(
    "merchant_id"
)

peut aider lorsque le partitionnement obtenu peut être réutilisé.

Mesurez si le shuffle initial en vaut la peine.


24. Utiliser coalesce() pour réduire le nombre de partitions

df_small = df.coalesce(20)

C’est utile lorsque les données sont déjà devenues beaucoup plus petites et que vous voulez moins de partitions en sortie.

Comme il évite généralement un reshuffle complet tout en réduisant le nombre de partitions, il peut être moins coûteux que repartition().

Il peut toutefois produire des partitions déséquilibrées.


25. Éviter repartition(1)

Risqué :

df.repartition(1)

avant une écriture volumineuse.

Cela concentre tout le travail dans une seule partition.

N’utilisez une sortie en un seul fichier que comme étape d’export délibérée pour un petit jeu de données.


26. Vérifier le paramètre des partitions de shuffle

print(
    spark.conf.get(
        "spark.sql.shuffle.partitions"
    )
)

Ce paramètre influence de nombreuses étapes de shuffle.

Ne le modifiez pas globalement parce qu’un seul job semble lent.

Mesurez d’abord la taille des tâches et le comportement des étapes.


27. Inspecter l’Adaptive Query Execution

print(
    spark.conf.get(
        "spark.sql.adaptive.enabled"
    )
)

L’Adaptive Query Execution peut modifier les plans à l’exécution en fonction des statistiques observées.

Cela peut inclure :

  • la fusion (coalescing) des partitions de shuffle
  • le changement de stratégie de jointure
  • la gestion des partitions présentant du skew dans les cas pris en charge

Inspectez le comportement réellement exécuté plutôt que de supposer que le plan initial est définitif.


28. Vérifier le seuil de broadcast

print(
    spark.conf.get(
        "spark.sql.autoBroadcastJoinThreshold"
    )
)

Spark peut diffuser automatiquement les entrées suffisamment petites.

N’augmentez pas ce seuil de manière agressive sans vérifier la mémoire des executors et la taille réelle de la table.


29. Éviter les tris inutiles

Tri global :

df.orderBy(
    F.col("event_time")
)

peut être coûteux, car il nécessite un ordonnancement distribué.

Ne l’utilisez que lorsque l’ordre de sortie est réellement nécessaire.

Pour un top N :

df.orderBy(
    F.col("revenue").desc()
).limit(100)

peut convenir, mais utilisez des modèles spécialisés, comme une fenêtre ou un top N par groupe, lorsque la sémantique des groupes compte.


30. Éviter les partitions de fenêtre trop larges

Exemple :

Window.partitionBy("country")

peut produire des partitions énormes lorsqu’un pays représente une grande partie du jeu de données.

Utilisez la clé de l’entité métier lorsque c’est le véritable besoin de partitionnement.


31. Filtrer avant les fonctions de fenêtrage lorsque la sémantique le permet

recent = (
    df
    .filter(
        F.col("event_date") >= "2026-10-01"
    )
    .select(
        "customer_id",
        "event_time",
        "amount",
    )
)

Appliquez ensuite la fenêtre.

N’éliminez pas par filtrage l’historique nécessaire aux calculs sur toute la durée de vie (lifetime).


32. Vérifier le nombre de fichiers et les problèmes de petits fichiers

De nombreux petits fichiers sources peuvent augmenter :

  • le surcoût de planification
  • le surcoût d’ouverture des fichiers
  • le surcoût d’ordonnancement des tâches

Pour les tables Delta, inspectez l’organisation de la table et des fichiers lorsque les scans sont plus lents que prévu.

Ne supposez pas que le code DataFrame est le seul problème.


33. Compacter les petits fichiers Delta lorsque c’est justifié

Dans les environnements Delta pris en charge :

OPTIMIZE sales;

Utilisez cette commande lorsque la fragmentation en petits fichiers affecte les lectures de manière mesurable.

N’exécutez pas OPTIMIZE par défaut après chaque écriture.


34. Utiliser l’élagage des partitions

Si la table Delta est partitionnée physiquement par :

sale_year
sale_month

filtrez directement sur ces colonnes lorsque c’est approprié :

df = (
    spark.table("sales")
    .filter(
        (F.col("sale_year") == 2026)
        & (F.col("sale_month") == 10)
    )
)

Inspectez :

df.explain("formatted")

Recherchez les filtres de partition.


35. Éviter d’envelopper inutilement les colonnes de partition

Si sale_year existe, préférez :

F.col("sale_year") == 2026

à :

F.year(
    F.col("sale_date")
) == 2026

lorsque l’objectif est l’élagage des partitions.


36. Éviter un partitionnement physique à forte cardinalité

Les mauvaises colonnes de partition comprennent souvent :

  • les identifiants de transaction
  • les horodatages exacts
  • les identifiants client comptant des millions de valeurs

Cela peut créer de nombreux petits répertoires ou fichiers.

Le partitionnement doit servir un véritable modèle d’élagage ou d’isolation des écritures.


37. Comparer les formats de fichiers

Pour des analyses Spark répétées, préférez les formats en colonnes tels que :

Parquet
Delta

à CSV/JSON lorsque vous maîtrisez la couche de stockage.

Leurs avantages incluent :

  • l’élagage des colonnes
  • la compression
  • un schéma typé
  • la prise en charge du predicate pushdown

N’utilisez pas CSV comme format analytique interne simplement parce qu’il est facile à inspecter manuellement.


38. Conserver des décimaux exacts pour les charges de travail financières

Utilisez :

from pyspark.sql.types import DecimalType

df = df.withColumn(
    "amount",
    F.col("amount").cast(
        DecimalType(18, 2)
    ),
)

Évitez les conversions inutiles en virgule flottante lorsqu’un rapprochement exact est important.

Des types de données corrects peuvent aussi réduire les ambiguïtés en aval.


39. Éviter si possible d’éclater les tableaux avant de filtrer

Si un tableau contient de nombreux éléments, ce code :

df.select(
    "id",
    F.explode("items").alias("item"),
)

peut multiplier considérablement les lignes.

Si possible, réduisez ou filtrez plus tôt.

Comprenez toujours la granularité obtenue après explode().


40. Valider l’augmentation du nombre de lignes après explode()

before = df.count()

exploded = (
    df.select(
        "id",
        F.explode("items").alias("item"),
    )
)

after = exploded.count()

print(
    "Expansion factor:",
    after / before
    if before
    else None,
)

Une augmentation légitime du nombre de lignes peut tout de même être coûteuse.


41. Utiliser les semi/anti joins pour les contrôles d’existence

Au lieu d’un enrichissement complet :

valid = sales.join(
    merchants.select("merchant_id"),
    "merchant_id",
    "left_semi",
)

Pour les lignes sans correspondance :

invalid = sales.join(
    merchants.select("merchant_id"),
    "merchant_id",
    "left_anti",
)

Ces jointures évitent de transporter des données inutiles du côté droit.


42. Éviter les jointures complètes lorsque seule l’existence compte

Une jointure gauche suivie de :

filter(right.key.isNotNull())

est souvent moins claire qu’un semi join.

Utilisez le type de jointure qui correspond à la question métier.


43. Vérifier le comportement des étapes et des tâches, pas seulement la durée du notebook

Un notebook lent peut présenter :

une étape lente
une tâche retardataire
un shuffle volumineux
une nouvelle tentative d’executor
une pause du driver

Utilisez la Spark UI et les outils de supervision de la plateforme pour inspecter :

  • la durée des étapes
  • la durée des tâches
  • les lectures/écritures de shuffle
  • le comportement des executors
  • les tâches en échec
  • les entrées/sorties

44. Interpréter avec prudence les tâches retardataires

Si la plupart des tâches se terminent en :

20–30 secondes

mais qu’une tâche prend :

15 minutes

soupçonnez :

  • du skew
  • une partition surdimensionnée
  • un fichier d’entrée défectueux
  • un problème d’executor
  • du spill ou une pression sur les ressources

Ne gommez pas cette anomalie en raisonnant sur des moyennes.


45. Suivre la taille des entrées pour comparer les exécutions

Les comparaisons de performances sont peu fiables sans contexte sur la charge de travail.

Enregistrez lorsque c’est utile :

lignes en entrée
fichiers en entrée
octets
plage de dates
partitions
lignes en sortie
charges de travail concurrentes

Une exécution peut être plus lente simplement parce qu’elle a traité beaucoup plus de données.


46. Distinguer le démarrage de l’exécution

Sur les plateformes de notebooks, la durée totale peut inclure :

démarrage de la session
initialisation de l’environnement
installation des bibliothèques
exécution Spark
durée d’écriture/commit

N’optimisez pas le code Spark pour corriger le démarrage de la plateforme ou de la session.


47. Ne pas commencer par augmenter la taille du cluster

Une capacité de calcul plus importante peut aider une charge de travail parallèle saine.

Elle ne corrige pas :

  • les jointures many-to-many accidentelles
  • les clés chaudes
  • la collecte sur le driver
  • les scans répétés
  • les partitions à forte cardinalité
  • une mauvaise organisation des fichiers

Corrigez d’abord les inefficacités évitables.


48. Ajuster une seule variable à la fois

Mauvaise approche d’optimisation :

modifier les partitions de shuffle
activer le cache
jointure broadcast
augmenter les executors
repartitionner
modifier l’organisation des fichiers

le tout en même temps.

Mieux :

mesurer la référence
→ modifier une seule chose
→ comparer
→ conserver ou annuler

Sinon, vous ne savez pas ce qui a aidé.


49. Conserver les contrôles d’exactitude pendant l’optimisation

Par exemple, comparez :

before_total = (
    baseline
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

avec :

after_total = (
    optimized
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

Un résultat plus rapide mais faux n’est pas une optimisation.


50. Utiliser une démarche de diagnostic compacte

Job lent
  ↓
Scan trop volumineux ?
  → filtrer/projeter plus tôt

Shuffle volumineux ?
  → inspecter les jointures/groupBy/fenêtres

Une tâche domine ?
  → inspecter le skew

Pression sur le driver ?
  → supprimer collect/toPandas/boucles Python

Étapes répétées ?
  → vérifier le recalcul/le cache

Nombreux petits fichiers ?
  → inspecter l’organisation des écritures/OPTIMIZE

Tout est lent en même temps ?
  → inspecter le calcul/la capacité partagés

Interpréter le résultat

Signal Interprétation probable
Scan volumineux Trop de données en entrée ou élagage insuffisant
Nombreux opérateurs Exchange Shuffle important
Broadcast hash join Petit côté distribué aux executors
Sort-merge join Les deux côtés redistribués/triés
Une tâche longue Skew ou partition surdimensionnée
Nombreuses étapes répétées Lineage recalculée ou actions répétées
OOM du driver Trop de données collectées localement
Nombreux petits fichiers Surcoût lié à l’organisation des fichiers
Lectures/écritures de shuffle élevées Redistribution due aux jointures, agrégations ou fenêtres
Empreinte de cache importante Données persistées consommant la mémoire des executors
Notebook lent mais étapes Spark rapides Surcoût de démarrage ou d’orchestration
Nombreuses charges de travail ralenties en même temps Pression sur les ressources ou la capacité partagées

Le principe fondamental en matière de performances est le suivant :

faire moins de travail
avant
de demander à Spark de faire le même travail plus vite

Points à vérifier

Le temps d’exécution a augmenté après une jointure

Vérifiez :

  • la multiplication des lignes
  • le choix du broadcast
  • le volume de shuffle
  • le skew des clés
  • les colonnes inutiles

Une tâche domine une étape

Vérifiez :

  • les clés chaudes
  • les clés nulles ou sentinelles
  • les partitions surdimensionnées
  • une mauvaise distribution des fichiers

La mémoire du driver augmente

Recherchez :

  • collect()
  • toPandas()
  • les listes Python
  • les boucles locales
  • les résultats affichés très volumineux

La même lineage s’exécute plusieurs fois

Vérifiez les actions répétées et déterminez si un résultat intermédiaire coûteux et réutilisé doit être mis en cache.

Les lectures sont lentes alors que les transformations sont simples

Inspectez :

  • le nombre de fichiers
  • l’élagage des partitions
  • la latence du stockage
  • la largeur du schéma
  • la fragmentation en petits fichiers

Le shuffle comporte des milliers de très petites tâches

Le nombre de partitions de shuffle est peut-être trop élevé pour le volume de données.

Mesurez la taille des tâches avant de le réduire.

Le shuffle comporte quelques tâches énormes

Le nombre de partitions est peut-être trop faible, ou le skew domine peut-être.

Ne supposez pas qu’un nombre fixe de partitions résout ces deux problèmes.

Notes de production

L’optimisation des performances dépend de la charge de travail

Il n’existe pas de valeur idéale universelle pour :

spark.sql.shuffle.partitions
nombre d’executors
nombre de partitions
seuil de broadcast
stratégie de cache

Utilisez des données représentatives de l’échelle de production.

Spark est lazy

Le code de transformation peut sembler rapide jusqu’au déclenchement d’une action.

Mesurez les actions de bout en bout.

L’AQE peut déjà corriger certains problèmes à l’exécution

L’Adaptive Query Execution peut fusionner des partitions et modifier dynamiquement certains comportements de jointure.

Ne luttez pas contre l’optimiseur sans éléments probants.

La mise en cache est en concurrence pour la mémoire

Persister de grands DataFrames peut augmenter le spill ou réduire la mémoire disponible pour les étapes actives.

N’utilisez le cache que pour une réutilisation significative.

Le shuffle n’est pas mauvais en soi

Les jointures, les agrégations et les fenêtres en ont souvent besoin.

L’objectif est de réduire les shuffles inutiles et d’éviter un skew pathologique, pas d’éliminer chaque Exchange.

L’organisation des fichiers fait partie des performances

Le code Spark et l’organisation du stockage forment un seul système.

Une requête bien écrite sur des milliers de petits fichiers peut tout de même être lente.

L’échelle change la réponse

Un modèle qui fonctionne bien avec :

1 million de lignes

peut se comporter différemment avec :

1 milliard de lignes

car le shuffle, le skew et l’organisation des fichiers deviennent dominants.

Erreurs fréquentes

1. Augmenter la taille du cluster avant de vérifier l’exactitude des résultats

Les mauvaises jointures et l’explosion du nombre de lignes deviennent simplement plus coûteuses.

2. Chronométrer des transformations lazy

Mesurez une action réelle.

3. Tout mettre en cache

Le cache a un coût.

4. Utiliser le broadcast parce qu’une table a moins de lignes

Vérifiez la taille en octets et la largeur.

5. Repartitionner partout

Chaque repartitionnement est un shuffle.

6. Utiliser repartition(1) pour obtenir un seul fichier de sortie

Cela crée un goulot d’étranglement sur une seule partition.

7. Ignorer le skew

Une taille moyenne de partition peut masquer une clé chaude massive.

8. Utiliser des UDF Python pour des opérations intégrées

Cela ajoute un surcoût de sérialisation évitable et limite l’optimiseur.

9. Comparer des durées d’exécution sans comparer la taille des entrées

Un volume d’entrée plus important peut expliquer une exécution plus lente.

10. Modifier plusieurs variables d’optimisation à la fois

Vous perdez la compréhension des causes.

Étape suivante

Utilisez le signal dominant pour choisir l’action suivante.

  • Scan volumineux → filtrez/projetez plus tôt et inspectez l’élagage des partitions.
  • Shuffle volumineux → inspectez les jointures, les agrégations, les fenêtres et les repartitionnements inutiles.
  • Une tâche retardataire → analysez le skew.
  • Pression sur le driver → supprimez les collect() / toPandas() volumineux et les boucles côté Python.
  • Travail répété → envisagez de mettre en cache uniquement le préfixe coûteux réutilisé.
  • Jointure lente → validez la cardinalité, puis examinez la stratégie broadcast ou shuffle.
  • Nombreux petits fichiers → revoyez l’organisation des écritures Delta et la maintenance.
  • Tout a ralenti en même temps → inspectez la capacité de calcul partagée et la concurrence.
  • Le code est correct mais reste lent → inspectez la Spark UI, les métriques des étapes et la configuration d’exécution avant d’ajouter de la capacité de calcul.

← Tous les aide-mémoire