Explorar guías rápidas · PySpark

Tecnología: PySparkCategoría: RendimientoNivel: IntermedioActualizado

Referencia rápida de rendimiento de PySpark

Diagnostica y optimiza cargas de trabajo de PySpark separando los problemas de lectura, shuffle, skew, particionamiento, caché, joins, presión sobre el driver y diseño de archivos antes de cambiar el tamaño del clúster.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Mide una acción, no la definición de transformaciones lazy
  5. 2. Inspecciona el plan físico
  6. 3. Reduce las columnas cuanto antes
  7. 4. Filtra cuanto antes
  8. 5. Inspecciona el número de particiones
  9. 6. Inspecciona la distribución de filas por partición
  10. 7. Comprueba el skew de las claves
  11. 8. No corrijas el skew añadiendo primero capacidad de cómputo
  12. 9. Comprueba la cardinalidad del join antes de optimizar su rendimiento
  13. 10. Haz broadcast de una tabla de búsqueda realmente pequeña
  14. 11. Proyecta antes del broadcast
  15. 12. Evita recopilar datos de búsqueda en el driver
  16. 13. Evita collect() de gran tamaño
  17. 14. Evita toPandas() innecesarios
  18. 15. Prefiere las funciones integradas a las UDF de Python
  19. 16. Usa UDF de Python solo cuando sea necesario
  20. 17. Guarda en caché solo resultados intermedios costosos y reutilizados
  21. 18. No guardes en caché resultados intermedios de un solo uso
  22. 19. Comprueba si los datos están persistidos
  23. 20. Evita acciones repetidas sobre la misma lineage costosa
  24. 21. Agrega varias métricas en una sola pasada
  25. 22. Reparticiona solo cuando necesites redistribuir
  26. 23. Reparticiona por clave para operaciones repetidas sobre esa clave
  27. 24. Usa coalesce() para reducir particiones
  28. 25. Evita repartition(1)
  29. 26. Comprueba la configuración de particiones de shuffle
  30. 27. Inspecciona Adaptive Query Execution
  31. 28. Comprueba el umbral de broadcast
  32. 29. Evita ordenaciones innecesarias
  33. 30. Evita particiones de ventana demasiado anchas
  34. 31. Filtra antes de las funciones de ventana cuando la semántica lo permita
  35. 32. Comprueba el número de archivos y los patrones de archivos pequeños
  36. 33. Compacta los archivos pequeños de Delta cuando esté justificado
  37. 34. Usa partition pruning
  38. 35. Evita envolver innecesariamente las columnas de partición
  39. 36. Evita el particionamiento físico de alta cardinalidad
  40. 37. Compara los formatos de archivo
  41. 38. Conserva decimales exactos en cargas de trabajo financieras
  42. 39. Evita, si es posible, expandir arrays antes de filtrar
  43. 40. Valida el crecimiento de filas después de explode()
  44. 41. Usa semi/anti joins para comprobar existencia
  45. 42. Evita joins completos cuando solo necesitas comprobar existencia
  46. 43. Revisa el comportamiento de etapas y tareas, no solo la duración del notebook
  47. 44. Interpreta con cuidado las tareas rezagadas
  48. 45. Registra el tamaño de la entrada al comparar ejecuciones
  49. 46. Separa el inicio de la ejecución
  50. 47. No uses el tamaño del clúster como primera solución
  51. 48. Ajusta una variable cada vez
  52. 49. Conserva las comprobaciones de corrección durante la optimización
  53. 50. Usa un flujo de diagnóstico compacto
  54. Qué significa el resultado
  55. Qué revisar
  56. El tiempo de ejecución aumentó después de un join
  57. Una tarea domina una etapa
  58. La memoria del driver crece
  59. La misma lineage se ejecuta repetidamente
  60. Las lecturas son lentas aunque las transformaciones sean simples
  61. El shuffle tiene miles de tareas diminutas
  62. El shuffle tiene unas pocas tareas enormes
  63. Notas de producción
  64. La optimización del rendimiento depende de la carga de trabajo
  65. Spark es lazy
  66. AQE ya puede corregir algunos problemas en tiempo de ejecución
  67. La caché compite por la memoria
  68. El shuffle no es malo en sí mismo
  69. El diseño de archivos forma parte del rendimiento
  70. La escala cambia la respuesta
  71. Errores comunes
  72. 1. Aumentar el tamaño del clúster antes de comprobar la corrección
  73. 2. Cronometrar transformaciones lazy
  74. 3. Guardarlo todo en caché
  75. 4. Hacer broadcast porque una tabla tiene menos filas
  76. 5. Reparticionar en todas partes
  77. 6. Usar repartition(1) para obtener un único archivo de salida
  78. 7. Ignorar el skew
  79. 8. Usar UDF de Python para operaciones integradas
  80. 9. Comparar tiempos de ejecución sin comparar el tamaño de la entrada
  81. 10. Cambiar muchas variables de ajuste a la vez
  82. Siguiente paso
  83. Para profundizar

