Microsoft Fabric

Cómo acelerar los notebooks de Microsoft Fabric

Un flujo de trabajo práctico para reducir, sin adivinar, el tiempo de inicio, lectura, shuffle, transformación y escritura Delta de los notebooks Fabric.

Por JaviPublicado Actualizado 10 min de lecturaIntermedio

Un notebook pasa por una sesión reutilizable y el procesamiento Spark hasta generar una salida Delta

Respuesta corta: un notebook de Fabric lento rara vez es lento en todo. Su duración se divide en fases distintas: espera en cola para obtener capacidad, inicio de una sesión de Spark, lectura de datos, transformación y shuffle, escritura del resultado y espera de lo que se ejecuta después. Cada fase tiene su propia evidencia y sus propias soluciones. Encuentra la fase que creció antes de cambiar ningún ajuste: un shuffle más rápido no sirve de nada si la ejecución pasó la mayor parte del tiempo esperando capacidad.

  1. ColaTrabajo de pipeline o programado esperando capacidad de Spark
  2. Inicio de sesiónStarter pool o clúster a petición, bibliotecas del entorno
  3. LecturaBytes y archivos leídos, poda, archivos pequeños
  4. TransformaciónForma del plan, acciones repetidas, recogidas en el driver
  5. ShuffleLectura y escritura de shuffle, tareas desequilibradas, desbordamiento
  6. EscrituraArchivos y particiones de salida, modo de escritura, compactación
Dónde pasa el tiempo una ejecución de notebook. Mide cada fase por separado; la más lenta decide qué optimizar. La cola y el inicio de sesión ocurren antes de tu código.

Después de la escritura, el pipeline todavía puede esperar a una actividad posterior; ese tiempo es de orquestación, no de Spark.

Problema

Un pipeline de producción llama a un notebook que a veces termina rápido y otras tarda mucho más. El notebook lee un historial amplio, realiza joins y agregaciones y sobrescribe un destino Delta. Antes de cambiar la capacidad o añadir llamadas a la caché, separa el retraso de orquestación, el inicio de la sesión, la ejecución de Spark y la escritura de la salida.

Registra como mínimo la ejecución del pipeline y del notebook, la ventana de entrada, las filas o archivos de entrada, las filas de salida y la duración de las etapas principales. Compara una ejecución lenta con otra normal que haya procesado un volumen similar. Los volúmenes diferentes son experimentos distintos.

Por qué sucede

Spark es lazy: las transformaciones de DataFrame construyen un plan, mientras que acciones como count, mostrar, recopilar y escribir lo ejecutan. Varias acciones de depuración pueden repetir la misma lineage costosa. Las operaciones amplias —incluidos joins, agrupaciones, operaciones distinct y reparticionamiento— pueden mover datos entre executors mediante un shuffle. Un pequeño número de particiones muy grandes puede dejar la mayoría de las tareas terminadas mientras unas pocas tareas rezagadas dominan el tiempo total.

El diseño de entrada también importa. Leer una tabla completa y filtrar después puede impedir el partition pruning o el data skipping. Seleccionar todas las columnas aumenta las E/S y la serialización. Miles de archivos pequeños añaden costos de listado y planificación. En la salida, forzar el reparticionamiento y repetir pequeños append puede sustituir un problema por otro.

Fabric añade una capa de sesión. Las cargas compatibles pueden reutilizar sesiones de alta concurrencia; otras configuraciones necesitan una sesión nueva. Los starter pools pueden reducir el tiempo de adquisición cuando la configuración encaja con sus restricciones, pero son una vía rápida de mejor esfuerzo, no una garantía. La configuración personalizada, las bibliotecas, los entornos y la red pueden cambiar el comportamiento del inicio. La guía de Microsoft sobre monitoreo de Spark y las vistas de detalles de sesión ayudan a separar esas causas.

