Databricks com PySpark: Engenharia de Dados em Larga Escala

Databricks é hoje uma das plataformas mais citadas em vagas brasileiras de dados. Ao analisar o radar de vagas Python do site em junho de 2026, Databricks aparece com frequência ao lado de PySpark, Spark, Snowflake, Airflow e dbt, em posições de engenheiro de dados, analytics engineer, platform engineer e cientista de dados. Para quem já programa em Python, entender Databricks e PySpark abre um conjunto grande de oportunidades sem trocar de linguagem.

Este guia mostra como pensar Databricks de forma prática, sem precisar de um cluster gigante para começar. A ideia é conectar a plataforma com temas que já importam para o seu portfólio: ETL com Python, dbt para analytics engineering, Airflow para orquestração de pipelines, DuckDB para analytics, Docker em projetos Python e vagas Python no Brasil.

Por que Databricks aparece tanto em vagas

Databricks nasceu da união dos criadores do Apache Spark com uma camada gerenciada de infraestrutura. Em vez de você montar um cluster Spark na mão, instalar dependências, configurar storage e lidar com atualizações, a plataforma entrega isso pronto, com interface de notebooks, job scheduler, controle de permissões, Unity Catalog para governança e integração com cloud (AWS, Azure, GCP).

As empresas brasileiras adotam Databricks quando o volume de dados passa do que cabe confortavelmente em um notebook Pandas ou em um banco relacional tradicional. Os cenários mais comuns são:

• consolidar dados de várias fontes em um lakehouse central;
• rodar transformações pesadas em Parquet com Spark distribuído;
• treinar e servir modelos de machine learning com MLflow;
• compartilhar tabelas governadas entre times de dados,analytics e negócio;
• atender exigências de auditoria com lineage e controle de acesso por coluna.

A combinação Python + Databricks é forte porque PySpark é a API mais madura da plataforma. Quem já sabe Pandas e SQL sente uma curva de aprendizado suave.

Community Edition: como começar sem pagar

Databricks oferece uma Community Edition gratuita, suficiente para aprender os conceitos. Para usá-la:

1. Crie uma conta em databricks.com/learn/community-edition.
2. Escolha a versão Community, que sobe um cluster pequeno por hora.
3. Abra um notebook e selecione o runtime mais recente com PySpark.

Para testes locais sem depender da nuvem, vale rodar PySpark puro com pip install pyspark dentro de um virtual environment. A API é a mesma; apenas algumas funcionalidades específicas do Databricks (como Unity Catalog e Delta Lake gerenciado) ficam limitadas.

PySpark: o motor por trás

Antes de entrar no Databricks, vale entender o que o PySpark resolve. Pandas é excelente até a memória da máquina. Quando o arquivo de pedidos passa de dezenas de gigabytes, ou quando você precisa processar meses de logs em paralelo, um DataFrame do Spark distribui o trabalho entre vários nós do cluster.

Um exemplo simples, que roda igual no seu notebook local e em um cluster Databricks:

from pyspark.sql import SparkSession
from pyspark.sql import functions as F

spark = SparkSession.builder.appName("vendas_diarias").getOrCreate()

df = (
    spark.read.option("header", True)
    .option("inferSchema", True)
    .csv("s3://meu-lake/pedidos/")
)

resumo = (
    df.filter(F.col("status") == "pago")
    .groupBy("canal", "regiao")
    .agg(
        F.count("*").alias("pedidos"),
        F.sum("valor_total").alias("receita"),
        F.avg("valor_total").alias("ticket_medio"),
    )
    .orderBy(F.desc("receita"))
)

resumo.show(20, truncate=False)

O ponto-chave é que Spark usa lazy evaluation: as transformações (filter, groupBy, agg) apenas montam um plano lógico, e a computação só acontece quando uma ação (show, write, collect) é chamada. Isso permite que o otimizador Catalyst reorganize as etapas para reduzir shuffle e leitura de dados.

Delta Lake: o coração do lakehouse

A grande virada do Databricks em relação ao Spark puro é o Delta Lake, um formato de armazenamento que adiciona transações ACID, schema enforcement, time travel e upserts/merges em cima do Parquet. Na prática, você deixa de ter uma pasta solta de arquivos e passa a tratar o lake como um conjunto de tabelas versionadas.

Um padrão recorrente em pipelines brasileiros é o upsert (merge) diário: chegarão pedidos novos e atualizações de pedidos antigos. Com Parquet puro, isso exige reescrever a partição inteira. Com Delta, você faz um merge declarativo:

from delta.tables import DeltaTable

alvo = DeltaTable.forPath(spark, "s3://meu-lake/delta/pedidos")

novos = spark.read.parquet("s3://meu-lake/staging/pedidos_hoje/")

