Migrer du compute classique au compute serverless
Migrez vos charges de travail du compute classique au compute serverless. Le compute serverless gère automatiquement le provisionnement, la mise à l'échelle, les mises à niveau d'exécution et l'optimisation.
La plupart des charges de travail classiques peuvent migrer avec des modifications de code minimes, voire aucune. Cette page se concentre sur ces charges de travail. Certaines fonctionnalités, telles que df.cache, ne sont pas encore prises en charge en mode Serverless, mais ne nécessiteront pas de modifications de code une fois disponibles. Certaines charges de travail qui dépendent des Notebooks R ou Scala nécessitent un compute classique et ne pourront pas migrer vers le serverless. Pour une liste complète des limitations actuelles, voir Limitations du compute Serverless.
Étapes de migration
Pour migrer vos charges de travail du compute classique vers le compute Serverless, suivez ces étapes :
- Vérifier les prérequis : Vérifiez que votre workspace, votre réseau et l'accès au stockage cloud répondent aux exigences. Voir Avant de commencer.
- Mettre à jour le code : apportez toutes les modifications nécessaires au code et à la configuration. Consultez Mettre à jour votre code.
- **Testez vos charges de travail** : Validez la compatibilité et l'exactitude avant le basculement. Voir Testez vos charges de travail.
- Choisissez un mode de performance : Sélectionnez le mode de performance qui correspond le mieux à vos exigences de charge de travail. Voir Choisir un mode de performance.
- Migration par phases : Déployez Serverless progressivement, en commençant par les workloads nouveaux et à faible risque. Voir Migrer par phases.
- Surveiller les coûts : suivre la consommation de DBU serverless et configurer des alertes. Voir Surveiller les coûts.
Avant de commencer
Avant de commencer la migration, vous pourriez avoir besoin de mettre à jour certaines configurations héritées dans votre Workspace.
Prérequis | Action | Détails |
|---|---|---|
Workspace est activé pour Unity Catalog | Migrer depuis Hive metastore si nécessaire | |
Réseau configuré | Remplacez le peering Virtual Private Cloud (VPC) par les NCC, Private Link ou les règles de pare-feu. | |
Accès au stockage cloud | Remplacez les modèles d'accès aux données hérités par les emplacements externes Unity Catalog. | Connectez-vous au stockage d'objets cloud à l'aide de Unity Catalog |
Remplacez les montages DBFS qui utilisent des profils d'instance par des emplacements externes Unity Catalog.
Mettez à jour votre code
Les sections suivantes énumèrent les modifications de code et de configuration requises pour rendre vos charges de travail compatibles avec le 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 Unity Catalog à la place.
Modèle classique | Remplacement Serverless | Détails |
|---|---|---|
Chemins DBFS ( | Volumes du Unity Catalog | |
Tables du Hive Metastore | Tables Unity Catalog (ou fédération HMS) | |
Profils d'instance IAM | Emplacements externes Unity Catalog | Connectez-vous au stockage d'objets cloud à l'aide de Unity Catalog |
JAR JDBC personnalisés | Lakehouse Federation |
L'accès DBFS est limité sur serverless. Mettre à jour tous les dbfs:/ chemins vers des volumes Unity Catalog avant la migration. Pour plus d'informations, consultez Migrer les fichiers stockés dans DBFS.
Exemple : Remplacez les chemins DBFS et les références au Hive metastore
# 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 et code
Certaines APIs et certains modèles de code ne sont pas pris en charge sur Serverless. Référez-vous à cette table pour voir si votre code doit être mis à jour.
Modèle classique | Remplacement Serverless | Détails |
|---|---|---|
RDD APIs ( | DataFrame APIs | |
| Supprimer les appels de mise en cache | |
| Utilisez | |
Variables Hive ( | SQL | |
Configurations Spark non prises en charge | Supprimez les configurations non prises en charge. Serverless configure automatiquement la plupart des paramètres. | Configurez les propriétés Spark pour les Notebooks et les Jobs serverless. |
Exemple : remplacer les opérations RDD par des 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")
Exemple : remplacer SparkContext et la mise en cache
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 les bibliothèques et les environnements au niveau du Workspace à l'aide des environnements de base et au niveau du Notebook à l'aide de l'environnement Serverless du Notebook.
Modèle classique | Remplacement Serverless | Détails |
|---|---|---|
Scripts d'initialisation | Environnements Serverless | |
Bibliothèques limitées aux clusters | Bibliothèques à portée du Notebook ou d'environnement | |
Bibliothèques Maven/JAR | Prise en charge des tâches JAR pour les Job ; PyPI pour les Notebook | |
Conteneurs Docker | Environnements serverless pour les besoins des bibliothèques |
Pin Python packages in requirements.txt pour des environnements reproductibles. Voir Spécifier les versions de package Python.
streaming
Les workloads de streaming sont pris en charge sur Serverless, mais certains triggers ne le sont pas. Mettez à jour votre code pour utiliser les Trigger pris en charge.
Trigger Spark | Pris en charge | Notes |
|---|---|---|
| Oui | Recommandations |
| Oui | Ceci est obsolète. Utilisez |
| Non | Renvoie |
| Non | Utilisez plutôt le mode continu des Lakeflow pipelines. |
default (sans définir | Non | L’omission de |
Pour le streaming continu, migrez vers les Spark Declarative Pipelines en mode continu ou utilisez des jobs à planification continue avec AvailableNow. Pour les sources volumineuses, définissez maxFilesPerTrigger ou maxBytesPerTrigger pour éviter les erreurs de mémoire insuffisante.
Exemple : correction des triggers de streaming
# 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))
Testez vos charges de travail
- Test de compatibilité rapide : Exécutez la charge de travail sur le compute classique avec le mode d'accès Standard et Databricks Runtime 14.3 ou versions ultérieures. Si l'exécution réussit, la charge de travail peut migrer vers Serverless sans aucune modification de code.
- Comparaison A/B (recommandé pour la production) : Exécutez la même charge de travail sur un cluster classique (contrôle) et serverless (expérimentation). Comparer les tables de sortie et vérifier l'exactitude. Itérer jusqu'à ce que les sorties correspondent.
- Configurations temporaires : Vous pouvez temporairement définir des configurations Spark prises en charge pendant les tests. Supprimez-les une fois stables.
Choisir un mode de performance
Les jobs et pipelines Serverless prennent en charge deux modes de performance : standard et optimisé pour les performances. Le mode de performance que vous choisissez dépend de vos exigences en matière de charge de travail.
Mode | Disponibilité | Startup | Idéal pour |
|---|---|---|---|
Standard | Tâches, LakeFlow Pipelines | de 4 à 6 minutes | Batch sensible aux coûts |
Optimisé pour la performance | Notebooks, Jobs, LakeFlow Pipelines | secondes | Interactif, sensible à la latence |
Migrez par phases
- Nouvelles charges de travail : Start tous les nouveaux notebooks et Jobs sur Serverless.
- Charges de travail à faible risque : Migrez les charges de travail PySpark/SQL déjà en mode d'accès standard et sous Databricks Runtime 14,3 ou version supérieure.
- Charges de travail complexes : migrez les charges de travail nécessitant des modifications de code (réécritures RDD, mises à jour DBFS, corrections de Trigger).
- Charges de travail restantes : examinez-les périodiquement à mesure que les capacités s'étendent.
Surveillance des coûts
La facturation Serverless est basée sur la consommation de DBU, et non sur le temps d'activité des clusters. Validez les prévisions de coûts avec des charges de travail représentatives avant de migrer à grande échelle. Pour les outils et stratégies de surveillance des coûts Serverless, voir Surveiller le coût du compute Serverless.
Ressources supplémentaires
- Bonnes pratiques pour le compute Serverless: conseils d'optimisation pour les workloads Serverless
- Limitations du compute Serverless: Liste complète des limitations actuelles et des 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 vs. Spark classique: différences de comportement dans l'architecture serverless
- Sécurité réseau Serverless: NCC, Private Link et configuration du pare-feu
- Notes de publication du calcul Serverless: suivez les nouvelles fonctionnalités au fur et à mesure de leur déploiement.
- Guide de mise à niveau vers Unity Catalog: Migrez de Hive Metastore vers Unity Catalog
Vous pouvez également vous référer aux billets de blog suivants pour plus d'informations :
- Qu'est-ce que le calcul Serverless ?: Aperçu des capacités Serverless et des résultats clients
- Évolution de l'ingénierie des données : comment le compute serverless transforme les notebooks et les Lakeflow Jobs: comment le serverless alimente les Lakeflow Jobs et les pipelines