Migración de proceso clásico a proceso sin servidor

Migre las cargas de trabajo del proceso clásico al proceso sin servidor. El proceso sin servidor controla automáticamente el aprovisionamiento, el escalado, las actualizaciones en tiempo de ejecución y la optimización.

La mayoría de las cargas de trabajo clásicas pueden migrar con cambios mínimos o sin código. Esta página se centra en esas cargas de trabajo. Algunas características, como df.cache, aún no se admiten en sin servidor, pero no requerirán cambios de código una vez disponibles. Algunas cargas de trabajo que dependen de cuadernos de R o Scala requieren proceso clásico y no podrán migrar a sin servidor. Para obtener una lista completa de las limitaciones actuales, consulte Limitaciones de proceso sin servidor.

Pasos de migración

Para migrar las cargas de trabajo de proceso clásico a proceso sin servidor, siga estos pasos:

1. Compruebe los requisitos previos: compruebe que el acceso al área de trabajo, las redes y el almacenamiento en la nube cumplen los requisitos. Consulte Antes de empezar.
2. Código de actualización: realice los cambios necesarios en el código y la configuración. Consulte Actualización del código.
3. Probar las cargas de trabajo: valide la compatibilidad y la integridad antes de cortar el servicio. Consulte Prueba de las cargas de trabajo.
4. Elija un modo de rendimiento: seleccione el modo de rendimiento que mejor se adapte a los requisitos de la carga de trabajo. Consulte Elegir un modo de rendimiento.
5. Migración en fases: implemente incrementalmente sin servidor, empezando por cargas de trabajo nuevas y de bajo riesgo. Consulte Migración en fases.
6. Supervisar los costos: realice un seguimiento del consumo de DBU sin servidor y configure alertas. Consulte Supervisión de los costos.

Antes de empezar

Antes de empezar a migrar, es posible que tenga que actualizar algunas configuraciones heredadas en el área de trabajo.

Confirme que el área de trabajo está en una región admitida.

Actualización del código

En las secciones siguientes se enumeran los cambios de código y configuración necesarios para que las cargas de trabajo sean compatibles con sin servidor.

Acceso a datos

Los patrones de acceso a datos heredados no son compatibles en entornos sin servidor. Actualice el código para usar el catálogo de Unity en su lugar.

# Classic
df = spark.read.csv("dbfs:/mnt/datalake/data.csv", header=True)
df.write.parquet("dbfs:/mnt/output/results")
df = spark.table("my_database.my_table")

# Serverless
df = spark.read.csv("/Volumes/main/sales/raw_data/data.csv", header=True)
df.write.parquet("/Volumes/main/analytics/output/results")
df = spark.table("main.my_database.my_table")  # three-level namespace

API y código

Algunas API y patrones de código no se admiten en un entorno sin servidor. Haga referencia a esta tabla para ver si el código debe actualizarse.

from pyspark.sql import functions as F

# sc.parallelize + rdd.map
# Classic:  rdd = sc.parallelize([1, 2, 3]); rdd.map(lambda x: x * 2).collect()
df = spark.createDataFrame([(1,), (2,), (3,)], ["value"])
result = df.select((F.col("value") * 2).alias("value")).collect()

# rdd.flatMap
# Classic:  sc.parallelize(["hello world"]).flatMap(lambda l: l.split(" ")).collect()
df = spark.createDataFrame([("hello world",)], ["line"])
words = df.select(F.explode(F.split("line", " ")).alias("word")).collect()

# rdd.groupByKey
# Classic:  rdd.groupByKey().mapValues(list).collect()
df = spark.createDataFrame([("a", 1), ("b", 2), ("a", 3)], ["key", "value"])
grouped = df.groupBy("key").agg(F.collect_list("value").alias("values")).collect()

# rdd.mapPartitions → applyInPandas
import pandas as pd
def process_group(pdf: pd.DataFrame) -> pd.DataFrame:
    return pd.DataFrame({"total": [pdf["id"].sum()]})
result = (spark.range(100).repartition(4)
    .groupBy(F.spark_partition_id())
    .applyInPandas(process_group, schema="total long").collect())

# sc.textFile → spark.read.text
df = spark.read.text("/Volumes/catalog/schema/volume/file.txt")

from pyspark.sql.functions import broadcast

# sc.broadcast → broadcast join
result = main_df.join(broadcast(lookup_df), "key")

# sc.accumulator → DataFrame aggregation
total = df.agg(F.sum("amount")).collect()[0][0]

# sqlContext.sql → spark.sql
result = spark.sql("SELECT * FROM main.db.table")