Una secuencia de diagnóstico

  1. Establece una referencia. Elige una ejecución normal con datos comparables y anota su duración total y las medidas siguientes. Sin referencia, «lento» es una opinión.
  2. Separa inicio y ejecución. Compara el inicio de la actividad, el momento en que la sesión está lista y el primer job de Spark. El tiempo antes del primer job es cola o inicio de sesión; consulta reducir el tiempo de inicio de los notebooks.
  3. Revisa la cola y la concurrencia. Los notebooks lanzados por pipelines o por el programador esperan en una cola de tipo primero en entrar, primero en salir cuando los núcleos de Spark de la capacidad están ocupados; las ejecuciones interactivas se rechazan. Si las ejecuciones solo son lentas a ciertas horas, mira qué más comparte la capacidad antes de optimizar el código: el runbook de saturación de capacidad de Fabric (en inglés) cubre esa investigación.
  4. Revisa la lectura. Bytes y archivos leídos por las etapas de escaneo, si los filtros llegaron al escaneo y si la tabla tiene muchos archivos pequeños.
  5. Revisa el shuffle y el desequilibrio. Lectura y escritura de shuffle por etapa, desbordamiento y dispersión de la duración de las tareas: una tarea mucho más larga que la mediana indica desequilibrio.
  6. Revisa la lógica de transformación. Acciones repetidas sobre el mismo linaje, joins sobre datos sin filtrar, collect() o toPandas() con resultados grandes, UDF de Python en rutas críticas.
  7. Revisa la escritura. Número y tamaño de los archivos de salida, columnas de partición, append, sobrescritura o merge.
  8. Cambia una sola cosa y vuelve a ejecutar con datos comparables.
  9. Compara con la referencia en duración y en exactitud: recuentos de filas, duplicados, filas rechazadas.

Qué medir

Medida Dónde encontrarla Qué indica
Duración total Ejecución del pipeline, centro de supervisión Si la ejecución es realmente más lenta que su referencia
Tiempo de cola e inicio de sesión Centro de supervisión, detalles de la sesión Si se pierde tiempo antes de tu código
Duración por etapa Spark UI (Stages), página de detalle de la aplicación Spark Qué fase domina
Duración de tareas, mediana frente a máximo Métricas de resumen de la etapa en la Spark UI Desequilibrio: una tarea que retiene toda la etapa
Bytes y archivos leídos Métricas de entrada de la etapa, nodo de escaneo del plan Lectura excesiva, poda ausente, archivos pequeños
Lectura y escritura de shuffle, desbordamiento Métricas de la etapa Operaciones amplias costosas, presión de memoria
Número de tareas por etapa Detalle de la etapa Muy pocas (núcleos ociosos) o demasiadas (sobrecarga de planificación)
Número y tamaño de archivos de salida DESCRIBE DETAIL, historial de la tabla Escrituras que dejan archivos pequeños a todos los lectores posteriores

Archivos pequeños

Muchos archivos diminutos hacen que una tabla Delta sea lenta de leer y de mantener. Cada archivo se lista y se abre, añade una entrada al log de Delta y suele convertirse en su propia tarea, así que una lectura que necesitaría unas pocas tareas planifica miles de tareas muy cortas. Los merges y borrados también tienen más archivos que reescribir. La causa suele estar en la escritura: appends pequeños y frecuentes, microlotes de streaming o una salida particionada por una columna de alta cardinalidad.

Comprueba el tamaño medio de los archivos antes de elegir una solución:

PySpark
detail = spark.sql("DESCRIBE DETAIL SalesLakehouse.silver.orders").first()
avg_mb = detail.sizeInBytes / max(detail.numFiles, 1) / 1024**2
print({"files": detail.numFiles, "avg_file_mb": round(avg_mb, 1)})
PySpark3 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.

Una media de pocos megabytes en una tabla grande es una señal de alerta. Compacta con OPTIMIZE, considera Optimize Write para escrituras pequeñas y frecuentes, y agrupa los appends cuando el pipeline lo permita. Mantenimiento de tablas Delta: OPTIMIZE y VACUUM (en inglés) explica cuándo y cómo ejecutarlos con seguridad.

Recomendaciones prácticas

Empieza desglosando los tiempos. Si la mayor parte transcurre antes del primer job de Spark, investiga la adquisición de sesión y las bibliotecas. Si domina una etapa, inspecciona sus jobs, tareas, entradas, shuffle, spill, skew y salida. Si domina la escritura, revisa el número de particiones, el tamaño de los archivos, el modo de escritura y el diseño de la tabla posterior.

Lee solo las columnas y el intervalo necesarios. Coloca los filtros selectivos junto a la lectura y usa predicados alineados con el diseño físico de la tabla. Confirma en el plan ejecutado que se produjo pruning o skipping; la sintaxis de origen no lo demuestra por sí sola.

Reduce los datos antes de las operaciones amplias. Agrega con la granularidad requerida antes de hacer el join si se mantiene la corrección. Usa broadcast solo para datos de referencia realmente pequeños y después de medirlos. Evita collect() y toPandas() con resultados grandes porque trasladan los datos al driver. Para inspeccionar, usa muestras limitadas.

Guarda en caché solo un DataFrame costoso de recalcular que se reutiliza en varias acciones. Materialízalo de forma deliberada, comprueba la presión de almacenamiento y ejecuta unpersist() al terminar. Guardar en caché un DataFrame que se usa una sola vez añade trabajo y presión de memoria sin evitar cálculos repetidos.

