Migrieren von klassischem Compute zu serverloser Berechnung

Migrieren Sie Ihre Workloads von klassischem Compute zu serverloser Berechnung. Serverlose Berechnungsdienste übernehmen automatisch die Bereitstellung, Skalierung, Laufzeitupgrades und Optimierung.

Die meisten klassischen Workloads können mit minimalen oder ohne Codeänderungen migriert werden. Diese Seite konzentriert sich auf diese Workloads. Einige Features, wie z. B. df.cache, werden auf serverlosen Plattformen noch nicht unterstützt, erfordern aber keine Codeänderungen, sobald sie verfügbar sind. Bestimmte Workloads, die von R- oder Scala-Notizbüchern abhängen, erfordern eine klassische Berechnung und können nicht ohne Server migriert werden. Eine vollständige Liste der aktuellen Einschränkungen finden Sie unter Serverless Compute Limitations.

Schritte bei der Migration

Führen Sie die folgenden Schritte aus, um Ihre Workloads von der klassischen Compute zur serverlosen Berechnung zu migrieren:

1. Überprüfen Sie die Voraussetzungen: Überprüfen Sie, ob Ihr Arbeitsbereich, Ihr Netzwerk und der Cloudspeicherzugriff die Anforderungen erfüllen. Weitere Informationen finden Sie unter Vorbereitung.
2. Aktualisieren von Code: Nehmen Sie alle erforderlichen Code- und Konfigurationsänderungen vor. Informationen finden Sie unter Aktualisieren des Codes.
3. Testen Sie Ihre Workloads: Überprüfen Sie die Kompatibilität und Korrektheit, bevor Sie sie überschneiden. Weitere Informationen finden Sie unter "Testen Ihrer Workloads".
4. Wählen Sie einen Leistungsmodus aus: Wählen Sie den Leistungsmodus aus, der Ihren Workloadanforderungen am besten entspricht. Weitere Informationen finden Sie unter "Auswählen eines Leistungsmodus".
5. In Phasen migrieren: Führen Sie serverlose Architekturen schrittweise ein, beginnend mit neuen und risikoarmen Workloads. Siehe Migrieren in Phasen.
6. Überwachen sie die Kosten: Verfolgen Sie den Serverlosen DBU-Verbrauch und richten Sie Warnungen ein. Siehe "Kosten überwachen".

Bevor Sie anfangen

Bevor Sie mit der Migration beginnen, müssen Sie möglicherweise einige ältere Konfigurationen in Ihrem Arbeitsbereich aktualisieren.

Vergewissern Sie sich, dass sich Ihr Arbeitsbereich in einer unterstützten Region befindet.

Aktualisieren Ihres Codes

In den folgenden Abschnitten werden die Code- und Konfigurationsänderungen aufgeführt, die erforderlich sind, um Ihre Workloads mit serverlosen Servern kompatibel zu machen.

Datenzugriff

Ältere Datenzugriffsmuster werden auf serverlosen Servern nicht unterstützt. Aktualisieren Sie Ihren Code, um stattdessen Unity-Katalog zu verwenden.

# 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 und Code

Bestimmte APIs und Codemuster werden auf serverlosen Servern nicht unterstützt. Verweisen Sie auf diese Tabelle, um festzustellen, ob Ihr Code aktualisiert werden muss.

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 und Umgebungen

Sie können Bibliotheken und Umgebungen auf Arbeitsbereichsebene mithilfe von Basisumgebungen und auf Notizbuchebene mithilfe der serverlosen Umgebung des Notizbuchs verwalten.

Anheften Python Pakete in requirements.txt für reproduzierbare Umgebungen. Siehe Specify Python Paketversionen.

Streamen

Streamingworkloads werden auf serverlosen Servern unterstützt, aber bestimmte Trigger werden nicht unterstützt. Aktualisieren Sie Ihren Code, um die unterstützten Trigger zu verwenden.