Problema

Un job de PySpark es lento, irregular, consume mucha memoria o resulta costoso.

La causa puede ser:

  • leer demasiados datos
  • arrastrar demasiadas columnas
  • joins o agregaciones con mucho shuffle
  • claves con skew
  • demasiadas o muy pocas particiones
  • reparticionamiento innecesario
  • recálculos repetidos
  • uso excesivo de cache()
  • la sobrecarga de las UDF de Python
  • operaciones collect() / toPandas() de gran tamaño
  • muchos archivos pequeños
  • un mal diseño de las tablas Delta
  • cargas de trabajo concurrentes que compiten por los recursos
  • simplemente, procesar más datos que en ejecuciones anteriores

El objetivo es identificar el costo dominante antes de cambiar la configuración de Spark o añadir capacidad de cómputo.

Respuesta rápida

Sigue este orden:

1. Verifica primero la corrección
2. Mide una acción real de Spark
3. Inspecciona el plan físico
4. Reduce pronto filas y columnas
5. Revisa la estrategia de join
6. Revisa el volumen de shuffle
7. Revisa el skew / las tareas rezagadas
8. Revisa el número de particiones
9. Elimina la recopilación en el driver
10. Cachea solo resultados intermedios costosos que se reutilicen
11. Inspecciona el diseño de archivos / los archivos pequeños
12. Compara con el volumen de entrada y la concurrencia
13. Cambia una sola cosa y vuelve a medir

Empieza con:

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")

Después inspecciona el plan:

result.explain("formatted")

No ajustes Spark a ciegas.

Código / comandos

1. Mide una acción, no la definición de transformaciones lazy

Esto:

start = perf_counter()

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

print(perf_counter() - start)

mide sobre todo la construcción del plan lógico.

Fuerza la ejecución:

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,
)

Usa una acción representativa de la carga de trabajo real.


2. Inspecciona el plan físico

result.explain("formatted")

Busca:

  • lecturas (scans) de tablas o archivos
  • filtros
  • Exchange
  • ordenaciones
  • broadcast joins
  • sort-merge joins
  • agregaciones hash (hash aggregations)
  • lecturas repetidas
  • operadores de ventana

Exchange suele indicar una redistribución de los datos.

No es necesariamente malo, pero los exchanges grandes y repetidos merecen atención.


3. Reduce las columnas cuanto antes

Prefiere:

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

en lugar de:

sales = spark.table("sales")

cuando la tabla es ancha y la mayoría de las columnas no se usan.

Los DataFrames más estrechos reducen:

  • la E/S de lectura
  • la serialización
  • el ancho del shuffle
  • la presión sobre la memoria

4. Filtra cuanto antes

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

Coloca los filtros antes de los joins y las agregaciones cuando la lógica de negocio lo permita.

No elimines filas históricas con un filtro si la lógica posterior las necesita.


5. Inspecciona el número de particiones

print(
    df.rdd.getNumPartitions()
)

Usa este valor como contexto, no como un veredicto.

Un número de particiones «bueno» depende de:

  • el volumen de datos
  • los recursos de los executors
  • el tamaño de las tareas
  • el tipo de carga de trabajo
  • la etapa de shuffle
  • el skew

6. Inspecciona la distribución de filas por partición

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,
)

Usa esta consulta cuando sospeches que las particiones están desequilibradas.

El número de filas es solo una señal, porque las filas pueden tener tamaños distintos.


7. Comprueba el skew de las claves

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

Busca un pequeño número de claves que concentren una proporción desmesurada de las filas.

Fuentes habituales de skew:

  • un tenant de gran tamaño
  • claves nulas o centinela
  • "UNKNOWN"
  • 0
  • claves mal formadas
  • clientes dominantes

8. No corrijas el skew añadiendo primero capacidad de cómputo

Si una sola tarea procesa una clave caliente enorme, añadir executors puede no resolver el cuello de botella.

Primero determina si puedes:

  • filtrar las claves erróneas o centinela
  • preagregar
  • aislar la clave caliente
  • usar otra clave de negocio
  • aplicar salting solo a la distribución problemática

