Migreren van klassieke berekening naar serverloze berekening

Migreer uw workloads van klassieke berekening naar serverloze berekeningen. Serverloze rekenprocessen verwerken het inrichten, schalen, runtime-upgrades en optimalisatie automatisch.

De meeste klassieke workloads kunnen worden gemigreerd met minimale of geen codewijzigingen. Deze pagina is gericht op deze workloads. Sommige functies, zoals df.cache, worden nog niet ondersteund op serverloos, maar er zijn geen codewijzigingen nodig zodra deze beschikbaar zijn. Bepaalde werkbelastingen die afhankelijk zijn van R- of Scala-notebooks, vereisen klassieke berekeningen en kunnen niet worden gemigreerd naar serverloos. Zie Serverloze rekenbeperkingen voor een volledige lijst met huidige beperkingen.

Migratiestappen

Voer de volgende stappen uit om uw workloads van klassieke berekening naar serverloze berekeningen te migreren:

1. Controleer de vereisten: controleer of de toegang tot uw werkruimte, netwerken en cloudopslag voldoet aan de vereisten. Zie voordat u begint.
2. Code bijwerken: breng alle benodigde code- en configuratiewijzigingen aan. Zie Uw code bijwerken.
3. Test uw workloads: valideer de compatibiliteit en correctheid voordat u de overstap maakt. Zie Uw workloads testen.
4. Kies een prestatiemodus: selecteer de prestatiemodus die het beste overeenkomt met uw workloadvereisten. Zie Een prestatiemodus kiezen.
5. Migreren in fasen: serverloos incrementeel implementeren, te beginnen met nieuwe en workloads met een laag risico. Zie Migreren in fasen.
6. Kosten bewaken: serverloos DBU-verbruik bijhouden en waarschuwingen instellen. Zie Kosten monitoren.

Voordat u begint

Voordat u begint met migreren, moet u mogelijk een aantal verouderde configuraties in uw werkruimte bijwerken.

Controleer of uw werkruimte zich in een ondersteunde regio bevindt.

Uw code bijwerken

In de volgende secties worden de code- en configuratiewijzigingen vermeld die nodig zijn om uw workloads compatibel te maken met serverloos.

Toegang tot gegevens

Verouderde patronen voor gegevenstoegang worden niet ondersteund op serverloos. Werk uw code bij om in plaats daarvan Unity Catalog te gebruiken.

# 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

APIs en code

Bepaalde API's en codepatronen worden niet ondersteund op serverloos. Raadpleeg deze tabel om te zien of uw code moet worden bijgewerkt.

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")

Bibliotheken en omgevingen

U kunt bibliotheken en omgevingen op werkruimteniveau beheren met behulp van basisomgevingen en op notebookniveau met behulp van de serverloze omgeving van het notebook.

Maak Python pakketten vast in requirements.txt voor reproduceerbare omgevingen. Zie Python-pakketversies specificeren.

Streamen

Streaming-workloads worden ondersteund op serverloze architectuur, maar bepaalde triggers worden niet ondersteund. Werk uw code bij om de ondersteunde triggers te gebruiken.

Voor continue streaming migreert u naar declaratieve Spark-pijplijnen in de continue modus of gebruikt u taken met continue planning met AvailableNow. Voor grote bronnen stelt u maxFilesPerTrigger of maxBytesPerTrigger om out-of-memory-fouten te voorkomen.

# 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))

Uw workloads testen

1. Snelle compatibiliteitstest: voer de workload uit op klassieke berekeningen met de standaardtoegangsmodus en Databricks Runtime 14.3 of hoger. Als de uitvoering slaagt, kan de workload zonder codewijzigingen naar serverloos worden gemigreerd.
2. Vergelijking van A/B (aanbevolen voor productie): Voer dezelfde workload uit op klassiek (beheer) en serverloos (experiment). De uitvoertabellen vergelijken en de juistheid controleren. Herhalen totdat de uitvoer overeenkomt.
3. Tijdelijke configuraties: u kunt tijdens het testen tijdelijk ondersteunde Spark-configuraties instellen. Verwijder ze zodra ze stabiel zijn.

Een prestatiemodus kiezen

Serverloze taken en pijplijnen ondersteunen twee prestatiemodi: standaard en geoptimaliseerd voor prestaties. De prestatiemodus die u kiest, is afhankelijk van uw workloadvereisten.

Migreren in fasen

1. Nieuwe workloads: start alle nieuwe notebooks en taken op serverloos.
2. Workloads met een laag risico: PySpark-/SQL-workloads migreren die al in de standaardtoegangsmodus en Databricks Runtime 14.3 of hoger staan.
3. Complexe workloads: migreren die codewijzigingen vereisen, zoals het herschrijven van RDD's, het bijwerken van DBFS, en het oplossen van triggerproblemen.
4. Resterende workloads: controleer regelmatig naarmate de mogelijkheden worden uitgebreid.

Kosten controleren

Serverloze facturering is gebaseerd op DBU-verbruik, niet op clustertijd. Valideer de kostenverwachtingen met representatieve workloads voordat u op schaal migreert. Zie De kosten van serverloze berekeningen bewaken voor hulpprogramma's en strategieën voor het bewaken van serverloze kosten.

Aanvullende bronnen

• Aanbevolen procedures voor serverloze berekening: Optimalisatietips voor serverloze workloads
• Beperkingen voor serverloze berekeningen: volledige lijst met huidige beperkingen en niet-ondersteunde functies
• De serverloze omgeving configureren: Bibliotheken en afhankelijkheden beheren
• Ondersteunde Spark-configuraties: Spark-configuraties beschikbaar op serverloos
• Spark Connect versus klassieke Spark: Gedragsverschillen in serverloze architectuur
• Serverloze netwerkbeveiliging: NCC's, Private Link en firewallconfiguratie
• Releaseopmerkingen voor serverless computing: Nieuwe mogelijkheden bijhouden wanneer ze worden uitgebracht
• Upgradehandleiding voor Unity Catalog: Migreren van Hive Metastore naar Unity Catalog

U kunt ook verwijzen naar de volgende blogberichten voor meer informatie:

• Wat is serverloze computing?: Overzicht van serverloze mogelijkheden en klantresultaten
• Ontwikkeling van data engineering: hoe serverloze compute notebooks en Lakeflow-taken transformeert: hoe serverloze computing Lakeflow-taken en -pijplijnen aandrijft.