Migrera från klassisk beräkning till serverlös beräkning

Migrera dina arbetsbelastningar från klassisk beräkning till serverlös beräkning. Serverlös beräkning hanterar etablering, skalning, körningsuppgraderingar och optimering automatiskt.

De flesta klassiska arbetsbelastningar kan migreras med minimala eller inga kodändringar. Den här sidan fokuserar på dessa arbetsbelastningar. Vissa funktioner, till exempel df.cache, stöds inte ännu på serverlösa, men kräver inte kodändringar när de är tillgängliga. Vissa arbetsbelastningar som är beroende av R- eller Scala-notebook-filer kräver klassisk beräkning och kan inte migreras till serverlösa. En fullständig lista över aktuella begränsningar finns i Begränsningar för serverlös beräkning.

Migreringssteg

Så här migrerar du dina arbetsbelastningar från klassisk beräkning till serverlös beräkning:

  1. Kontrollera kraven: Kontrollera att din arbetsyta, nätverk och molnlagringsåtkomst uppfyller kraven. Se Innan du börjar.
  2. Uppdateringskod: Gör nödvändiga kod- och konfigurationsändringar. Se Uppdatera din kod.
  3. Testa dina arbetsbelastningar: Verifiera kompatibilitet och korrekthet innan du byter över. Se Testa dina arbetsbelastningar.
  4. Välj ett prestandaläge: Välj det prestandaläge som bäst matchar dina arbetsbelastningskrav. Se Välj ett prestandaläge.
  5. Migrera i faser: Distribuera serverlöst stegvis, med början i nya arbetsbelastningar med låg risk. Se Migrera i faser.
  6. Övervaka kostnader: Spåra serverlös DBU-förbrukning och konfigurera aviseringar. Se Övervaka kostnader.

Innan du börjar

Innan du börjar migrera kan du behöva uppdatera några äldre konfigurationer på din arbetsyta.

Förutsättning Action Detaljer
Arbetsytan är aktiverad för Unity Catalog Migrera från Hive-metaarkivet om det behövs Uppgradera en Azure Databricks arbetsyta till Unity Catalog
Konfigurerat nätverk Ersätt VPC-peering med NCC:er, Private Link eller brandväggsregler Nätverk för serverlös beräkningsplattform
Åtkomst till molnlagring Ersätt äldre dataåtkomstmönster med externa platser i Unity Catalog Ansluta till molnobjektlagring med Unity Catalog

Bekräfta att arbetsytan finns i en region som stöds.

Uppdatera koden

I följande avsnitt visas de kod- och konfigurationsändringar som krävs för att göra dina arbetsbelastningar kompatibla med serverlösa.

Dataåtkomst

Äldre dataåtkomstmönster stöds inte på serverlösa. Uppdatera koden så att den använder Unity Catalog i stället.

Klassiskt mönster Serverlös lösning Detaljer
DBFS-sökvägar (dbfs:/...) Unity Catalog-volymer Vad är Unity Catalog-volymer?
Hive Metastore-tabeller Unity Catalog-tabeller (eller HMS-federation) Uppgradera en Azure Databricks arbetsyta till Unity Catalog
Autentiseringsuppgifter för lagringskonto Externa platser i Unity Catalog Ansluta till molnobjektlagring med Unity Catalog
Anpassade JDBC-JAR:er Lakehouse Federation Vad är sökfrågefederation?

Varning

DBFS-åtkomsten är begränsad på serverlös. Uppdatera alla dbfs:/ sökvägar till Unity Catalog-volymer innan du migrerar. Mer information finns i Migrera filer som lagras i DBFS.

Exempel: Ersätt DBFS-sökvägar och Hive-metaarkivreferenser 
# 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:er och kod

Vissa API:er och kodmönster stöds inte på serverlösa. Referera till den här tabellen för att se om koden behöver uppdateras.

Klassiskt mönster Serverlös lösning Detaljer
RDD-API:er (sc.parallelize, rdd.map) Api:er för DataFrame Jämför Spark Connect med Spark Classic
df.cache(), df.persist() Ta bort cachelagringsanrop Begränsningar för serverlös beräkning
spark.sparkContext, sqlContext Använd spark (SparkSession) direkt Jämför Spark Connect med Spark Classic
Hive-variabler (${var}) SQL DECLARE VARIABLE eller Python f-strings DECLARE VARIABLE
Spark-konfigurationer som inte stöds Ta bort konfigurationer som inte stöds. Serverlös justerar automatiskt de flesta inställningar. Konfigurera Spark-egenskaper för serverlösa notebooks och jobb
Exempel: Ersätt RDD-åtgärder med DataFrames 
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")
Exempel: Ersätt SparkContext och cachelagring 
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")

