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. Por exemplo, cargas de trabalho que usamdf.cache() e df.persist() migram principalmente sem alterações no código. Esta página se concentra nessas cargas de trabalho. Certas cargas de trabalho que dependem de notebooks R ou Scala exigem computação clássica e não podem migrar para serverless. Para obter uma lista completa das limitações atuais, consulte limitações de computação sem servidor.

Migre com o agente de migração

Importante

Esse recurso está em Beta. Administradores do espaço de trabalho podem habilitá-lo na página Pré-visualizações ao aderir à versão prévia do Compute Agent. Consulte Gerenciar visualizações do Azure Databricks.

Você pode usar um agente de migração para migrar um único notebook ou tarefa para computação sem servidor. O agente revisa o ambiente da carga de trabalho, bibliotecas, configurações do Spark, tags e código, e então propõe cada alteração como uma sugestão individual para você aceitar ou rejeitar. As mudanças aceitas são aplicadas no local e podem ser revertidas.

O que o agente revisa e muda

Area O que o agente faz
Ambiente e bibliotecas Traduz instalações de bibliotecas em uma especificação de ambiente serverless, incluindo instalações com %pip, scripts de inicialização do cluster, bibliotecas de cluster em trabalhos e referências a um índice de pacotes privado.
Variáveis de ambiente Traduz variáveis do ambiente do cluster para seus equivalentes serverless, preservando referências secretas de workspace e omitindo valores gerenciados pela plataforma.
Acesso a dados e armazenamento Reescreve caminhos incompatíveis com serverless, como disco local, dbfs:/, e caminhos de montagem, para volumes do Catálogo Unity. O agente aplica reescritas inequívocas automaticamente e pede que você escolha um volume quando o destino for ambíguo.
Configurações do Spark Classifica cada configuração do Spark, comenta configurações que são seguras para descartar e sinaliza e remove configurações que serverless não suporta. Abrange tanto configurações conectadas ao cluster quanto configurações no notebook.
Código da carga de trabalho Reescreve código que o serverless não suporta em equivalentes compatíveis, como operações RDD reescritas para operações DataFrame, e ajusta o código para o comportamento do SQL em modo ANSI em serverless.
Tags Traduz tags personalizadas do cluster, como uma tag de centro de custo, para seus equivalentes serverless.
Modo Performance Sugere um modo de desempenho baseado na configuração do cluster. Consulte Escolher um modo de desempenho.

Requirements

  • O acesso de administrador do espaço de trabalho é recomendado para garantir uma migração completa. Isso porque o agente também inspeciona scripts globais de inicialização no nível do espaço de trabalho, além da carga de trabalho de destino. Talvez seja possível migrar se você tiver CAN MANAGE permissão na carga de trabalho, mas, sem permissões de administrador, isso pode resultar na ausência de bibliotecas, configurações de ambiente ou tags.

  • Confirme que você tem acesso ao agente. Digite /compute o Código Gênio. /compute Deveria aparecer no menu de autocompletamento. Se não aparecer, um administrador do espaço de trabalho deve ativar a pré-visualização no seu espaço de trabalho.

    O painel do Genie Code com /compute digitado, mostrando o comando /compute no menu de preenchimento automático com a descrição Migrar trabalhos para computação sem servidor

Migre um notebook

  1. Abra o caderno que você quer migrar.
  2. Abra o Código Genie e execute /compute migrate to serverless a partir da / paleta de comandos.
  3. Revise as conclusões do agente. O agente escaneia o ambiente, bibliotecas e código do notebook, e propõe uma alteração para cada item que precise, como mover uma instalação de biblioteca para uma especificação de ambiente ou reescrever uma célula de código para rodar em serverless.
  4. Aceite ou rejeite cada mudança proposta.
  5. Aplique as mudanças que você aceitou. Elas são gravadas no notebook no mesmo local.
  6. Conecte o notebook ao serverless e rode para confirmar se ele se comporta como você espera. Veja Verificando uma carga de trabalho migrada.

