Explorar guías rápidas · Microsoft Fabric

Tecnología: Microsoft FabricCategoría: RendimientoNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Mide la acción de Spark, no solo la construcción del DataFrame
  5. 2. Inspecciona el plan físico
  6. 3. Comprueba el número actual de particiones
  7. 4. Inspecciona la distribución de filas por partición
  8. 5. Filtra antes de las transformaciones costosas
  9. 6. Evita select("*") cuando solo necesitas unas pocas columnas
  10. 7. Inspecciona la estrategia de join
  11. 8. Haz broadcast de una tabla de búsqueda realmente pequeña
  12. 9. Revisa las claves de join duplicadas antes de culpar a Spark
  13. 10. Reduce los datos antes de un join grande
  14. 11. Busca skew en las claves de join o de agrupación
  15. 12. Evita collect() con resultados grandes
  16. 13. Evita toPandas() innecesario
  17. 14. Evita los bucles de Python sobre filas de Spark
  18. 15. Prefiere las expresiones integradas de Spark a las UDF de Python
  19. 16. Almacena en caché solo los DataFrames que reutilizas
  20. 17. Comprueba el estado de la caché
  21. 18. Evita acciones repetidas innecesarias
  22. 19. Inspecciona la configuración de Spark relevante para la sesión
  23. 20. Inspecciona los ajustes importantes de ejecución adaptativa
  24. 21. Reparticiona cuando necesites una redistribución real
  25. 22. Usa coalesce para reducir particiones sin un shuffle completo
  26. 23. Evita repartition(1) en salidas de producción grandes
  27. 24. Comprueba si los archivos pequeños forman parte del problema
  28. 25. Escribe solo las columnas que necesitas
  29. 26. Usa overwrite de forma deliberada
  30. 27. Deja de comparar ejecuciones de notebooks con volúmenes de entrada distintos
  31. 28. Separa la latencia de inicio de la ejecución de Spark
  32. 29. Usa starter pools de Fabric para acelerar el inicio de sesión cuando corresponda
  33. 30. Usa High Concurrency cuando notebooks compatibles puedan compartir una sesión
  34. 31. Usa un session tag para reutilizar sesiones de notebooks de pipeline cuando High Concurrency esté habilitado
  35. 32. No generes una actividad paralela de notebooks excesiva
  36. 33. Usa autoescalado y asignación dinámica de executors para cargas variables cuando corresponda
  37. 34. Considera el Native Execution Engine solo donde esté admitido y validado
  38. 35. Usa el monitoreo de Spark para encontrar la etapa que domina el tiempo de ejecución
  39. Qué significa el resultado
  40. Qué revisar
  41. El inicio domina el tiempo total
  42. Una etapa tiene una o unas pocas tareas rezagadas
  43. El shuffle domina el tiempo de ejecución
  44. El driver falla o se vuelve lento
  45. El tiempo de ejecución cambia drásticamente con código similar
  46. La salida genera muchos archivos pequeños
  47. Notas de producción
  48. El rendimiento de los notebooks de Fabric tiene dos capas distintas
  49. High Concurrency tiene reglas de compatibilidad
  50. La densidad actual de High Concurrency es configurable
  51. En Spark no existen instantáneas tipo DMV como en SQL Server
  52. La capacidad y el dimensionamiento de los pools importan una vez entendidos los problemas de código
  53. Las colas pueden ser un problema de capacidad y no del código del notebook
  54. Autotune depende de la versión y de las funcionalidades
  55. Mide con datos representativos a escala de producción
  56. Errores comunes
  57. 1. Aumentar el cómputo de Spark antes de encontrar el cuello de botella
  58. 2. Cronometrar solo las transformaciones de DataFrame
  59. 3. Usar repartition(1) para obtener un único archivo de salida
  60. 4. Almacenar en caché todos los DataFrames
  61. 5. Hacer broadcast de una tabla sin comprobar su tamaño
  62. 6. Usar UDF de Python para operaciones que Spark ya admite
  63. 7. Ignorar el skew de los datos
  64. 8. Aumentar la concurrencia de notebooks a ciegas
  65. 9. Tratar el inicio de sesión como tiempo de ejecución de la consulta
  66. 10. Optimizar el código ignorando la organización de los archivos
  67. Siguiente paso
  68. 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.

Siguiente paso

Usa el cuello de botella observado para elegir la siguiente investigación.

  • Domina el inicio → evalúa starter pools, High Concurrency y la reutilización de sesiones.
  • Domina la lectura → reduce columnas y filas cuanto antes e inspecciona la organización Delta y de archivos.
  • Domina el shuffle → inspecciona los joins, las claves de agrupación, el particionamiento y los intercambios innecesarios.
  • Domina una tarea → investiga el skew y la distribución de particiones.
  • Aparece presión en el driver → elimina los collect() y toPandas() grandes y el procesamiento del lado de Python.
  • Aparecen etapas repetidas → revisa las acciones repetidas y almacena en caché solo los resultados intermedios costosos y reutilizables.
  • La salida del join se dispara → valida la unicidad de las claves y la cardinalidad de la relación.
  • La escritura es lenta o crea muchos archivos → inspecciona el número final de particiones y la estrategia de mantenimiento de Delta.
  • Los jobs quedan en cola antes de ejecutarse → investiga la capacidad/concurrencia de Spark en Fabric en lugar del código de las consultas.
  • El código ya es eficiente pero el tiempo de ejecución sigue siendo alto → evalúa el tamaño del pool, el autoescalado, la asignación dinámica y las opciones de motor de ejecución admitidas.

← Todas las guías rápidas