No añadas salting hasta que el skew esté demostrado.


9. Comprueba la cardinalidad del join antes de optimizar su rendimiento

Si un join multiplica las filas de forma inesperada:

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

Un join many-to-many incorrecto puede generar más trabajo del que cualquier ajuste de Spark puede compensar.

Primero, la corrección.


10. Haz broadcast de una tabla de búsqueda realmente pequeña

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

Después verifica:

result.explain("formatted")

Busca:

BroadcastHashJoin

El broadcast puede evitar el shuffle del lado grande.

No hagas broadcast de un DataFrame grande o muy ancho.


11. Proyecta antes del broadcast

Prefiere:

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

Después:

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

El tamaño de un broadcast depende de los bytes, no solo del número de filas.


12. Evita recopilar datos de búsqueda en el driver

Incorrecto:

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

Después:

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

Mejor:

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

Mantén distribuidos los datos distribuidos.


13. Evita collect() de gran tamaño

Arriesgado:

rows = df.collect()

Esto mueve todas las filas del resultado al driver.

Para inspeccionar:

df.show(
    20,
    truncate=False,
)

o bien:

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

Recopila datos solo cuando el resultado sea deliberadamente pequeño.


14. Evita toPandas() innecesarios

Arriesgado:

pdf = df.toPandas()

Todo el resultado debe caber en la memoria del driver.

Para inspeccionar:

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

Para transformaciones grandes, quédate en Spark.


15. Prefiere las funciones integradas a las UDF de Python

Prefiere:

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

en lugar de una UDF de Python para operaciones que ya existen en las funciones de Spark SQL.

Las funciones integradas evitan la sobrecarga de serialización de Python y dan a Spark más oportunidades de optimización.


16. Usa UDF de Python solo cuando sea necesario

Si la lógica personalizada no se puede expresar con funciones integradas, una UDF de Python puede ser adecuada.

Pero primero pregúntate si la lógica se puede expresar con:

  • funciones de Spark SQL
  • funciones de orden superior sobre arrays y maps
  • expresiones SQL
  • pandas UDF cuando la vectorización sea adecuada

No uses las UDF de Python como mecanismo de transformación por defecto.


17. Guarda en caché solo resultados intermedios costosos y reutilizados

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

Materializa:

filtered.count()

Reutiliza:

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

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

Al terminar:

filtered.unpersist()

18. No guardes en caché resultados intermedios de un solo uso

Patrón incorrecto:

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

Guardar en caché introduce:

  • costo de materialización
  • consumo de memoria
  • posible spill

Úsalo solo cuando la reutilización justifique el costo.


19. Comprueba si los datos están persistidos

print(
    filtered.storageLevel
)

Recuerda que cache() es lazy hasta que se ejecuta una acción.


20. Evita acciones repetidas sobre la misma lineage costosa

Esto puede provocar recálculos repetidos:

print(df.count())

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

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

Si el mismo prefijo costoso se reutiliza varias veces, considera guardarlo en caché o reestructurar el código en menos lecturas.


21. Agrega varias métricas en una sola pasada

En lugar de jobs separados:

row_count = df.count()

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

prefiere:

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"),
    )
)

Esto puede reducir las lecturas repetidas.


22. Reparticiona solo cuando necesites redistribuir

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

Esto crea un shuffle.

Úsalo cuando la redistribución aporte un beneficio claro en las operaciones posteriores.

No reparticiones a ciegas antes de cada join o escritura.


23. Reparticiona por clave para operaciones repetidas sobre esa clave

Si varias operaciones costosas usan la misma clave:

by_merchant = df.repartition(
    "merchant_id"
)

puede ayudar cuando el particionamiento resultante se pueda reutilizar.

Mide si el shuffle inicial compensa.


24. Usa coalesce() para reducir particiones

df_small = df.coalesce(20)

Es útil cuando los datos ya se han reducido mucho y quieres menos particiones de salida.

Como normalmente evita un reshuffle completo al reducir particiones, puede ser más barato que repartition().

Pero puede producir particiones desequilibradas.


25. Evita repartition(1)

Arriesgado:

df.repartition(1)

antes de una escritura grande.

Esto concentra todo el trabajo en una sola partición.

Usa la salida en un único archivo solo como paso de exportación deliberado para un conjunto de datos pequeño.


26. Comprueba la configuración de particiones de shuffle

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

Esta configuración influye en muchas etapas de shuffle.

No la cambies globalmente porque un solo job parezca lento.

