Explorar guías rápidas · Microsoft Fabric
Rendimiento de los notebooks de Fabric
Diagnostica y mejora el rendimiento de los notebooks de Microsoft Fabric separando los cuellos de botella del inicio de la sesión Spark, la lectura de datos, el shuffle, el skew, la presión sobre el driver, la concurrencia y la escritura.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Mide la acción de Spark, no solo la construcción del DataFrame
- 2. Inspecciona el plan físico
- 3. Comprueba el número actual de particiones
- 4. Inspecciona la distribución de filas por partición
- 5. Filtra antes de las transformaciones costosas
- 6. Evita select("*") cuando solo necesitas unas pocas columnas
- 7. Inspecciona la estrategia de join
- 8. Haz broadcast de una tabla de búsqueda realmente pequeña
- 9. Revisa las claves de join duplicadas antes de culpar a Spark
- 10. Reduce los datos antes de un join grande
- 11. Busca skew en las claves de join o de agrupación
- 12. Evita collect() con resultados grandes
- 13. Evita toPandas() innecesario
- 14. Evita los bucles de Python sobre filas de Spark
- 15. Prefiere las expresiones integradas de Spark a las UDF de Python
- 16. Almacena en caché solo los DataFrames que reutilizas
- 17. Comprueba el estado de la caché
- 18. Evita acciones repetidas innecesarias
- 19. Inspecciona la configuración de Spark relevante para la sesión
- 20. Inspecciona los ajustes importantes de ejecución adaptativa
- 21. Reparticiona cuando necesites una redistribución real
- 22. Usa coalesce para reducir particiones sin un shuffle completo
- 23. Evita repartition(1) en salidas de producción grandes
- 24. Comprueba si los archivos pequeños forman parte del problema
- 25. Escribe solo las columnas que necesitas
- 26. Usa overwrite de forma deliberada
- 27. Deja de comparar ejecuciones de notebooks con volúmenes de entrada distintos
- 28. Separa la latencia de inicio de la ejecución de Spark
- 29. Usa starter pools de Fabric para acelerar el inicio de sesión cuando corresponda
- 30. Usa High Concurrency cuando notebooks compatibles puedan compartir una sesión
- 31. Usa un session tag para reutilizar sesiones de notebooks de pipeline cuando High Concurrency esté habilitado
- 32. No generes una actividad paralela de notebooks excesiva
- 33. Usa autoescalado y asignación dinámica de executors para cargas variables cuando corresponda
- 34. Considera el Native Execution Engine solo donde esté admitido y validado
- 35. Usa el monitoreo de Spark para encontrar la etapa que domina el tiempo de ejecución
- Qué significa el resultado
- Qué revisar
- El inicio domina el tiempo total
- Una etapa tiene una o unas pocas tareas rezagadas
- El shuffle domina el tiempo de ejecución
- El driver falla o se vuelve lento
- El tiempo de ejecución cambia drásticamente con código similar
- La salida genera muchos archivos pequeños
- Notas de producción
- El rendimiento de los notebooks de Fabric tiene dos capas distintas
- High Concurrency tiene reglas de compatibilidad
- La densidad actual de High Concurrency es configurable
- En Spark no existen instantáneas tipo DMV como en SQL Server
- La capacidad y el dimensionamiento de los pools importan una vez entendidos los problemas de código
- Las colas pueden ser un problema de capacidad y no del código del notebook
- Autotune depende de la versión y de las funcionalidades
- Mide con datos representativos a escala de producción
- Errores comunes
- 1. Aumentar el cómputo de Spark antes de encontrar el cuello de botella
- 2. Cronometrar solo las transformaciones de DataFrame
- 3. Usar repartition(1) para obtener un único archivo de salida
- 4. Almacenar en caché todos los DataFrames
- 5. Hacer broadcast de una tabla sin comprobar su tamaño
- 6. Usar UDF de Python para operaciones que Spark ya admite
- 7. Ignorar el skew de los datos
- 8. Aumentar la concurrencia de notebooks a ciegas
- 9. Tratar el inicio de sesión como tiempo de ejecución de la consulta
- 10. Optimizar el código ignorando la organización de los archivos
- Siguiente paso
- Para profundizar
Problema
Un notebook de Microsoft Fabric es lento, irregular o consume más capacidad de Spark de lo esperado.
El retraso puede venir de lugares muy distintos:
- el inicio de la sesión Spark
- la lectura de demasiados datos
- demasiados archivos pequeños
- un particionamiento deficiente
- joins o agregaciones con mucho shuffle
- skew en los datos
- código Python que se ejecuta en el driver
- llamadas innecesarias a
collect()/toPandas() - recálculos repetidos
- concurrencia excesiva de notebooks
- cómputo Spark infradimensionado o sobredimensionado
- escrituras Delta lentas
- varios notebooks que inician sesiones Spark separadas sin necesidad
El objetivo es identificar en qué se va el tiempo antes de cambiar la configuración de Spark.
Respuesta rápida
Sigue este flujo:
1. Separa el tiempo de inicio de sesión del tiempo de ejecución del notebook
2. Identifica la acción / etapa de Spark lenta
3. Inspecciona el plan físico
4. Revisa cuántos datos se están escaneando
5. Revisa las particiones y el shuffle
6. Revisa si hay skew
7. Revisa recolecciones en el driver / bucles de Python
8. Revisa los recálculos repetidos
9. Revisa la organización de archivos y el patrón de escritura Delta
10. Revisa el tamaño del pool, el autoescalado, la concurrencia y la reutilización de sesiones
11. Cambia una sola cosa y vuelve a medir
Empieza por la operación que crees que es lenta:
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")
Después inspecciona el plan:
result.explain("formatted")
No ajustes la configuración de Spark hasta saber si el cuello de botella está en la lectura, el shuffle, el skew, el cómputo, el inicio o el driver.
Código / comandos
1. Mide la acción de Spark, no solo la construcción del DataFrame
Los DataFrames de Spark son lazy (evaluación diferida).
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 una acción:
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")
Usa una acción representativa.
No añadas un collect() grande solo para hacer un benchmark.
2. Inspecciona el plan físico
result.explain("formatted")
Hazlo antes de cambiar el número de particiones o el tamaño del cómputo.
Busca:
- lecturas (scans)
- filtros
- joins
- intercambios (exchanges)
- ordenaciones
- agregaciones
- broadcast joins
- lecturas repetidas
Un Exchange suele indicar que Spark debe redistribuir los datos entre particiones.
No es necesariamente malo, pero los intercambios grandes o repetidos merecen atención.
3. Comprueba el número actual de particiones
print(df.rdd.getNumPartitions())
Después de un shuffle:
result = (
df.groupBy("merchant_id")
.sum("amount")
)
print(result.rdd.getNumPartitions())
El número de particiones por sí solo no indica si la carga de trabajo está sana.
Tienes que compararlo con:
- el volumen de datos
- la distribución del tamaño de las particiones
- el número de executors
- la duración de las tareas
- el skew
4. Inspecciona la distribución de filas por partición
Para un diagnóstico específico:
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)
Úsalo cuando sospeches que hay skew.
Si unas pocas particiones contienen muchas más filas que el resto, esas tareas pueden dominar la duración de la etapa.
El número de filas es solo una señal: las filas de ancho variable pueden tener tamaños en bytes distintos.
5. Filtra antes de las transformaciones costosas
Es preferible:
filtered = (
spark.read.format("delta")
.load("Tables/sales")
.filter(F.col("sale_date") >= "2026-10-01")
.select(
"merchant_id",
"sale_date",
"amount",
)
)
a cargar datos anchos y arrastrar todas las columnas a través de joins y agregaciones.
Aplica:
- los filtros
- la selección de columnas
tan pronto como sea práctico.
Así se reduce la cantidad de datos procesados en las etapas posteriores.
6. Evita select("*") cuando solo necesitas unas pocas columnas
En lugar de:
df = (
spark.read.format("delta")
.load("Tables/sales")
.select("*")
)
es preferible:
df = (
spark.read.format("delta")
.load("Tables/sales")
.select(
"sale_id",
"merchant_id",
"sale_date",
"amount",
)
)
La poda de columnas importa sobre todo en tablas analíticas anchas.
7. Inspecciona la estrategia de join
joined = sales.join(
merchants,
on="merchant_id",
how="left",
)
joined.explain("formatted")
Comprueba si Spark elige:
- broadcast hash join
- sort-merge join
- otra estrategia
No fuerces un broadcast hasta saber si el lado más pequeño es adecuado para ello.
8. Haz broadcast de una tabla de búsqueda realmente pequeña
Cuando hayas verificado que la tabla de búsqueda es lo bastante pequeña:
from pyspark.sql import functions as F
joined = sales.join(
F.broadcast(merchants),
on="merchant_id",
how="left",
)
Después vuelve a inspeccionar:
joined.explain("formatted")
El broadcast evita hacer shuffle del lado grande en algunos patrones de join.
No hagas broadcast de una tabla grande solo porque un join es lento.
9. Revisa las claves de join duplicadas antes de culpar a Spark
Un join puede ser lento porque multiplica filas.
Comprueba la cardinalidad de las claves:
duplicate_keys = (
merchants.groupBy("merchant_id")
.count()
.filter(F.col("count") > 1)
)
duplicate_keys.show(50, truncate=False)
Si una supuesta tabla de dimensión no es única, un join puede:
- multiplicar filas
- aumentar el volumen de shuffle
- aumentar la presión de memoria
- inflar las métricas posteriores
Corrige la relación entre los datos antes de ajustar el clúster.
10. Reduce los datos antes de un join grande
Es preferible:
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",
)
Filtrar y proyectar primero puede reducir considerablemente el trabajo de shuffle.
11. Busca skew en las claves de join o de agrupación
Empieza con:
(
df.groupBy("merchant_id")
.count()
.orderBy(F.desc("count"))
.show(50, truncate=False)
)
Una clave muy «caliente» puede enviar una cantidad desproporcionada de datos a una sola partición.
Ejemplos habituales:
- una clave por defecto o desconocida
- un reemplazo de nulos como
0 - un cliente muy grande
- un comercio dominante
- datos mal formados que concentran muchos registros en una sola clave
No añadas salting aleatorio de inmediato.
Primero identifica la clave con skew y confirma el motivo de negocio.
12. Evita collect() con resultados grandes
Arriesgado:
rows = df.collect()
Esto envía el resultado completo al driver.
Más seguro para inspeccionar:
df.show(20, truncate=False)
o:
rows = df.limit(100).collect()
Usa la recopilación completa solo cuando el resultado sea pequeño a propósito.
13. Evita toPandas() innecesario
Arriesgado:
pdf = df.toPandas()
El DataFrame de pandas resultante debe caber en la memoria del driver.
Para inspeccionar:
pdf = (
df.limit(1000)
.toPandas()
)
Para transformaciones grandes, mantén el trabajo distribuido en Spark.
14. Evita los bucles de Python sobre filas de Spark
Mal patrón:
for row in df.collect():
process(row)
Es preferible usar transformaciones de Spark:
result = (
df.withColumn(
"net_amount",
F.col("amount") - F.col("discount"),
)
)
Pasar los datos a Python fila por fila elimina la ventaja de la ejecución distribuida de Spark.
15. Prefiere las expresiones integradas de Spark a las UDF de Python
Es preferible:
df = df.withColumn(
"normalized_email",
F.lower(
F.trim(F.col("email"))
),
)
a una UDF de Python para operaciones ya disponibles en las funciones de Spark SQL.
Las expresiones integradas le dan a Spark más oportunidades de optimizar la ejecución y evitan la sobrecarga de serialización de Python.
Usa una UDF solo cuando la lógica necesaria no pueda expresarse con funciones integradas de Spark u otro mecanismo compatible más eficiente.
16. Almacena en caché solo los DataFrames que reutilizas
Si el mismo resultado costoso se reutiliza varias veces:
filtered = (
df.filter(F.col("sale_date") >= "2026-10-01")
.select(
"merchant_id",
"amount",
)
.cache()
)
Materialízalo:
filtered.count()
Reutilízalo:
by_merchant = (
filtered.groupBy("merchant_id")
.sum("amount")
)
total = filtered.agg(
F.sum("amount")
)
Al terminar:
filtered.unpersist()
No almacenes en caché todos los DataFrames.
Almacenar en caché datos que se usan una sola vez suele añadir trabajo en lugar de eliminarlo.
17. Comprueba el estado de la caché
print(filtered.storageLevel)
Úsalo al depurar si un DataFrame está realmente persistido.
Recuerda que cache() es lazy hasta que una acción lo materializa.
18. Evita acciones repetidas innecesarias
Esto lanza varios jobs:
print(df.count())
print(df.filter(F.col("status") == "failed").count())
print(df.agg(F.sum("amount")).collect())
Puede ser aceptable, pero cada acción puede volver a calcular la lineage anterior si la entrada no está en caché o materializada de otro modo.
Si varias acciones reutilizan un prefijo común costoso, considera materializar ese prefijo una sola vez.
19. Inspecciona la configuración de Spark relevante para la sesión
for key, value in sorted(
spark.sparkContext.getConf().getAll()
):
print(f"{key}={value}")
Úsalo cuando:
- el rendimiento difiere entre entornos
- un notebook se comporta de forma distinta a un pipeline
- sospechas que hay diferencias en la configuración de la sesión
No cambies la configuración solo porque un valor te resulte desconocido.
20. Inspecciona los ajustes importantes de ejecución adaptativa
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>",
)
Adaptive Query Execution puede cambiar la estrategia de ejecución física según la información obtenida en tiempo de ejecución.
Considera el ajuste manual de spark.sql.shuffle.partitions como algo específico de cada carga de trabajo, no como una solución universal.
21. Reparticiona cuando necesites una redistribución real
repartitioned = df.repartition(
200,
"merchant_id",
)
Usa repartition() cuando necesites redistribuir los datos de forma intencionada, por ejemplo antes de una operación repetida que usa la misma clave de particionamiento.
Esto genera un shuffle.
No reparticiones a ciegas.
22. Usa coalesce para reducir particiones sin un shuffle completo
smaller = df.coalesce(20)
Es útil para reducir el número de particiones de salida cuando la carga de trabajo ya se ha vuelto pequeña.
coalesce() suele evitar un shuffle completo al reducir particiones.
Puede producir particiones desiguales, así que valida la carga de trabajo resultante.
23. Evita repartition(1) en salidas de producción grandes
Arriesgado:
df.repartition(1).write.parquet(
"Files/export"
)
Esto canaliza la salida por una sola partición y puede crear un cuello de botella grave.
Si un consumidor posterior necesita un único archivo, trátalo como un requisito de exportación y usa un proceso dedicado y controlado después de la transformación distribuida.
24. Comprueba si los archivos pequeños forman parte del problema
Una tabla con muchos archivos diminutos puede aumentar la sobrecarga de planificación y de apertura de archivos.
Inspecciona la organización del origen desde el lado de Lakehouse/OneLake cuando una lectura sea inesperadamente costosa.
Para las tablas Delta, usa las capacidades de mantenimiento y optimización adecuadas que admite Fabric en lugar de combinar archivos manualmente en el código del notebook.
No optimices una tabla solo porque el número de archivos sea alto; confirma que la carga de trabajo se ve afectada.
25. Escribe solo las columnas que necesitas
output = result.select(
"merchant_id",
"sale_date",
"amount",
)
(
output.write
.format("delta")
.mode("append")
.save("Tables/curated_sales")
)
Evita arrastrar columnas temporales o de depuración a las tablas de producción.
26. Usa overwrite de forma deliberada
Esto es destructivo para los datos de destino que abarca la operación:
(
result.write
.format("delta")
.mode("overwrite")
.save("Tables/curated_sales")
)
No uses overwrite solo para facilitar las reejecuciones.
Elige entre:
- append
- merge/upsert
- reemplazo de particiones
- reconstrucción completa
según el contrato de datos del pipeline.
27. Deja de comparar ejecuciones de notebooks con volúmenes de entrada distintos
Registra el contexto básico de ejecución:
input_rows = df.count()
print(
"Input rows:",
input_rows,
)
El número de filas no basta por sí solo, pero las comparaciones de rendimiento son poco fiables cuando las ejecuciones procesan volúmenes de datos sustancialmente distintos.
Registra también, cuando sea útil:
- el rango de fechas del origen
- el número de archivos
- las particiones
- las filas de salida
- la cardinalidad del join
28. Separa la latencia de inicio de la ejecución de Spark
La duración total (wall-clock) de un notebook puede incluir:
obtención de la sesión
+ inicio de Spark
+ inicialización del entorno
+ inicialización de bibliotecas
+ trabajo real de Spark
Si las etapas de Spark de un notebook se ejecutan rápido pero el notebook sigue tardando mucho de principio a fin, optimiza la reutilización y el inicio de la sesión en lugar de reescribir el código de DataFrame.
29. Usa starter pools de Fabric para acelerar el inicio de sesión cuando corresponda
Los starter pools están diseñados para reducir la latencia de inicio de las sesiones Spark usando cómputo precalentado administrado por Microsoft cuando está disponible.
Son más útiles cuando:
- los notebooks son cortos
- el inicio representa un porcentaje significativo del tiempo de ejecución
- el desarrollo interactivo necesita adquirir sesiones rápidamente
La disponibilidad de los starter pools es de mejor esfuerzo; una sesión puede recurrir igualmente al aprovisionamiento estándar cuando no hay capacidad precalentada disponible.
No confundas la optimización del inicio con la optimización de la ejecución de consultas.
30. Usa High Concurrency cuando notebooks compatibles puedan compartir una sesión
El modo High Concurrency (alta concurrencia) de Fabric permite que cargas de trabajo de notebooks compatibles compartan una aplicación Spark en ejecución en lugar de crear una sesión Spark separada para cada una.
Es útil para:
- grupos de actividades de notebook
- notebooks cortos en los que domina el inicio
- orquestación paralela de notebooks
- mejorar el uso de los recursos de Spark
Compartir sesión requiere un contexto de carga de trabajo compatible, incluidos el mismo límite de usuario, el mismo Lakehouse predeterminado y la misma configuración de cómputo Spark.
No des por hecho que todos los notebooks compartirán la misma sesión.
31. Usa un session tag para reutilizar sesiones de notebooks de pipeline cuando High Concurrency esté habilitado
En las actividades Notebook de los pipelines de Fabric, un session tag puede dirigir a las actividades compatibles para que reutilicen una sesión Spark existente.
Usa un tag coherente para los notebooks que deban compartir cómputo.
Se trata principalmente de una optimización del inicio y la reutilización de sesiones.
No hace más rápida una consulta Spark lenta en sí misma.
32. No generes una actividad paralela de notebooks excesiva
La ejecución paralela de notebooks sigue compartiendo recursos de Spark finitos.
Si muchos notebooks hijos se ejecutan a la vez, pueden competir por:
- CPU
- memoria
- executors
- recursos de shuffle
Más concurrencia no significa automáticamente más rendimiento.
Cuando uses orquestación de notebooks, como la ejecución paralela de notebooks, ajusta la concurrencia al cómputo Spark disponible en lugar de maximizarla a ciegas.
33. Usa autoescalado y asignación dinámica de executors para cargas variables cuando corresponda
Los pools de Spark de Fabric pueden usar autoescalado y asignación dinámica de executors.
Esto puede ayudar cuando el tamaño de la carga de trabajo varía significativamente.
Aun así, monitorea:
- el comportamiento del escalado
- las colas
- el tiempo de ejecución
- el consumo de capacidad
El autoescalado no puede compensar código patológico, como joins cartesianos accidentales o la recopilación de resultados masivos en el driver.
34. Considera el Native Execution Engine solo donde esté admitido y validado
Fabric ofrece el Native Execution Engine para cargas de trabajo Spark admitidas.
Puede mejorar las operaciones admitidas, pero debe tratarse como una opción de motor de ejecución y no como un sustituto de:
- una buena organización de los datos
- joins correctos
- poda de particiones
- evitar el skew
- un cómputo bien dimensionado
Valida la compatibilidad y mide tu carga de trabajo real antes de estandarizarlo.
35. Usa el monitoreo de Spark para encontrar la etapa que domina el tiempo de ejecución
Cuando un notebook sea lento, revisa la información de monitoreo de Spark de Fabric y de Spark UI sobre:
- la duración de las etapas
- la duración de las tareas
- el tamaño de la entrada
- la lectura/escritura de shuffle
- las tareas fallidas o reintentadas
- el uso de los executors
- las tareas con skew
La celda del notebook te dice en qué parte del notebook.
La información de etapas y tareas de Spark te dice en qué parte de la ejecución distribuida.
Usa ambas.
Qué significa el resultado
| Señal | Qué suele indicar |
|---|---|
| Retraso largo antes del primer trabajo de Spark | Adquisición/inicio de sesión/inicialización del entorno |
| Lectura grande | Demasiados datos de entrada o poda insuficiente |
Exchange en el plan |
Redistribución de datos/shuffle |
| Una tarea mucho más lenta que las demás | Posible skew o tamaño de partición desigual |
| Lectura/escritura de shuffle elevada | Presión de joins/agregaciones/redistribución |
| Presión de memoria en el driver | Demasiados datos movidos al driver u objetos locales grandes |
| Etapas idénticas repetidas | Lineage recalculada o acciones repetidas |
| Gran aumento de filas después de un join | Problema de cardinalidad del join |
| Muchos archivos de salida diminutos | Patrón de escritura con demasiadas particiones |
| Notebook rápido en modo interactivo pero lento en un pipeline | Pueden influir diferencias de sesión/inicio/configuración/concurrencia |
| Varios notebooks cortos inician Spark cada uno | Oportunidad de reutilización de sesión / High Concurrency |
Qué revisar
El inicio domina el tiempo total
Si la ejecución de Spark en sí es corta, investiga:
- starter pools
- High Concurrency
- session tags de pipeline
- actividades de notebook separadas innecesarias
No optimices una consulta Spark de 10 segundos para resolver un problema de inicio de 2 minutos.
Una etapa tiene una o unas pocas tareas rezagadas
Entre las causas probables están:
- skew en las claves
- particiones desiguales
- un archivo o partición inusualmente grande
- presión sobre los executors
Inspecciona la distribución de particiones y claves.
El shuffle domina el tiempo de ejecución
Investiga:
- la estrategia de join
- las claves de agrupación
- los reparticionamientos innecesarios
- el volumen de datos antes del shuffle
- si se puede hacer broadcast de una tabla de búsqueda pequeña
- el skew
El driver falla o se vuelve lento
Busca:
collect()toPandas()- listas o diccionarios de Python grandes
- procesamiento de Python fila por fila
- resultados grandes mostrados en el notebook
Mantén distribuidos los datos grandes.
El tiempo de ejecución cambia drásticamente con código similar
Compara:
- el volumen de entrada
- el número de archivos
- el plan
- la configuración de Spark
- el pool y el modo de sesión
- la carga de trabajo concurrente
- el skew
No compares duraciones totales sin un contexto de carga de trabajo equivalente.
La salida genera muchos archivos pequeños
Busca un número excesivo de particiones en la etapa de escritura.
Reduce las particiones de forma deliberada cuando la salida ya sea pequeña, pero evita forzar una sola partición en salidas grandes.
Notas de producción
El rendimiento de los notebooks de Fabric tiene dos capas distintas
Trátalas por separado:
sobrecarga de sesión/plataforma de Fabric
ejecución de la carga de trabajo de Spark
Las optimizaciones de plataforma y sesión incluyen:
- starter pools
- High Concurrency
- reutilización de sesiones
- dimensionamiento de pools
Las optimizaciones de Spark incluyen:
- poda (pruning)
- estrategia de join
- particionamiento
- reducción del skew
- evitar la recopilación en el driver
- organización de los archivos
Mezclar estas capas lleva a un mal diagnóstico.
High Concurrency tiene reglas de compatibilidad
Las cargas de trabajo compatibles pueden compartir una aplicación Spark, pero compartir sesión no es universal.
Las diferencias de Lakehouse o de configuración de cómputo Spark pueden dar lugar a sesiones separadas.
Diseña la orquestación de notebooks teniendo en cuenta esa restricción.
La densidad actual de High Concurrency es configurable
Fabric admite un límite configurable de notebooks compartidos mediante la propiedad de Spark del Environment:
spark.highConcurrency.max
El valor predeterminado es inferior al máximo de la plataforma.
Aumentar la concurrencia puede mejorar la densidad de sesiones, pero también aumenta la competencia por los recursos dentro de la sesión Spark compartida.
Ajústalo a partir del comportamiento medido de la carga de trabajo en lugar de fijar automáticamente el máximo.
En Spark no existen instantáneas tipo DMV como en SQL Server
La investigación del rendimiento se basa en gran medida en:
- planes físicos
- etapas y tareas de Spark
- métricas de los executors
- monitoreo de Fabric
- historial de cargas de trabajo y ejecuciones
Captura los metadatos de ejecución si necesitas comparaciones de antes y después.
La capacidad y el dimensionamiento de los pools importan una vez entendidos los problemas de código
Un pool más grande puede hacer que una carga de trabajo sea más rápida.
También puede encarecer el código ineficiente.
Corrige las lecturas evitables, la multiplicación de filas, el skew y la recopilación en el driver antes de usar el tamaño del cómputo como principal estrategia de ajuste.
Las colas pueden ser un problema de capacidad y no del código del notebook
Si los jobs pasan tiempo esperando a adquirir recursos de Spark, investiga:
- la concurrencia del workspace/capacidad
- el consumo actual de Spark
- los jobs paralelos
- la idoneidad de High Concurrency
- la configuración del pool
No interpretes el tiempo en cola como tiempo de transformación de Spark.
Autotune depende de la versión y de las funcionalidades
Fabric tiene capacidades de ajuste automático de Spark (autotune), pero su disponibilidad y compatibilidad dependen del runtime y de la configuración de las funcionalidades.
No construyas una estrategia de rendimiento en producción alrededor de autotune sin verificar el runtime y el modo de carga de trabajo admitidos actualmente.
Mide con datos representativos a escala de producción
Un notebook que es rápido con:
100.000 filas
puede comportarse de forma muy distinta con:
500 millones de filas
debido a:
- el shuffle
- el skew
- el número de particiones
- la organización de los archivos
- la presión de memoria
Las pruebas de rendimiento deben parecerse a la carga de trabajo real.
Errores comunes
1. Aumentar el cómputo de Spark antes de encontrar el cuello de botella
Más cómputo no corrige:
- joins mal planteados
- explosión de filas
collect()- skew
- lecturas repetidas
Mide primero.
2. Cronometrar solo las transformaciones de DataFrame
Spark es lazy.
Sin una acción, puedes estar cronometrando la construcción del plan en lugar de la ejecución.
3. Usar repartition(1) para obtener un único archivo de salida
Esto crea un cuello de botella de una sola partición.
Trata la exportación a un único archivo como un requisito aparte.
4. Almacenar en caché todos los DataFrames
El almacenamiento en caché tiene un costo de materialización y de memoria.
Almacena en caché solo los datos costosos que se vayan a reutilizar.
5. Hacer broadcast de una tabla sin comprobar su tamaño
Un broadcast demasiado grande puede generar presión de memoria.
Valida primero el lado pequeño.
6. Usar UDF de Python para operaciones que Spark ya admite
Las expresiones integradas de Spark suelen darle al optimizador una mejor ruta de ejecución.
7. Ignorar el skew de los datos
El tamaño medio de las particiones puede parecer correcto mientras una sola clave «caliente» controla la duración de la etapa.
Inspecciona la distribución.
8. Aumentar la concurrencia de notebooks a ciegas
Los notebooks en paralelo pueden competir por los mismos recursos finitos.
Ajusta para maximizar el rendimiento, no la cantidad de actividad en paralelo.
9. Tratar el inicio de sesión como tiempo de ejecución de la consulta
Un notebook puede ser lento incluso antes de que empiece la transformación de Spark.
Separa las mediciones de inicio y de ejecución.
10. Optimizar el código ignorando la organización de los archivos
Muchos archivos pequeños o una mala organización de las particiones pueden hacer lenta una transformación de DataFrame bien escrita.
Inspecciona el lado del almacenamiento cuando domine la planificación de la lectura.
¿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.