Migrar da computação clássica para a computação sem servidor

Migre as suas cargas de trabalho da computação clássica para a computação serverless. A computação serverless faz a gestão automaticamente do provisionamento, escalonamento, atualizações de runtime e otimização.

A maioria das cargas de trabalho clássicas pode migrar com alterações mínimas ou nenhumas no código. Esta página foca-se nessas cargas de trabalho. Algumas funcionalidades, como df.cache, ainda não são suportadas em serverless, mas não exigirão alterações de código assim que estiverem disponíveis. Certas cargas de trabalho que dependem de blocos de notas R ou Scala requerem recursos de computação clássicos e não poderão migrar para sem servidor. Para uma lista completa das limitações atuais, veja Limitações de computação sem servidor.

Etapas de migração

Para migrar as suas cargas de trabalho da computação clássica para a computação serverless, siga estes passos:

1. Verifique os pré-requisitos: Verifique se o seu espaço de trabalho, redes e acesso ao armazenamento na cloud cumprem os requisitos. Consulte Antes de começar.
2. Atualizar código: Faça quaisquer alterações necessárias no código e configuração. Veja Atualizar o seu código.
3. Teste as suas tarefas de processamento: Valide a compatibilidade e correção antes de fazer a transição. Veja Teste as suas cargas de trabalho.
4. Escolha um modo de desempenho: Selecione o modo de desempenho que melhor se adequa às suas necessidades de carga de trabalho. Veja Escolher um modo de desempenho.
5. Migre em fases: Implemente o serverless de forma incremental, começando com cargas de trabalho novas e de baixo risco. Ver Migrar em fases.
6. Monitorizar custos: Monitorizar o consumo de DBUs serverless e configurar alertas. Ver Monitorizar custos.

Antes de começar

Antes de começares a migrar, podes precisar de atualizar algumas configurações legadas no teu espaço de trabalho.

Confirma que o teu espaço de trabalho está numa região suportada.

Atualize o seu código

As secções seguintes listam o código e as alterações de configuração necessárias para tornar as suas cargas de trabalho compatíveis com serverless.

Acesso a dados

Os padrões de acesso a dados legados não são suportados em ambientes *serverless*. Atualize o seu código para usar o Unity Catalog em vez disso.

# 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 e código

Certas APIs e padrões de código não são suportados em serverless. Consulte esta tabela para ver se o seu código precisa de ser atualizado.

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

Bibliotecas e ambientes

Pode gerir bibliotecas e ambientes a nível de workspace usando ambientes base e a nível de notebook usando o ambiente serverless do notebook.

Fixar pacotes Python em requirements.txt para criar ambientes reproduzíveis. Veja Especificar versões de pacotes Python.

Serviço de streaming

Cargas de trabalho de streaming são suportadas em serverless, mas certos gatilhos não são suportados. Atualiza o teu código para usar os gatilhos suportados.

Para streaming contínuo, migre para os Pipelines Declarativos Spark em modo contínuo ou use tarefas de agendamento contínuo com AvailableNow. Para fontes grandes, defina maxFilesPerTrigger ou maxBytesPerTrigger para evitar erros de falta de memória.

# 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 as tuas cargas de trabalho

1. Teste rápido de compatibilidade: Execute a carga de trabalho em computação clássica com modo de acesso Standard e Databricks Runtime 14.3 ou superior. Se a execução for bem-sucedida, a carga de trabalho pode migrar para serverless sem quaisquer alterações de código.
2. Comparação A/B (recomendada para produção): Execute a mesma tarefa nos ambientes clássico (controlo) e sem servidor (experimento). Tabelas de saída do diff e verifique a correção. Iterar até que os resultados coincidam.
3. Configurações temporárias: Pode definir temporariamente as configurações suportadas do Spark durante os testes. Remova-os quando estiver estável.

Escolha um modo de performance

Os trabalhos e pipelines sem servidor suportam dois modos de desempenho: padrão e otimizado para performance. O modo de desempenho que escolhes depende das tuas necessidades de carga de trabalho.

Migrar em fases

1. Novas cargas de trabalho: Inicia todos os novos cadernos e trabalhos em serverless.
2. Cargas de trabalho de baixo risco: migrar cargas de trabalho PySpark/SQL já em modo de acesso padrão e Databricks Runtime 14.3 ou superior.
3. Cargas de trabalho complexas: Migrar cargas de trabalho que necessitam de alterações de código (reescritas RDD, atualizações de DBFS, correções de triggers).
4. Cargas de trabalho restantes: Revise periodicamente à medida que as capacidades se expandem.

Monitorizar os custos

A faturação serverless baseia-se no consumo da DBU, não no tempo de funcionamento do cluster. Valide expectativas de custos com cargas de trabalho representativas antes de migrar em escala. Para monitorizar os custos serverless com ferramentas e estratégias, consulte Monitorizar o custo da computação serverless.

Recursos adicionais

• Boas práticas para computação sem servidor: dicas de otimização para workloads sem servidor
• Limitações de computação serverless: Lista completa de limitações atuais e funcionalidades não suportadas
• Configurar o ambiente serverless: Gerir bibliotecas e dependências
• Configurações Spark suportadas: Configurações Spark disponíveis em serverless
• Spark Connect vs. Spark clássico: Diferenças comportamentais na arquitetura serverless
• Segurança de rede serverless: NCCs, Private Link e configuração de firewalls
• Notas de lançamento de computação serverless: Acompanhe as novas capacidades conforme são lançadas
• Guia de atualização do Unity Catalog: Migrar da Hive Metastore para o Unity Catalog

Pode também consultar os seguintes artigos do blogue para mais informações:

• O que é computação serverless?: Visão geral das capacidades serverless e resultados dos clientes
• Evolução da engenharia de dados: Como a computação serverless está a transformar os notebooks e as tarefas Lakeflow: Como a computação serverless impulsiona as tarefas e os pipelines Lakeflow