Migrar um trabalho

  1. Abra o trabalho que deseja migrar.
  2. Abra o Código Genie e execute /compute migrate to serverless a partir da / paleta de comandos.
  3. O agente clona seu trabalho e tenta migrar o trabalho clonado para serverless.
  4. Revise as conclusões do agente. Para um trabalho multitarefa, o agente enumera todas as tarefas e sua configuração de cluster por tarefa, e propõe mudanças para cada uma enquanto preserva o cronograma do trabalho.
  5. Aceite ou rejeite cada alteração proposta na superfície de migração: ambiente e bibliotecas, configurações do Spark e qualquer código de carga de trabalho que precise mudar.
  6. Aplique as mudanças que você aceitou. O poder computacional do trabalho é alterado para serverless.
  7. Execute o trabalho no serverless e confirme os resultados. Veja Verificando uma carga de trabalho migrada.
  8. Opcionalmente, como etapa final, o agente promove o clone migrado. Ele copia a configuração e os notebooks do clone de volta para o seu trabalho original no lugar (mantendo o mesmo ID do trabalho, cronograma e permissões), e depois deleta o clone. Se você pular a promoção e mantiver os dois trabalhos, pause o agendamento do trabalho que não estiver em execução; caso contrário, o mesmo gatilho acionará os dois e poderá duplicar gravações ou outros efeitos colaterais.

Verifique uma carga de trabalho migrada

O agente propõe e aplica alterações, mas não executa sua carga de trabalho nem verifica sua saída. Sempre execute uma carga de trabalho migrada em serverless e confirme os resultados antes de confiar nela, especialmente para cargas que gravam em tabelas de produção. Se o agente propor uma mudança que pareça errada, rejeite-a e nos envie feedback para que possamos melhorar o agente. Consulte Enviar comentários sobre o produto.

Dica

Enquanto você valida uma carga de trabalho migrada, execute-a em modo otimizado para desempenho. Ele começa mais rápido que o modo padrão, então você recebe um feedback mais rápido ao confirmar os resultados. Mude para o modo que melhor se encaixa na carga de trabalho antes de rodar em produção. Consulte Escolher um modo de desempenho.

Quando o agente encontra algo que não pode migrar com segurança, ele sinaliza um bloqueio e interrompe o processo por padrão. Você pode instruí-lo explicitamente a ignorar alguns bloqueios de compatibilidade ou dependência, mas, ao fazer isso, você aceita o risco de que essas dependências, a atribuição de custos ou o comportamento em tempo de execução não sejam preservados, e a carga de trabalho possa falhar no ambiente serverless.

Reverter alterações da migração

As mudanças que o agente aplica são reversíveis.

Para um notebook, abra-o e restaure a revisão imediatamente anterior à migração. Consulte o histórico de versões nos notebooks do Databricks.

No caso de um trabalho, se você não promoveu o clone migrado, seu trabalho original nunca foi alterado: execute-o como antes e exclua o clone. Se você promoveu o clone, restaure usando o backup que o agente criou antes de fazer qualquer alteração:

  1. Abra a pasta de backup no seu espaço de trabalho inicial: /Workspace/Users/<your-username>/serverless-migration/backups/job-<job-id>/<timestamp>/. O agente mostrou esse caminho durante a migração. Se houver várias marcas de tempo, escolha a que está imediatamente antes da migração.
  2. Abra job.yaml, que contém as configurações da tarefa anteriores à migração, e aplique essas configurações novamente à mesma tarefa por meio de uma solicitação POST /api/2.2/jobs/reset, que sobrescreve as configurações da tarefa pelas que você fornecer. Você também pode colá-los na definição JSON do trabalho na interface. Isso retorna o trabalho para a computação clássica.
  3. Abra mapping.yaml, que lista cada arquivo com backup e o caminho original de onde veio. Copie cada arquivo de backup de volta para seu caminho original para desfazer as reescritas no código.
  4. Execute a tarefa para confirmar se ela se comporta da mesma forma que antes da migração.