Para la salida Delta, elige append, overwrite o merge según el contrato de datos. No reparticiones solo para obtener una cantidad preferida de archivos: repartition provoca un shuffle, mientras que coalesce reduce particiones sin una redistribución completa, pero puede generar desequilibrio. Evalúa Optimize Write, la compactación, V-Order y Z-Order según la frecuencia de escritura y los consumidores. Microsoft señala que V-Order puede mejorar las lecturas entre motores, pero añade costo de escritura en Spark; no es un interruptor universal para acelerar notebooks.

Ejemplo de patrón

El ejemplo mantiene la proyección y el filtrado cerca de la fuente, realiza una agregación reutilizable y valida la salida sin recopilar todos los datos.

PySpark
from pyspark.sql import functions as F
from pyspark.storagelevel import StorageLevel

run_date = "2026-10-02"

orders = (
    spark.read.table("SalesLakehouse.silver.orders")
    .select("order_id", "customer_id", "order_date", "status", "amount")
    .where(F.col("order_date") == F.lit(run_date))
    .where(F.col("status") == F.lit("Completed"))
)

daily_customer = (
    orders.groupBy("customer_id")
    .agg(
        F.countDistinct("order_id").alias("order_count"),
        F.sum("amount").alias("revenue"),
    )
    .persist(StorageLevel.MEMORY_AND_DISK)
)

output_rows = daily_customer.count()

(
    daily_customer.write
    .format("delta")
    .mode("append")
    .saveAsTable("SalesLakehouse.gold.daily_customer_sales")
)

print({"run_date": run_date, "output_rows": output_rows})
daily_customer.unpersist()
PySpark32 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.

Es un patrón, no una receta. Si daily_customer solo se utiliza para la escritura, elimina la persistencia y el count independiente, o sustitúyelo por una métrica producida en otro lugar. Si el proceso puede volver a ejecutarse, un append ciego puede duplicar la fecha; el diseño de escritura idempotente forma parte del contrato del pipeline.

Usa explain("formatted") antes y después de un cambio importante. Busca filtros cerca del scan, exchanges inesperados, estrategias de join y ramas repetidas. Después confirma el resultado con los jobs Spark ejecutados, porque las estimaciones y los planes no muestran todas las condiciones de ejecución.

Errores frecuentes

  • Cambiar la configuración de executors o shuffle antes de identificar la etapa lenta.
  • Ejecutar count, mostrar y escribir sobre la misma lineage costosa sin caché.
  • Leer todo el historial en una ejecución incremental.
  • Seleccionar todas las columnas «por si acaso».
  • Hacer broadcast de una consulta de búsqueda según el recuento de filas sin considerar los bytes.
  • Guardar todo en caché y provocar presión de eviction o spill.
  • Reparticionar cada salida en un solo archivo y destruir el paralelismo.
  • Tratar la reutilización de sesiones como si no tuviera implicaciones de aislamiento; el cálculo compartido requiere configuración compatible y planificación de cargas.
  • Comparar ejecuciones con volúmenes distintos y llamar regresión a la diferencia.

Síntoma, causa probable, primera comprobación

Síntoma Causa probable Primera comprobación
Mucho tiempo antes del primer job de Spark Cola, o inicio de sesión lento (clúster a petición, bibliotecas) Detalles de la sesión: origen del pool y motivo del retraso; tiempo de cola en la supervisión
Inicio rápido, ejecución lenta Volumen leído, operaciones amplias o la escritura Duración de las etapas en la Spark UI
Una etapa domina Un escaneo, join o agregación grandes Bytes leídos, shuffle y desbordamiento de esa etapa
Miles de tareas muy cortas Archivos pequeños o demasiadas particiones numFiles de DESCRIBE DETAIL; tareas por etapa
Una tarea dura mucho más que las demás Clave desequilibrada en un join o agregación Duración máxima frente a mediana; filas por clave
La escritura es lenta Muchos archivos o particiones de salida; merge en un destino grande Número de archivos de salida; condición del merge y tamaño del destino
La duración varía según la hora Contención de capacidad o cola Uso de la capacidad y tiempo de cola a esas horas
Spark termina rápido pero el pipeline llega tarde Dependencia posterior o espera de orquestación La línea de tiempo de actividades del pipeline, no la Spark UI

Cambia una variable que entiendas, vuelve a ejecutar con datos comparables y mantén controles de exactitud junto a las medidas de rendimiento. Un notebook más rápido que pierde filas sin coincidencia, duplica una partición o cambia el grano de negocio es una optimización fallida.

Relacionado

Fuentes

Comportamiento de Fabric revisado en Microsoft Learn en noviembre de 2026.

Etiquetas

  • Microsoft Fabric
  • Fabric Notebook
  • Rendimiento
  • PySpark
  • Delta Lake
  • Solución de problemas