Explorar guías rápidas · PySpark
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
- Problema
- Respuesta rápida
- Código / comandos
- 1. Mide una acción, no la definición de transformaciones lazy
- 2. Inspecciona el plan físico
- 3. Reduce las columnas cuanto antes
- 4. Filtra cuanto antes
- 5. Inspecciona el número de particiones
- 6. Inspecciona la distribución de filas por partición
- 7. Comprueba el skew de las claves
- 8. No corrijas el skew añadiendo primero capacidad de cómputo
- 9. Comprueba la cardinalidad del join antes de optimizar su rendimiento
- 10. Haz broadcast de una tabla de búsqueda realmente pequeña
- 11. Proyecta antes del broadcast
- 12. Evita recopilar datos de búsqueda en el driver
- 13. Evita collect() de gran tamaño
- 14. Evita toPandas() innecesarios
- 15. Prefiere las funciones integradas a las UDF de Python
- 16. Usa UDF de Python solo cuando sea necesario
- 17. Guarda en caché solo resultados intermedios costosos y reutilizados
- 18. No guardes en caché resultados intermedios de un solo uso
- 19. Comprueba si los datos están persistidos
- 20. Evita acciones repetidas sobre la misma lineage costosa
- 21. Agrega varias métricas en una sola pasada
- 22. Reparticiona solo cuando necesites redistribuir
- 23. Reparticiona por clave para operaciones repetidas sobre esa clave
- 24. Usa coalesce() para reducir particiones
- 25. Evita repartition(1)
- 26. Comprueba la configuración de particiones de shuffle
- 27. Inspecciona Adaptive Query Execution
- 28. Comprueba el umbral de broadcast
- 29. Evita ordenaciones innecesarias
- 30. Evita particiones de ventana demasiado anchas
- 31. Filtra antes de las funciones de ventana cuando la semántica lo permita
- 32. Comprueba el número de archivos y los patrones de archivos pequeños
- 33. Compacta los archivos pequeños de Delta cuando esté justificado
- 34. Usa partition pruning
- 35. Evita envolver innecesariamente las columnas de partición
- 36. Evita el particionamiento físico de alta cardinalidad
- 37. Compara los formatos de archivo
- 38. Conserva decimales exactos en cargas de trabajo financieras
- 39. Evita, si es posible, expandir arrays antes de filtrar
- 40. Valida el crecimiento de filas después de explode()
- 41. Usa semi/anti joins para comprobar existencia
- 42. Evita joins completos cuando solo necesitas comprobar existencia
- 43. Revisa el comportamiento de etapas y tareas, no solo la duración del notebook
- 44. Interpreta con cuidado las tareas rezagadas
- 45. Registra el tamaño de la entrada al comparar ejecuciones
- 46. Separa el inicio de la ejecución
- 47. No uses el tamaño del clúster como primera solución
- 48. Ajusta una variable cada vez
- 49. Conserva las comprobaciones de corrección durante la optimización
- 50. Usa un flujo de diagnóstico compacto
- Qué significa el resultado
- Qué revisar
- El tiempo de ejecución aumentó después de un join
- Una tarea domina una etapa
- La memoria del driver crece
- La misma lineage se ejecuta repetidamente
- Las lecturas son lentas aunque las transformaciones sean simples
- El shuffle tiene miles de tareas diminutas
- El shuffle tiene unas pocas tareas enormes
- Notas de producción
- La optimización del rendimiento depende de la carga de trabajo
- Spark es lazy
- AQE ya puede corregir algunos problemas en tiempo de ejecución
- La caché compite por la memoria
- El shuffle no es malo en sí mismo
- El diseño de archivos forma parte del rendimiento
- La escala cambia la respuesta
- Errores comunes
- 1. Aumentar el tamaño del clúster antes de comprobar la corrección
- 2. Cronometrar transformaciones lazy
- 3. Guardarlo todo en caché
- 4. Hacer broadcast porque una tabla tiene menos filas
- 5. Reparticionar en todas partes
- 6. Usar repartition(1) para obtener un único archivo de salida
- 7. Ignorar el skew
- 8. Usar UDF de Python para operaciones integradas
- 9. Comparar tiempos de ejecución sin comparar el tamaño de la entrada
- 10. Cambiar muchas variables de ajuste a la vez
- Siguiente paso
- 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.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.