Migrieren Sie für kontinuierliches Streaming zum fortlaufenden Modus auf Spark Declarative Pipelines oder verwenden Sie kontinuierlich-geplante Jobs mit AvailableNow. Setzen Sie bei großen Quellen maxFilesPerTrigger oder maxBytesPerTrigger ein, um Speicherfehler zu verhindern.

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

Testen Sie Ihre Workloads

1. Schnellkompatibilitätstest: Führen Sie die Workload auf der klassischen Compute mit Standardzugriffsmodus und Databricks Runtime 14.3 oder höher aus. Wenn die Ausführung erfolgreich ist, kann die Workload ohne Codeänderungen zu serverlosen Servern migriert werden.
2. A/B-Vergleich (empfohlen für die Produktion): Führen Sie dieselbe Workload sowohl auf der klassischen (Kontrollgruppe) als auch der serverlosen (Experiment) Umgebung aus. Diff-Ergebnistabellen und Korrektheit überprüfen. Iteriere, bis die Ausgaben übereinstimmen.
3. Temporäre Konfigurationen: Sie können während des Tests vorübergehend unterstützte Spark-Konfigurationen festlegen. Entfernen Sie sie, sobald sie stabil sind.

Auswählen eines Leistungsmodus

Serverlose Aufträge und Pipelines unterstützen zwei Leistungsmodi: Standard- und Leistungsoptimiert. Der von Ihnen ausgewählte Leistungsmodus hängt von Ihren Workloadanforderungen ab.

Migrieren in Phasen

1. Neue Workloads: Starten Sie alle neuen Notizbücher und Jobs in einer serverlosen Umgebung.
2. Workloads mit geringem Risiko: Migrieren Sie PySpark/SQL-Workloads bereits im Standardzugriffsmodus und Databricks Runtime 14.3 oder höher.
3. Komplexe Workloads: Migrieren Sie Arbeitslasten, die Codeänderungen benötigen (RDD-Neuschreibungen, DBFS-Updates, Triggerfixes).
4. Verbleibende Workloads: Überprüfen Sie regelmäßig, wenn die Funktionen erweitert werden.

Kosten überwachen

Serverlose Abrechnung basiert auf DBU-Verbrauch und nicht auf Cluster-Uptime. Überprüfen Sie die Kostenerwartungen mit repräsentativen Workloads, bevor Sie die Migration im großen Maßstab durchführen. Tools und Strategien zur Überwachung serverloser Kosten finden Sie unter Überwachen der Kosten für serverloses Berechnen.

Weitere Ressourcen

• Bewährte Methoden für serverlose Berechnung: Optimierungstipps für serverlose Workloads
• Serverlose Computebeschränkungen: Vollständige Liste der aktuellen Einschränkungen und nicht unterstützten Features
• Konfigurieren der serverlosen Umgebung: Verwalten von Bibliotheken und Abhängigkeiten
• Unterstützte Spark-Konfigurationen: Spark-Konfigurationen, die auf serverlosen Servern verfügbar sind
• Spark Connect im Vergleich zum klassischen Spark: Verhaltensunterschiede in der serverlosen Architektur
• Serverlose Netzwerksicherheit: NCCs, Private Link und Firewallkonfiguration
• Anmerkungen zur Veröffentlichung von serverlosen Rechenkapazitäten: Nachverfolgen neuer Funktionen bei der Veröffentlichung
• Unity Catalog-Upgradehandbuch: Migrieren von Hive Metastore zu Unity-Katalog

Weitere Informationen finden Sie auch in den folgenden Blogbeiträgen:

• Was ist serverloses Computing?: Übersicht über serverlose Funktionen und Kundenergebnisse
• Entwicklung des Datenengineerings: Wie serverloses Computing Notebooks und Lakeflow-Aufträge transformiert: Wie serverloses Computing Lakeflow-Jobs und -Pipelines antreibt