A migração nunca apaga esse backup. Tarefas que o agente não modificou, como tarefas provenientes do Git, SQL ou dbt, são registradas em job.yaml, mas seus arquivos não são copiados para o backup; portanto, restaure-os da sua fonte confiável, se necessário.

Limitações conhecidas

  • Os seguintes são considerados bloqueadores: imagens personalizadas, variantes do ML Runtime, versões do Databricks Runtime anteriores à 13, configurações do Spark que não podem ser ignoradas com segurança no ambiente serverless e dependências como eggs, JARs e bibliotecas Maven. Um bloqueador significa que o agente para em vez de migrar aquele item. Você pode resolver você mesmo e rodar a migração novamente, ou pedir para o agente migrar mesmo assim, o que deixa esse item sem solução e pode causar falha na carga de trabalho no serverless.
  • O agente lê scripts de init armazenados em arquivos de workspace ou volumes do Unity Catalog. Scripts de init armazenados em ABFSS ou DBFS não podem ser lidos e são reportados como bloqueadores.
  • O agente não inspeciona todos os atributos clássicos de computação. A entrega de logs do cluster e as chaves SSH não são representadas e, embora detecte muitas dependências relacionadas a montagens do DBFS no código da carga de trabalho, ele não enumera nem resolve todas as montagens.
  • APIs de cache e checkpoint, visualizações temporárias globais, chamadas de gerenciamento de montagens do DBFS e código em Scala ou R são impedimentos absolutos por padrão. Você pode instruir o agente a prosseguir, mas a funcionalidade não resolvida permanece inalterada e pode falhar no serverless.
  • Empregos com mais de 10 tarefas migráveis atualmente não podem ser migrados.
  • O agente migra uma carga de trabalho por vez. Não há descoberta em toda a frota, migração em massa nem fluxo de aprovação do administrador.
  • O agente propõe alterações e aplica as que você aceitar, mas não executa sua carga de trabalho nem verifica a correção dos resultados. Verifique uma carga de trabalho migrada antes de depender dela para dados de produção.
  • Se a fonte de verdade da sua carga de trabalho for um Databricks Asset Bundle ou uma pasta Git, o agente aplica alterações ao objeto de workspace já existente. Reconcilie essas mudanças com seu bundle ou repositório para que uma implantação posterior não sobrescrita a migração.

Migre manualmente para sem servidor

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 Pré-requisitos.
  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.

Prerequisites

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

Pré-requisito Ação Detalhes
O workspace está habilitado para o Unity Catalog Migrar do Metastore do Hive, se necessário Faça upgrade do workspace do Azure Databricks para o Unity Catalog
Rede configurada Substituir o emparelhamento VPC por NCCs, Link Privado ou regras de firewall Rede de camada de computação sem servidor
Acesso ao armazenamento em nuvem Substitua os padrões de acesso a dados herdados por localizações externas do Unity Catalog. Conectar-se ao armazenamento de objetos de nuvem usando o Unity Catalog

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.

Padrão clássico Substituição sem servidor Detalhes
Caminhos DBFS (dbfs:/...) Volumes do Catálogo do Unity O que são os volumes do Catálogo do Unity?
Tabelas do Metastore do Hive Tabelas Unity Catalog (ou Federação HMS) Faça upgrade do workspace do Azure Databricks para o Unity Catalog
Credenciais da conta de armazenamento Locais externos do Unity Catalog Conectar-se ao armazenamento de objetos de nuvem usando o Unity Catalog
JDBC JARs personalizados Federação do Lakehouse O que é federação de consulta?

Aviso

O acesso ao DBFS é limitado no modo sem servidor. Atualize todos os caminhos dbfs:/ para volumes do Catálogo do Unity antes de migrar. Para obter mais informações, consulte Migrar arquivos armazenados no DBFS.

Exemplo: substituir caminhos DBFS e referências do 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 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.