Mide primero el tamaño de las tareas y el comportamiento de las etapas.


27. Inspecciona Adaptive Query Execution

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

Adaptive Query Execution puede cambiar los planes en tiempo de ejecución según las estadísticas observadas.

Esto puede incluir:

  • combinar (coalescing) particiones de shuffle
  • cambiar estrategias de join
  • gestionar particiones con skew en los casos compatibles

Inspecciona el comportamiento realmente ejecutado en lugar de suponer que el plan original es el definitivo.


28. Comprueba el umbral de broadcast

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

Spark puede hacer broadcast automáticamente de entradas suficientemente pequeñas.

No aumentes el umbral de forma agresiva sin comprobar la memoria de los executors y el tamaño real de la tabla.


29. Evita ordenaciones innecesarias

Ordenación global:

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

puede ser costosa porque requiere una ordenación distribuida.

Úsala solo cuando el orden de salida sea realmente necesario.

Para un top N:

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

puede ser adecuado, pero usa patrones especializados, como ventanas o top N por grupo, cuando importe la semántica de grupo.


30. Evita particiones de ventana demasiado anchas

Ejemplo:

Window.partitionBy("country")

puede producir particiones enormes cuando un país contiene una gran parte del conjunto de datos.

Usa la clave de la entidad de negocio cuando ese sea el requisito real de particionamiento.


31. Filtra antes de las funciones de ventana cuando la semántica lo permita

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

Después aplica la ventana.

No elimines con un filtro el historial necesario para cálculos sobre toda la vida (lifetime).


32. Comprueba el número de archivos y los patrones de archivos pequeños

Muchos archivos de origen diminutos pueden aumentar:

  • la sobrecarga de planificación
  • la sobrecarga de apertura de archivos
  • la sobrecarga de programación de tareas

En tablas Delta, inspecciona el diseño de la tabla y de los archivos cuando las lecturas sean más lentas de lo esperado.

No supongas que el código del DataFrame es el único problema.


33. Compacta los archivos pequeños de Delta cuando esté justificado

En entornos Delta compatibles:

OPTIMIZE sales;

Úsalo cuando la fragmentación en archivos pequeños afecte de forma medible a las lecturas.

No ejecutes OPTIMIZE después de cada escritura por defecto.


34. Usa partition pruning

Si la tabla Delta está particionada físicamente por:

sale_year
sale_month

filtra directamente por esas columnas cuando corresponda:

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

Inspecciona:

df.explain("formatted")

Busca filtros de partición.


35. Evita envolver innecesariamente las columnas de partición

Si existe sale_year, prefiere:

F.col("sale_year") == 2026

en lugar de:

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

cuando el objetivo sea el partition pruning.


36. Evita el particionamiento físico de alta cardinalidad

Entre las malas columnas de partición suelen estar:

  • los ID de transacción
  • las marcas de tiempo exactas
  • los ID de cliente con millones de valores

Esto puede crear muchos directorios o archivos diminutos.

El particionamiento debe responder a un patrón real de pruning o de aislamiento de escrituras.


37. Compara los formatos de archivo

Para análisis repetidos con Spark, prefiere formatos columnares como:

Parquet
Delta

en lugar de CSV/JSON cuando controles la capa de almacenamiento.

Entre sus ventajas están:

  • la poda de columnas
  • la compresión
  • un esquema tipado
  • la compatibilidad con predicate pushdown

No uses CSV como formato analítico interno solo porque sea fácil de inspeccionar manualmente.


38. Conserva decimales exactos en cargas de trabajo financieras

Usa:

from pyspark.sql.types import DecimalType

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

Evita conversiones innecesarias a coma flotante cuando importe una conciliación exacta.

Los tipos de datos correctos también pueden reducir la ambigüedad en las etapas posteriores.


39. Evita, si es posible, expandir arrays antes de filtrar

Si un array contiene muchos elementos, esto:

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

puede multiplicar mucho las filas.

Si es posible, reduce o filtra antes.

Entiende siempre la granularidad resultante después de explode().


40. Valida el crecimiento de filas después de 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,
)

Una expansión de filas válida puede seguir siendo costosa.


41. Usa semi/anti joins para comprobar existencia

En lugar de un enriquecimiento completo:

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

Para las filas sin correspondencia:

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

Estos joins evitan arrastrar datos innecesarios del lado derecho.


42. Evita joins completos cuando solo necesitas comprobar existencia

Un left join seguido de:

filter(right.key.isNotNull())

suele ser menos claro que un semi join.

