Migrer du calcul classique vers le calcul sans serveur

Migrez vos charges de travail du calcul classique vers le calcul serverless. Le calcul serverless gère automatiquement l’approvisionnement, la mise à l’échelle, les mises à niveau du runtime et l’optimisation.

La plupart des charges de travail classiques peuvent migrer avec un minimum ou aucun changement de code. Cette page se concentre sur ces charges de travail. Certaines fonctionnalités, telles que df.cache, ne sont pas encore prises en charge sur serverless, mais ne nécessitent pas de modifications de code une fois disponibles. Certaines charges de travail qui dépendent de notebooks R ou Scala nécessitent un calcul classique et ne pourront pas migrer vers serverless. Pour obtenir la liste complète des limitations actuelles, consultez les limitations de calcul sans serveur.

Étapes de la migration

Pour migrer vos charges de travail du calcul classique vers le calcul serverless, procédez comme suit :

1. Vérifiez les conditions préalables : vérifiez que votre espace de travail, votre réseau et votre accès au stockage cloud répondent aux exigences. Voir Avant de commencer.
2. Code de mise à jour : apportez les modifications nécessaires au code et à la configuration. Consultez Mettre à jour votre code.
3. Testez vos charges de travail : vérifiez la compatibilité et l’exactitude avant de passer à la nouvelle configuration. Consultez Tester vos charges de travail.
4. Choisissez un mode de performance : sélectionnez le mode de performance qui correspond le mieux à vos besoins en charge de travail. Voir Choisir un mode de performances.
5. Migrer en phases : Déployer serverless de manière incrémentielle, en commençant par de nouvelles charges de travail à faible risque. Consultez Migrer en phases.
6. Surveiller les coûts : effectuez le suivi de la consommation DBU serverless et configurez des alertes. Consultez Surveiller les coûts.

Avant de commencer

Avant de commencer la migration, vous devrez peut-être mettre à jour certaines configurations héritées dans votre espace de travail.

Vérifiez que votre espace de travail se trouve dans une région prise en charge.

Mettre à jour votre code

Les sections suivantes répertorient les modifications de code et de configuration requises pour rendre vos charges de travail compatibles avec serverless.

Accès aux données

Les modèles d’accès aux données hérités ne sont pas pris en charge sur serverless. Mettez à jour votre code pour utiliser le catalogue Unity à la place.

# 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 et code

Certaines API et modèles de code ne sont pas pris en charge sur serverless. Référencez ce tableau pour voir si votre code doit être mis à jour.

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

Bibliothèques et environnements

Vous pouvez gérer des bibliothèques et des environnements au niveau de l’espace de travail à l’aide d’environnements de base et au niveau du notebook à l’aide de l’environnement serverless du notebook.

Épinglez des packages Python dans requirements.txt pour les environnements reproductibles. Consultez Spécifier les versions des packages Python.

Diffusion en continu

Les charges de travail de streaming sont prises en charge sur les infrastructures sans serveur (serverless), mais certains déclencheurs ne le sont pas. Mettez à jour votre code pour utiliser les déclencheurs pris en charge.

Pour le streaming en continu, migrez vers les pipelines déclaratifs Spark en mode continu ou utilisez des tâches à horaire continu avec AvailableNow. Pour les sources volumineuses, définissez maxFilesPerTrigger ou maxBytesPerTrigger, pour empêcher les erreurs de mémoire insuffisante.

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

Tester vos charges de travail

1. Test de compatibilité rapide : exécutez la charge de travail sur le calcul classique avec le mode d’accès Standard et Databricks Runtime 14.3 ou version ultérieure. Si l’exécution réussit, la charge de travail peut migrer vers serverless sans aucune modification du code.
2. Comparaison A/B (recommandée pour la production) : exécutez la même charge de travail sur classique (contrôle) et serverless (expérience). Comparer les tableaux de résultats et vérifier l'exactitude. Itérer jusqu’à ce que les sorties correspondent.
3. Configurations temporaires : vous pouvez définir temporairement les configurations Spark prises en charge pendant le test. Supprimez-les lorsque les conditions sont stables.

Choisir un mode de performance

Les travaux et pipelines serverless prennent en charge deux modes de performance : standard et optimisé pour les performances. Le mode de performances que vous choisissez dépend des besoins de votre charge de travail.

Migrer en phases

1. Nouvelles charges de travail : démarrez tous les nouveaux blocs-notes et travaux sur serverless.
2. Charges de travail à faible risque : migrez des charges de travail PySpark/SQL déjà en mode d’accès standard et Databricks Runtime 14.3 ou version ultérieure.
3. Charges de travail complexes : migrez les charges de travail nécessitant des modifications de code (réécritures RDD, mises à jour DBFS, correctifs de déclencheur).
4. Charges de travail restantes : passez en revue régulièrement à mesure que les fonctionnalités s’étendent.

Superviser les coûts

La facturation serverless est basée sur la consommation DBU, et non sur le temps d’activité du cluster. Validez les attentes en matière de coûts avec les charges de travail représentatives avant de migrer à grande échelle. Pour connaître les outils et stratégies permettant de surveiller les coûts liés au serverless, voir Surveiller le coût du calcul serverless.

Ressources additionnelles

• Meilleures pratiques pour le calcul sans serveur : conseils d’optimisation pour les charges de travail sans serveur
• Limitations de calcul serverless : liste complète des limitations actuelles et fonctionnalités non prises en charge
• Configurer l’environnement serverless : Gérer les bibliothèques et les dépendances
• Configurations Spark prises en charge : configurations Spark disponibles sur serverless
• Spark Connect et Spark classique : différences comportementales dans l’architecture serverless
• Sécurité réseau sans serveur : contrôleurs de réseau, Private Link et configuration du pare-feu
• Notes de publication de l'informatique sans serveur : Suivre les nouvelles fonctionnalités au fur et à mesure de leur déploiement
• Guide de mise à niveau du catalogue Unity : Migrer du metastore Hive vers le catalogue Unity

Vous pouvez également consulter les billets de blog suivants pour plus d’informations :

• Qu’est-ce que l’informatique serverless ? : vue d’ensemble des fonctionnalités serverless et des résultats des clients
• Évolution de l’ingénierie des données : comment le calcul sans serveur transforme les notebooks et les travaux Lakeflow : comment le calcul sans serveur alimente les travaux et les pipelines Lakeflow