Padrão clássico Substituição sem servidor Detalhes
APIs RDD (sc.parallelize, rdd.map) DataFrame APIs Comparar o Spark Connect com o Spark Classic
spark.sparkContext, sqlContext Usar spark (SparkSession) diretamente Comparar o Spark Connect com o Spark Classic
Variáveis do Hive (${var}) SQL DECLARE VARIABLE ou f-strings do Python DECLARE VARIABLE
Configurações do Spark sem suporte Remova configurações sem suporte. A maioria das configurações é ajustada automaticamente sem servidor. Configurar propriedades do Spark para notebooks e trabalhos sem servidor
Exemplo: substituir operações RDD por 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")
Exemplo: Substituir APIs do SparkContext 
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")

Diferenças de comportamento em SQL

Computação serverless ativa o modo ANSI por padrão. O Databricks Runtime ativa o modo ANSI por padrão na versão 17.0 e superior. Se seu classic compute roda uma versão anterior, algumas consultas que têm sucesso ali geram erros de runtime no serverless.

O agente de migração ajusta automaticamente o código para o comportamento do modo ANSI. Se você migrar manualmente, revise as seguintes operações, que geralmente mudam o comportamento:

Operação Computação clássica com modo ANSI desativado Computação sem servidor
Conversão inválida, como CAST('abc' AS INT) Retorna NULL Gera CAST_INVALID_INPUT
Estouro aritmético de inteiros Contorna. Por exemplo, 2147483647 + 1 retorna -2147483648. Gera ARITHMETIC_OVERFLOW
Transbordamento aritmético decimal Retorna NULL Gera NUMERIC_VALUE_OUT_OF_RANGE
Divisão por zero Retorna NULL Gera DIVIDE_BY_ZERO
URL malformada em parse_url Retorna NULL Gera INVALID_URL

Para retornar NULL em vez de gerar uma exceção, substitua a operação pela operação try_* equivalente, como try_cast, try_add, try_divide ou try_parse_url. O Databricks recomenda esta abordagem em vez de desativar o modo ANSI, porque o modo ANSI expõe problemas de qualidade de dados que um NULL silencioso oculta.

Para optar por sair do modo ANSI para casts, aritmética e análise sintática, defina spark.sql.ansi.enabled para false. A computação serverless aplica regras ANSI a casts implícitos em inserts de tabela independentemente dessa configuração, pois spark.sql.storeAssignmentPolicy não pode ser alterado em computação serverless. Para uma descrição completa do comportamento ANSI, veja conformidade ANSI em Databricks Runtime.

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.

Padrão clássico Substituição sem servidor Detalhes
Scripts de inicialização Ambientes sem servidor Configurar o ambiente sem servidor
Bibliotecas com escopo de cluster Bibliotecas de ambiente ou com escopo de bloco de anotações Configurar o ambiente sem servidor
Bibliotecas Maven/JAR Suporte para tarefas JAR em trabalhos; PyPI para notebooks Tarefa JAR para trabalhos
Contêineres do Docker Ambientes sem servidor para necessidades de biblioteca Configurar o ambiente sem servidor

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.

Acionador do Spark Supported Observações
Trigger.AvailableNow() Sim Recomendado
Trigger.Once() Sim Isto está obsoleto. Use Trigger.AvailableNow() em seu lugar.
Trigger.ProcessingTime(interval) No Retorna INFINITE_STREAMING_TRIGGER_NOT_SUPPORTED
Trigger.Continuous(interval) No Em vez disso, use o modo contínuo dos pipelines do Lakeflow
Padrão (sem definir .trigger()) No Omitindo .trigger() define por padrão o ProcessingTime("0 seconds"), que não é suportado em ambientes sem servidor. Sempre defina .trigger(availableNow=True) explicitamente.

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.

Exemplo: corrigir gatilhos 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))

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.

Modo Disponibilidade Inicialização Mais adequado para
Standard Trabalhos, pipelines do Lakeflow 4 a 6 minutos Lote sensível ao custo
Otimizado para desempenho Notebooks, trabalhos, pipelines do Lakeflow Segundos Interativo, sensível à latência

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

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

  • Última atualização em