Usa el tipo de join que corresponda a la pregunta de negocio.


43. Revisa el comportamiento de etapas y tareas, no solo la duración del notebook

Un notebook lento puede tener:

una etapa lenta
una tarea rezagada
un shuffle grande
reintento de un executor
pausa del driver

Usa la Spark UI y el monitoreo de la plataforma para inspeccionar:

  • la duración de las etapas
  • la duración de las tareas
  • la lectura/escritura de shuffle
  • el comportamiento de los executors
  • las tareas con errores
  • la entrada/salida

44. Interpreta con cuidado las tareas rezagadas

Si la mayoría de las tareas terminan en:

20–30 segundos

pero una tarea tarda:

15 minutos

sospecha de:

  • skew
  • una partición demasiado grande
  • un archivo de entrada defectuoso
  • un problema de un executor
  • spill o presión sobre los recursos

No lo diluyas con un promedio.


45. Registra el tamaño de la entrada al comparar ejecuciones

Las comparaciones de rendimiento son poco sólidas sin el contexto de la carga de trabajo.

Registra, cuando sea útil:

filas de entrada
archivos de entrada
bytes
rango de fechas
particiones
filas de salida
cargas de trabajo concurrentes

Una ejecución puede ser más lenta simplemente porque procesó muchos más datos.


46. Separa el inicio de la ejecución

En plataformas de notebooks, la duración total puede incluir:

inicio de la sesión
inicialización del entorno
configuración de bibliotecas
ejecución de Spark
tiempo de escritura/commit

No optimices el código Spark para corregir el inicio de la plataforma o de la sesión.


47. No uses el tamaño del clúster como primera solución

Más capacidad de cómputo puede ayudar a una carga de trabajo paralela saludable.

No corrige:

  • joins many-to-many accidentales
  • claves calientes
  • la recopilación de datos en el driver
  • lecturas repetidas
  • particiones de alta cardinalidad
  • un mal diseño de archivos

Corrige primero las ineficiencias evitables.


48. Ajusta una variable cada vez

Enfoque de ajuste incorrecto:

cambiar las particiones de shuffle
activar la caché
broadcast join
aumentar los executors
reparticionar
cambiar el diseño de archivos

todo a la vez.

Mejor:

medir la línea base
→ cambiar una sola cosa
→ comparar
→ conservar o revertir

De lo contrario, no sabrás qué ayudó.


49. Conserva las comprobaciones de corrección durante la optimización

Por ejemplo, compara:

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

con:

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

Un resultado más rápido pero incorrecto no es una optimización.


50. Usa un flujo de diagnóstico compacto

Job lento
  ↓
¿Lectura demasiado grande?
  → filtrar/proyectar antes

¿Shuffle grande?
  → inspeccionar joins/groupBy/ventanas

¿Una tarea domina?
  → inspeccionar el skew

¿Presión sobre el driver?
  → eliminar collect/toPandas/bucles de Python

¿Etapas repetidas?
  → revisar recálculo/caché

¿Muchos archivos diminutos?
  → inspeccionar el diseño de escritura/OPTIMIZE

¿Todo lento a la vez?
  → inspeccionar cómputo/capacidad compartidos

Qué significa el resultado

Señal Interpretación probable
Lectura grande Demasiada entrada o pruning insuficiente
Muchos operadores Exchange Shuffle significativo
Broadcast hash join Lado pequeño distribuido a los executors
Sort-merge join Ambos lados redistribuidos/ordenados
Una tarea larga Skew o partición demasiado grande
Muchas etapas repetidas Lineage recalculada o acciones repetidas
OOM del driver Demasiados datos recopilados localmente
Muchos archivos diminutos Sobrecarga por el diseño de archivos
Lectura/escritura de shuffle alta Redistribución por joins, agregaciones o ventanas
Gran huella de caché Datos persistidos que consumen memoria de los executors
Notebook lento pero etapas Spark rápidas Sobrecarga de inicio u orquestación
Muchas cargas de trabajo lentas a la vez Presión sobre recursos o capacidad compartidos

El principio de rendimiento fundamental es:

hacer menos trabajo
antes de
pedirle a Spark que haga el mismo trabajo más rápido

Qué revisar

El tiempo de ejecución aumentó después de un join

Revisa:

  • la multiplicación de filas
  • la elección del broadcast
  • el volumen de shuffle
  • el skew de las claves
  • las columnas innecesarias

Una tarea domina una etapa

Revisa:

  • las claves calientes
  • las claves nulas o centinela
  • las particiones demasiado grandes
  • una mala distribución de los archivos

