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

Migre suas cargas de trabalho da computação clássica para a computação sem servidor. A computação sem servidor lida com provisionamento, dimensionamento, atualizações de runtime e otimização automaticamente.

A maioria das cargas de trabalho clássicas pode migrar com alterações mínimas ou sem código. Esta página se concentra nessas cargas de trabalho. Alguns recursos, como df.cache, ainda não têm suporte no sem servidor, mas não exigirão alterações de código depois de disponíveis. Determinadas cargas de trabalho que dependem de notebooks R ou Scala exigem computação clássica e não poderão migrar para sem servidor. Para obter uma lista completa das limitações atuais, consulte limitações de computação sem servidor.

Etapas da migração

Para migrar suas cargas de trabalho da computação clássica para a computação sem servidor, siga estas etapas:

1. Verifique os pré-requisitos: verifique se o workspace, a rede e o acesso ao armazenamento em nuvem atendem aos requisitos. Consulte Antes de começar.
2. Código de atualização: faça as alterações necessárias no código e na configuração. Consulte Atualizar seu código.
3. Teste suas cargas de trabalho: valide a compatibilidade e a correção antes de cortar. Veja Teste suas cargas de trabalho.
4. Escolha um modo de desempenho: selecione o modo de desempenho que melhor corresponda aos requisitos de carga de trabalho. Consulte Escolher um modo de desempenho.
5. Migrar em fases: distribuir sem servidor incrementalmente, começando com cargas de trabalho novas e de baixo risco. Consulte Migrar em fases.
6. Monitorar custos: acompanhe o consumo de DBU sem servidor e configure alertas. Consulte os custos do Monitor.

Antes de começar

Antes de começar a migrar, talvez seja necessário atualizar algumas configurações herdadas em seu workspace.

Confirme se o workspace está em uma região com suporte.

Atualizar o código

As seções a seguir listam o código e as alterações de configuração necessárias para tornar suas cargas de trabalho compatíveis com sem servidor.

Acesso a dados

Não há suporte para padrões de acesso a dados herdados em computação sem servidor. Atualize seu código para usar o Catálogo do Unity.

# 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

Determinadas APIs e padrões de código não são suportados em ambientes serverless. Faça referência a esta tabela para ver se o código precisa 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

Você pode gerenciar bibliotecas e ambientes no nível do workspace usando ambientes base e no nível do notebook usando o ambiente sem servidor do notebook.

Fixe pacotes Python em requirements.txt para criar ambientes reproduzíveis. Consulte Especificar versões de pacotes do Python.

Transmissão ao vivo

Há suporte para cargas de trabalho de streaming sem servidor, mas não há suporte para determinados gatilhos. Atualize seu código para usar os gatilhos com suporte.

Para streaming contínuo, migre para Pipelines Declarativos do Spark em modo contínuo ou use tarefas agendadas continuamente com AvailableNow. Para fontes grandes, defina maxFilesPerTrigger ou maxBytesPerTrigger e evite erros fora 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))

Teste as suas cargas de trabalho

1. Teste de compatibilidade rápida: execute a carga de trabalho na computação clássica com o modo de acesso Standard e o Databricks Runtime 14.3 ou superior. Se a execução for bem-sucedida, a carga de trabalho poderá migrar para sem servidor sem nenhuma alteração de código.
2. Comparação A/B (recomendada para produção): execute a mesma carga de trabalho no clássico (controle) e sem servidor (experimento). Comparar tabelas de saída e verificar a exatidão. Iterar até que os resultados correspondam.
3. Configurações temporárias: você pode definir temporariamente configurações do Spark com suporte durante o teste. Remova-os quando estiverem estáveis.

Escolher um modo de desempenho

Os pipelines e trabalhos sem servidor dão suporte a dois modos de desempenho: padrão e otimizado para desempenho. O modo de desempenho escolhido depende dos requisitos de carga de trabalho.

Migrar em fases

1. Novas cargas de trabalho: inicie todos os novos notebooks e trabalhos sem servidor.
2. Cargas de trabalho de baixo risco: migrar cargas de trabalho PySpark/SQL já no modo de acesso padrão e Databricks Runtime 14.3 ou superior.
3. Cargas de trabalho complexas: Migrar cargas de trabalho que precisam de alterações de código (regravações de RDD, atualizações de DBFS, correções de gatilhos).
4. Cargas de trabalho restantes: examine periodicamente à medida que as funcionalidades se expandem.

Monitorar custos

A cobrança sem servidor é baseada no consumo de DBU, não no tempo de atividade do cluster. Valide as expectativas de custo com cargas de trabalho representativas antes de migrar em escala. Para ferramentas e estratégias para monitorar custos sem servidor, consulte Monitorar o custo da computação sem servidor.

Recursos adicionais

• Práticas recomendadas para computação sem servidor: dicas de otimização para cargas de trabalho sem servidor
• Limitações de computação sem servidor: lista completa de limitações atuais e recursos sem suporte
• Configurar o ambiente sem servidor: gerenciar bibliotecas e dependências
• Configurações do Spark com suporte: configurações do Spark disponíveis em ambientes serverless
• Spark Connect vs. Spark clássico: Diferenças comportamentais na arquitetura sem servidor
• Serverless network security: NCCs, Link Privado e configuração de firewall
• Notas de versão de computação sem servidor: acompanhar novos recursos à medida que eles são enviados
• Guia de atualização do Catálogo do Unity: Migrar do Metastore do Hive para o Catálogo do Unity

Você também pode consultar as seguintes postagens no blog para obter mais informações:

• O que é computação sem servidor?: Visão geral dos recursos sem servidor e dos resultados do cliente
• Evolução da engenharia de dados: como a computação sem servidor está transformando notebooks e tarefas do Lakeflow: Como a computação sem servidor impulsiona as tarefas e os pipelines do Lakeflow.