# df.cache() → remove caching calls
# Materialize expensive intermediate results to Delta as a workaround:
df = spark.read.parquet(path)
result = df.filter("status = 'active'")
expensive_df.write.format("delta").mode("overwrite").saveAsTable("main.scratch.temp")
result = spark.table("main.scratch.temp")

Bibliotecas y entornos

Puede administrar bibliotecas y entornos en el nivel de área de trabajo mediante entornos base y en el nivel de cuaderno mediante el entorno sin servidor del cuaderno.

Fije paquetes de Python en requirements.txt para entornos reproducibles. Consulte Especificar versiones del paquete de Python.

Transmisión en línea

Las cargas de trabajo de streaming se admiten en sin servidor, pero no se admiten determinados desencadenadores. Actualice el código para usar los desencadenadores admitidos.

Para el streaming continuo, migre a canalizaciones declarativas de Spark en modo continuo o use trabajos de programación continua con AvailableNow. Para orígenes grandes, establezca maxFilesPerTrigger o maxBytesPerTrigger para evitar errores de falta de memoria.

# Classic (not supported on serverless — default trigger is ProcessingTime)
query = df.writeStream.format("delta").outputMode("append").start()

# Serverless (explicit AvailableNow trigger)
query = (df.writeStream.format("delta").outputMode("append")
    .trigger(availableNow=True)
    .option("checkpointLocation", checkpoint_path)
    .start(output_path))
query.awaitTermination()

# With OOM prevention for large sources
query = (spark.readStream.format("delta")
    .option("maxFilesPerTrigger", 100)
    .option("maxBytesPerTrigger", "10g")
    .load(input_path)
    .writeStream.format("delta")
    .trigger(availableNow=True)
    .option("checkpointLocation", checkpoint_path)
    .start(output_path))

Prueba de las cargas de trabajo

1. Prueba de compatibilidad rápida: ejecute la carga de trabajo en el proceso clásico con el modo de acceso estándar y Databricks Runtime 14.3 o superior. Si la ejecución se ejecuta correctamente, la carga de trabajo puede migrar a sin servidor sin cambios en el código.
2. Comparación A/B (recomendada para producción): ejecute la misma carga de trabajo en el clásico (control) y sin servidor (experimento). Comparar tablas de salida y verificar la corrección. Iteración hasta que las salidas coincidan.
3. Configuraciones temporales: puede establecer temporalmente configuraciones de Spark admitidas durante las pruebas. Quítelos una vez que sean estables.

Elegir un modo de rendimiento

Los trabajos y canalizaciones sin servidor admiten dos modos de rendimiento: estándar y optimizados para el rendimiento. El modo de rendimiento que elija depende de los requisitos de carga de trabajo.

Migración en fases

1. Nuevas cargas de trabajo: Comience todos los cuadernos y trabajos nuevos en modalidad serverless.
2. Cargas de trabajo de bajo riesgo: migre cargas de trabajo de PySpark/SQL ya en modo de acceso estándar y Databricks Runtime 14.3 o superior.
3. Cargas de trabajo complejas: migre las cargas de trabajo que necesitan cambios de código (reescrituras de RDD, actualizaciones de DBFS, correcciones de desencadenadores).
4. Cargas de trabajo restantes: revise periódicamente a medida que se expandan las funcionalidades.

Supervisión de costos

La facturación sin servidor se basa en el consumo de DBU, no en el tiempo de actividad del clúster. Valide las expectativas de costos con cargas de trabajo representativas antes de migrar a escala. Para obtener herramientas y estrategias para supervisar los costos sin servidor, consulte Supervisión del costo del proceso sin servidor.

Recursos adicionales

• Procedimientos recomendados para el proceso sin servidor: sugerencias de optimización para cargas de trabajo sin servidor
• Limitaciones de proceso sin servidor: lista completa de las limitaciones actuales y las características no admitidas
• Configuración del entorno sin servidor: Administración de bibliotecas y dependencias
• Configuraciones de Spark admitidas: configuraciones de Spark disponibles en serverless
• Spark Connect frente a Spark clásico: diferencias de comportamiento en la arquitectura sin servidor
• Seguridad de red sin servidor: NCC, Private Link y configuración del firewall
• Notas de la versión de computación sin servidor: Realizar un seguimiento de las nuevas capacidades a medida que se lanzan
• Guía de actualización del catálogo de Unity: Migración desde Metastore de Hive al catálogo de Unity

También puede consultar las siguientes entradas de blog para obtener más información:

• ¿Qué es la informática sin servidor?: Información general sobre las funcionalidades sin servidor y los resultados del cliente
• Evolución de la ingeniería de datos: Cómo la computación sin servidor está transformando cuadernos y trabajos de Lakeflow: Cómo el procesamiento sin servidor impulsa los trabajos y canalizaciones de Lakeflow