La memoria del driver crece

Busca:

  • collect()
  • toPandas()
  • listas de Python
  • bucles locales
  • resultados mostrados enormes

La misma lineage se ejecuta repetidamente

Revisa las acciones repetidas y si conviene guardar en caché un resultado intermedio costoso que se reutiliza.

Las lecturas son lentas aunque las transformaciones sean simples

Inspecciona:

  • el número de archivos
  • el partition pruning
  • la latencia del almacenamiento
  • el ancho del esquema
  • la fragmentación en archivos pequeños

El shuffle tiene miles de tareas diminutas

Puede que el número de particiones de shuffle sea demasiado alto para el volumen de datos.

Mide el tamaño de las tareas antes de reducirlo.

El shuffle tiene unas pocas tareas enormes

Puede que el número de particiones sea demasiado bajo o que domine el skew.

No supongas que un número fijo de particiones resuelve ambos problemas.

Notas de producción

La optimización del rendimiento depende de la carga de trabajo

No existe un valor óptimo universal para:

spark.sql.shuffle.partitions
número de executors
número de particiones
umbral de broadcast
estrategia de caché

Usa datos representativos de la escala de producción.

Spark es lazy

El código de transformación puede parecer rápido hasta que se dispara una acción.

Mide acciones de extremo a extremo.

AQE ya puede corregir algunos problemas en tiempo de ejecución

Adaptive Query Execution puede combinar particiones y cambiar dinámicamente parte del comportamiento de los joins.

No luches contra el optimizador sin evidencias.

La caché compite por la memoria

Persistir DataFrames grandes puede aumentar el spill o reducir la memoria disponible para las etapas activas.

Usa la caché solo cuando haya una reutilización significativa.

El shuffle no es malo en sí mismo

Los joins, las agregaciones y las ventanas suelen requerirlo.

El objetivo es reducir el shuffle innecesario y evitar un skew patológico, no eliminar todos los Exchange.

El diseño de archivos forma parte del rendimiento

El código Spark y el diseño del almacenamiento son un único sistema.

Una consulta bien escrita sobre miles de archivos diminutos puede seguir siendo lenta.

La escala cambia la respuesta

Un patrón que funciona bien con:

1 millón de filas

puede comportarse de otra forma con:

1.000 millones de filas

porque el shuffle, el skew y el diseño de archivos pasan a ser dominantes.

Errores comunes

1. Aumentar el tamaño del clúster antes de comprobar la corrección

Los joins incorrectos y la explosión de filas simplemente se vuelven más costosos.

2. Cronometrar transformaciones lazy

Mide una acción real.

3. Guardarlo todo en caché

La caché tiene un costo.

4. Hacer broadcast porque una tabla tiene menos filas

Comprueba el tamaño en bytes y el ancho.

5. Reparticionar en todas partes

Cada reparticionamiento es un shuffle.

6. Usar repartition(1) para obtener un único archivo de salida

Esto crea un cuello de botella en una sola partición.

7. Ignorar el skew

El tamaño medio de las particiones puede ocultar una clave caliente enorme.

8. Usar UDF de Python para operaciones integradas

Esto añade una sobrecarga de serialización evitable y limita al optimizador.

9. Comparar tiempos de ejecución sin comparar el tamaño de la entrada

Una entrada más grande puede explicar una ejecución más lenta.

10. Cambiar muchas variables de ajuste a la vez

Pierdes la comprensión de qué causó cada efecto.

Siguiente paso

Usa la señal dominante para elegir la siguiente acción.

  • Lectura grande → filtra/proyecta antes e inspecciona el partition pruning.
  • Shuffle grande → inspecciona joins, agregaciones, ventanas y reparticionamientos innecesarios.
  • Una tarea rezagada → investiga el skew.
  • Presión sobre el driver → elimina los collect() / toPandas() grandes y los bucles del lado de Python.
  • Trabajo repetido → considera guardar en caché solo el prefijo costoso reutilizado.
  • Join lento → valida la cardinalidad y después inspecciona la estrategia broadcast frente a shuffle.
  • Muchos archivos pequeños → revisa el diseño de escritura y el mantenimiento de Delta.
  • Todo se ralentizó a la vez → inspecciona la capacidad de cómputo compartida y la concurrencia.
  • El código es correcto pero sigue siendo lento → inspecciona la Spark UI, las métricas de las etapas y la configuración de ejecución antes de añadir capacidad de cómputo.

← Todas las guías rápidas