Bibliotek och miljöer

Du kan hantera bibliotek och miljöer på arbetsytans nivå med hjälp av basmiljöer och på notebook-nivå med hjälp av notebook-filens serverlösa miljö.

Klassiskt mönster Serverlös lösning Detaljer
Initieringsskript Serverlösa miljöer Konfigurera den serverlösa miljön
Bibliotek med klusteromfattning Bibliotek med notebook-omfång eller miljö Konfigurera den serverlösa miljön
Maven/JAR-bibliotek JAR-uppgiftsstöd för jobb; PyPI för notebookar JAR-uppgift för jobb
Docker-containrar Serverlösa miljöer för biblioteksbehov Konfigurera den serverlösa miljön

Fäst Python paket i requirements.txt för reproducerbara miljöer. Se Ange Python-paketversioner.

Strömmande

Strömmande arbetslaster stöds i serverlösa miljöer, men vissa utlösare stöds inte. Uppdatera koden så att den använder utlösare som stöds.

Spark-utlösare Understödd Notes
Trigger.AvailableNow() Ja Rekommenderad
Trigger.Once() Ja Detta är inaktuellt. Använd Trigger.AvailableNow() i stället.
Trigger.ProcessingTime(interval) No Returnerar INFINITE_STREAMING_TRIGGER_NOT_SUPPORTED
Trigger.Continuous(interval) No Använd kontinuerligt läge för Lakeflow Spark deklarativa pipelines i stället
Standard (utan inställning .trigger()) No Om du utelämnar .trigger() är standardvärdet ProcessingTime("0 seconds"), vilket inte stöds i en serverlös miljö. Ange .trigger(availableNow=True) alltid explicit.

För kontinuerlig direktuppspelning migrerar du till Spark Deklarativa Pipelines i kontinuerligt läge eller använder kontinuerligt schemalagda jobb med AvailableNow. För att förhindra minnesfel vid stora källor, ställ in maxFilesPerTrigger eller maxBytesPerTrigger.

Exempel: Åtgärda utlösare för direktuppspelning 
# 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))

Testa dina arbetsbelastningar

  1. Snabbkompatibilitetstest: Kör arbetsbelastningen på klassisk beräkning med standardåtkomstläge och Databricks Runtime 14.3 eller senare. Om körningen lyckas kan arbetsbelastningen migreras till serverlös utan några kodändringar.
  2. A/B-jämförelse (rekommenderas för produktion): Kör samma arbetsbelastning på klassisk (kontroll) och serverlös (experiment). Diff-utdatatabeller och verifiera korrekthet. Iterera tills utdata matchar.
  3. Tillfälliga konfigurationer: Du kan tillfälligt ställa in Spark-konfigurationer som stöds under testningen. Ta bort dem när de är stabila.

Välj ett prestandaläge

Serverlösa jobb och pipelines stöder två prestandalägen: standard och prestandaoptimerad. Vilket prestandaläge du väljer beror på dina arbetsbelastningskrav.

Läge Tillgänglighet Startup-företag Passar bäst för
Standard Jobb, Lakeflow Spark deklarativa pipeline 4–6 minuter Kostnadskänslig sats
Prestandaoptimerad Notebooks, Jobb, Lakeflow Spark Deklarativa pipelines Sekunder Interaktiv, svarstidskänslig

Migrera i faser

  1. Nya arbetslaster: Starta alla nya notebook-filer och jobb på serverlöst.
  2. Lågriskarbetsbelastningar: Migrera PySpark/SQL-arbetsbelastningar som redan är i standardåtkomstläge och Databricks Runtime 14.3 eller senare.
  3. Komplexa arbetsbelastningar: Migrera arbetsbelastningar som behöver kodändringar (RDD-omskrivningar, DBFS-uppdateringar, utlösarkorrigeringar).
  4. Återstående arbetsbelastningar: Granska regelbundet när funktionerna utökas.

Övervaka kostnader

Serverlös fakturering baseras på DBU-förbrukning, inte klusterupptid. Verifiera kostnadsförväntningarna med representativa arbetsbelastningar innan du migrerar i stor skala. Verktyg och strategier för att övervaka serverlösa kostnader finns i Övervaka kostnaden för serverlös beräkning.

Ytterligare resurser

Mer information finns i följande blogginlägg:

  • Last updated on