(
    alvo.alias("t")
    .merge(novos.alias("s"), "t.pedido_id = s.pedido_id")
    .whenMatchedUpdateAll()
    .whenNotMatchedInsertAll()
    .execute()
)

Esse padrão aparece em pipelines de clientes, faturas, eventos de app e leads de CRM. Combinado com um job agendado, ele sustenta cargas diárias idempotentes.

Estrutura de projeto recomendada

Mesmo em Databricks, vale manter a lógica fora dos notebooks, em módulos Python testáveis. Uma estrutura pequena e profissional:

lakehouse-pedidos/
  notebooks/
    ingest_pedidos.py
    transform_pedidos.py
  src/lakehouse/
    __init__.py
    extract.py
    transform.py
    schema.py
    merge.py
  tests/
    test_transform.py
    test_merge.py
  setup.py

O notebook fica fino: importa a função de src/lakehouse, lê parâmetros do job e dispara a execução. Assim você consegue rodar testes com pytest localmente e promover o mesmo código para o cluster via Databricks Repos ou Asset Bundles.

Projeto de portfólio: indicador diário de vendas

Um projeto que vale destacar no portfólio Python é um indicador diário de vendas construído sobre um lakehouse. O fluxo:

1. Extração: um job Databricks lê CSVs de pedidos de um bucket S3 compatível (veja como fazer upload seguro com boto3).
2. Bronze: grava os dados crus em Delta, com schema enforcement e timestamp de ingestão.
3. Silver: limpa tipos, normaliza nomes de coluna, remove duplicados por pedido_id com merge.
4. Gold: agrega por canal, região e dia, gerando uma tabela pronta para dashboard em Streamlit ou Power BI.
5. Qualidade: asserts simples com contagem mínima de pedidos e faixa plausível de receita, integrados ao dbt ou a um notebook de validação.

Esse padrão Bronze/Silver/Gold é exatamente o que times de dados usam em produção, e demonstra maturidade em entrevistas para vagas de engenheiro de dados.

Otimização: os erros que custam caro

Spark é poderoso, mas permite escrever código que roda 10 vezes mais devagar do que poderia. Os erros mais comuns em pipelines brasileiros:

• muitos small files: ler milhares de CSVs pequenos gera overhead. Prefira Parquet particionado por dia.
• collect() em DataFrame grande: joga tudo para o driver e derruba a memória. Use toPandas() apenas após agregar.
• shuffles evitáveis: groupByKey em RDD ou joins sem broadcast em tabelas pequenas. Use broadcast(tabela_pequena).
• particionamento errado: particionar por coluna de alta cardinalidade (como pedido_id) cria milhões de pastas. Particione por dia ou região.
• UDFs em Python quando existe função nativa: UDFs quebram o Catalyst. Sempre que possível, use as funções de pyspark.sql.functions.

Um checkpoint importante é o EXPLAIN do plano de execução, que mostra onde o shuffle e o scan acontecem. Ler esse plano é uma habilidade que diferencia candidatos em entrevistas.

Custos e governança na nuvem

Databricks cobra por DBU (Databricks Unit) e roda sobre o custo da cloud. Para projetos de portfólio, use sempre clusters Community ou single-node pequenos, encerre clusters ao fim do dia e prefira jobs agendados a clusters “all-purpose” sempre ligados. Em produção, Unity Catalog centraliza permissões, tags de governança e lineage, o que costuma aparecer como requisito em vagas sênior e de platform data.

Carreira: como posicionar Databricks no currículo

Se você está de transição de carreira para Python ou mirando o primeiro emprego, vale destacar Databricks e PySpark no currículo quando já tiver um projeto rodando, mesmo que pequeno. As combinações mais demandadas no Brasil, segundo o radar de vagas do site, são:

• PySpark + Delta Lake para engenharia de dados.
• PySpark + Databricks SQL + Power BI para analytics engineering.
• Databricks + MLflow para machine learning em escala.

O caminho natural do iniciante é: aprender Python, dominar Pandas, entender SQL, fazer um projeto de portfólio com ETL, e só então subir para Spark e Databricks. Pular etapas leva a bugs difíceis de debugar em produção.

Conclusão

Databricks com PySpark é uma das stacks mais sólidas para quem quer crescer em engenharia de dados no Brasil. A boa notícia é que os conceitos fundamentais — DataFrames, lazy evaluation, partições, merges em Delta — podem ser aprendidos localmente com PySpark puro e aplicados ao cluster sem mudar o código. Comece com um projeto Bronze/Silver/Gold sobre dados públicos brasileiros, publique no seu portfólio e conecte com as outras ferramentas que já dominar: Airflow, dbt, DuckDB e Dashboards. Isso transforma a plataforma de uma palavra-chave de vaga em uma habilidade demonstrável.