Apache Spark 4.2 vs Databricks em 2026: Arquitetura, Performance e Perguntas de Entrevista

Apache Spark 4.2 e Databricks representam dois caminhos para o processamento distribuído de dados em 2026. Spark oferece máxima flexibilidade como framework open source, enquanto Databricks encapsula Spark em uma plataforma lakehouse totalmente gerenciada com melhorias proprietárias. Compreender as diferenças entre essas opções é essencial para entrevistas de data engineering e decisões arquiteturais.

Apache Spark 4.2: Novas Funcionalidades e Arquitetura

Apache Spark 4.2, lançado em 14 de julho de 2026, introduz várias funcionalidades que transformam o funcionamento dos pipelines de dados. As adições mais significativas focam em captura de dados de mudança, integração com IA e workloads de streaming.

Auto CDC e a Cláusula CHANGES

Spark 4.2 torna a captura de dados de mudança (CDC) nativa ao motor. Anteriormente, o rastreamento de mudanças nos dados exigia soluções customizadas envolvendo timestamps, comparações de hash ou ferramentas CDC externas. A nova funcionalidade Auto CDC lida com isso automaticamente.

-- changes-query.sql
-- Consultar mudanças em uma tabela Delta desde a versão 10
SELECT * FROM orders CHANGES SINCE VERSION 10;

-- Rastrear mudanças dentro de uma janela temporal
SELECT * FROM customers 
CHANGES BETWEEN TIMESTAMP '2026-07-01' AND TIMESTAMP '2026-07-15';

A cláusula CHANGES retorna linhas com colunas de metadados indicando se cada linha foi inserida, atualizada ou deletada. Isso elimina a necessidade de manter infraestrutura CDC separada para a maioria dos casos de uso.

Metric Views: Camada Semântica Nativa

Metric Views criam definições de negócio governadas diretamente em Spark SQL. As equipes definem métricas uma única vez, garantindo cálculos consistentes em dashboards, relatórios e aplicações de IA.

-- metric-views.sql
-- Definir uma view métrica para cálculos de receita
CREATE METRIC VIEW monthly_revenue AS
SELECT 
    DATE_TRUNC('month', order_date) AS month,
    SUM(amount) AS total_revenue,
    COUNT(DISTINCT customer_id) AS unique_customers,
    SUM(amount) / COUNT(DISTINCT customer_id) AS revenue_per_customer
FROM orders
WHERE status = 'completed'
GROUP BY DATE_TRUNC('month', order_date);

-- Consultar a view métrica
SELECT * FROM monthly_revenue WHERE month >= '2026-01-01';

Metric Views impõem consistência nos cálculos. Quando a equipe de finanças consulta monthly_revenue, obtém os mesmos números que a equipe de data science construindo modelos ML.

Modo Tempo Real para PySpark

Spark 4.2 introduz o Modo Tempo Real, simplificando workflows de streaming em PySpark. Essa funcionalidade reduz a carga operacional de gerenciamento de checkpoints e recuperação de falhas.

# streaming_pipeline.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, window

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

# Habilitar Modo Tempo Real para streaming simplificado
orders_stream = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "kafka:9092") \
    .option("subscribe", "orders") \
    .option("realtimeMode", "true") \
    .load()

# Agregar pedidos em janelas de 5 minutos
aggregated = orders_stream \
    .withWatermark("event_time", "10 minutes") \
    .groupBy(window(col("event_time"), "5 minutes"), col("region")) \
    .agg({"amount": "sum", "order_id": "count"})

# Escrever no Delta Lake
aggregated.writeStream \
    .format("delta") \
    .outputMode("append") \
    .option("checkpointLocation", "/checkpoints/orders") \
    .toTable("order_aggregates")

O Modo Tempo Real gerencia checkpoints internamente, reduzindo código boilerplate e complexidade operacional para aplicações de streaming.

Arquitetura da Plataforma Databricks em 2026

Databricks estende Spark com funcionalidades proprietárias que atendem requisitos enterprise. A plataforma combina Delta Lake, Unity Catalog, Mosaic AI e o novo motor OLTP Lakebase em um lakehouse integrado.

Unity Catalog: Governança Centralizada

Unity Catalog fornece controle de acesso granular sobre todos os ativos de dados. Segurança em nível de coluna, filtros de linha e mascaramento de dados se aplicam consistentemente através de queries SQL, notebooks e jobs de treinamento ML.

-- unity-catalog-policies.sql
-- Conceder acesso de leitura a colunas específicas
GRANT SELECT (customer_id, order_date, product_id) 
ON TABLE sales.orders 
TO `analyst-team`;

-- Criar política de segurança em nível de linha
CREATE ROW FILTER policy_regional_access 
ON sales.orders 
AS (region STRING) -> region = current_user_region();

-- Aplicar o filtro
ALTER TABLE sales.orders SET ROW FILTER policy_regional_access ON (region);

Com Spark autogerenciado, funcionalidade equivalente requer integração com Apache Ranger para controle de acesso, Apache Atlas para metadados e soluções customizadas para rastreamento de linhagem.

Economia do Compute Serverless

O SQL serverless do Databricks elimina custos de ociosidade de clusters. SQL Serverless custa $0.70 por DBU no AWS Premium, mas para workloads BI esporádicos, os custos totais frequentemente ficam 20-35% abaixo do SQL Pro porque as horas ociosas desaparecem.

| Tipo de Compute | Taxa DBU (AWS Premium) | Ideal Para | |-----------------|------------------------|------------| | Jobs Classic | $0.15 | ETL batch, processamento noturno | | Jobs Serverless | $0.28 | Workloads variáveis, agendamentos imprevisíveis | | SQL Pro | $0.55 | Queries BI sustentadas, padrões previsíveis | | SQL Serverless | $0.70 | Queries esporádicas, dashboards sob demanda | | Model Serving | $0.08 | Endpoints de inferência ML |

O tradeoff é direto: serverless cobra um premium de 20-40% em DBU versus compute classic, mas elimina custos de inicialização e ociosidade de clusters que podem dominar o gasto total para workloads variáveis.

Comparação de Arquitetura para Preparação de Entrevistas

Entrevistas de data engineering frequentemente exploram os tradeoffs entre Spark autogerenciado e plataformas gerenciadas como Databricks. A comparação a seguir cobre os tópicos de entrevista mais comuns.

Gerenciamento de Clusters e Escalabilidade

Spark autogerenciado requer configuração explícita de clusters. As equipes escolhem tipos de instância, configuram políticas de autoscaling e gerenciam interrupções de instâncias spot.

# spark_cluster_config.py
from pyspark import SparkConf

conf = SparkConf() \
    .setAppName("ProductionETL") \
    .set("spark.executor.instances", "10") \
    .set("spark.executor.cores", "4") \
    .set("spark.executor.memory", "16g") \
    .set("spark.dynamicAllocation.enabled", "true") \
    .set("spark.dynamicAllocation.minExecutors", "2") \
    .set("spark.dynamicAllocation.maxExecutors", "50") \
    .set("spark.shuffle.service.enabled", "true")

Databricks abstrai muito dessa complexidade. Políticas de cluster impõem padrões organizacionais, e instâncias otimizadas com Photon selecionam automaticamente configurações apropriadas.

Linhagem de Dados e Observabilidade

Databricks Unity Catalog rastreia linhagem automaticamente através de tabelas, notebooks e modelos ML. Cada operação de leitura e escrita cria uma trilha auditável.

Com Spark autogerenciado, rastreamento de linhagem requer ferramentas adicionais. Abordagens comuns incluem integração com Apache Atlas ou construção de soluções customizadas usando listeners Spark.

# custom_lineage_listener.py
from pyspark import SparkContext
from pyspark.sql import SparkSession

class LineageListener:
    def __init__(self, spark: SparkSession):
        self.spark = spark
        
    def track_read(self, table_name: str, query_id: str):
        # Registrar operação de leitura no store de linhagem
        lineage_record = {
            "operation": "read",
            "table": table_name,
            "query_id": query_id,
            "timestamp": datetime.now().isoformat(),
            "user": self.spark.sparkContext.sparkUser()
        }
        self._persist_lineage(lineage_record)
    
    def track_write(self, table_name: str, query_id: str, row_count: int):
        # Registrar operação de escrita com contagem de linhas afetadas
        lineage_record = {
            "operation": "write",
            "table": table_name,
            "query_id": query_id,
            "rows_affected": row_count,
            "timestamp": datetime.now().isoformat()
        }
        self._persist_lineage(lineage_record)

Opções de Camada de Armazenamento

Ambas as abordagens suportam formatos de tabela abertos. Delta Lake originou-se no Databricks mas é totalmente open source. Apache Iceberg fornece uma alternativa com forte suporte da comunidade.

| Funcionalidade | Delta Lake | Apache Iceberg | |----------------|------------|----------------| | Transações ACID | Sim | Sim | | Time Travel | Sim | Sim | | Evolução de Schema | Sim | Sim | | Evolução de Partição | Limitada | Completa | | Particionamento Oculto | Não | Sim | | Integração Principal | Databricks | Múltiplos motores |

Para uma análise mais profunda desses formatos, consulte a comparação Delta Lake vs Apache Iceberg.

Perguntas de Entrevista Comuns

As perguntas a seguir aparecem frequentemente em entrevistas de data engineering. Cada pergunta inclui o contexto que entrevistadores buscam e frameworks de resposta estruturados.

Pergunta 1: Quando escolher Spark autogerenciado em vez de Databricks?

O que entrevistadores avaliam: Consciência de custos, maturidade operacional e compreensão de restrições organizacionais.

Framework de resposta sólido:

• Previsibilidade de custos: Spark autogerenciado elimina cobranças por DBU. Para organizações com workloads constantes e previsíveis rodando 24/7, gasto de capital em instâncias reservadas frequentemente custa menos que precificação baseada em consumo.
• Soberania de dados: Algumas indústrias exigem que dados permaneçam on-premises ou em jurisdições específicas. Deployments autogerenciados em infraestrutura dedicada satisfazem esses requisitos.
• Expertise existente: Equipes com fortes capacidades de operações Kubernetes e Spark podem preferir a flexibilidade de deployments autogerenciados.
• Workloads multi-engine: Organizações usando Spark junto com Presto, Flink ou engines customizados se beneficiam de gerenciamento unificado de clusters através de YARN ou Kubernetes.

Pergunta 2: Como Databricks otimiza o desempenho do Spark?

O que entrevistadores avaliam: Compreensão do Delta Engine, Photon e otimizações específicas da plataforma.

Pontos-chave a cobrir:

• Photon: Motor de execução vetorizado nativo em C++ que substitui o motor Spark SQL baseado em JVM para operações suportadas. Fornece aceleração de 2-8x para workloads intensivos em scan e agregação.
• Delta Cache: Camada de cache baseada em SSD que acelera leituras repetidas do armazenamento em nuvem.
• Adaptive Query Execution: Versão aprimorada do AQE do Spark com otimizações adicionais para tratamento de data skew e seleção de estratégias de join.
• Otimização IO: Otimização automática de layout de dados, incluindo Z-ordering e compactação de arquivos.

Pergunta 3: Explicar os tradeoffs do compute serverless

O que entrevistadores avaliam: Habilidades de modelagem de custos e compreensão de características de workloads.

# cost_comparison.py
def estimate_monthly_cost(workload_type: str, daily_dbus: float, hours_active: float):
    """Comparar custos serverless vs classic."""
    
    # Taxas DBU (tier AWS Premium)
    rates = {
        "sql_classic": 0.55,
        "sql_serverless": 0.70,
        "jobs_classic": 0.15,
        "jobs_serverless": 0.28
    }
    
    # Clusters classic incorrem custos de ociosidade
    cluster_hours_per_day = 10  # Cluster roda 10h para 4h de trabalho real
    serverless_hours = hours_active  # Só paga por compute real
    
    classic_monthly = daily_dbus * cluster_hours_per_day * rates[f"{workload_type}_classic"] * 30
    serverless_monthly = daily_dbus * serverless_hours * rates[f"{workload_type}_serverless"] * 30
    
    return {
        "classic": classic_monthly,
        "serverless": serverless_monthly,
        "savings_percent": (classic_monthly - serverless_monthly) / classic_monthly * 100
    }

Serverless é adequado para workloads esporádicos e imprevisíveis. Compute classic vence para processamento sustentado e previsível onde clusters rodam perto da capacidade.

Pergunta 4: Como o Auto CDC do Spark 4.2 se compara a ferramentas CDC tradicionais?

O que entrevistadores avaliam: Compreensão de padrões de captura de dados de mudança e tradeoffs operacionais.

Pontos de comparação:

A versão Apache Spark 4.2 incorpora CDC no motor de query:

| Aspecto | Spark 4.2 Auto CDC | Debezium/Kafka | CDC Timestamp Custom | |---------|-------------------|----------------|----------------------| | Complexidade de Setup | Baixa | Alta | Média | | Latência Tempo Real | Minutos | Segundos | Minutos a horas | | Carga na Base Fonte | Nenhuma | Leitura de logs | Baseada em queries | | Queries Históricas | Integrado | Requer retenção | Limitada | | Evolução de Schema | Automática | Configuração necessária | Manual |

Auto CDC se destaca para workloads analíticos onde latência de nível de minutos é aceitável. Para requisitos sub-segundo, Debezium com Kafka permanece como a abordagem padrão.

Framework de Decisão Prático

Usar este framework ao avaliar Spark vs Databricks para uma organização ou projeto específico.

Escolher Spark Autogerenciado Quando:

• A equipe tem expertise existente em Spark e Kubernetes
• Workloads são previsíveis e rodam continuamente
• Dados devem permanecer on-premises ou em regiões específicas
• A organização já opera infraestrutura de plataforma de dados
• Sensibilidade a custos supera conveniência operacional

Escolher Databricks Quando:

• Time-to-production importa mais que custos por query
• A equipe carece de expertise profunda em operações Spark
• Requisitos de governança e compliance exigem trilhas de auditoria
• Workflows ML precisam de tracking de experimentos integrado e model serving
• Workloads BI se beneficiam de scaling serverless

Para preparação de entrevistas sobre orquestração de pipelines Apache Airflow e padrões ETL, os módulos de perguntas do SharpSkill oferecem prática estruturada.

Conclusão

• Apache Spark 4.2 traz Auto CDC, Metric Views e Modo Tempo Real como funcionalidades nativas, reduzindo a necessidade de ferramentas externas
• Databricks adiciona governança Unity Catalog, aceleração Photon e compute serverless sobre o fundamento Spark
• Spark autogerenciado oferece custos menores para workloads previsíveis e máxima flexibilidade arquitetural
• Databricks reduz carga operacional e acelera time-to-production para equipes sem expertise Spark profunda
• Sucesso em entrevistas requer compreender tanto as diferenças técnicas quanto os tradeoffs de negócio que guiam a seleção de plataforma
• A escolha certa depende das capacidades da equipe, modelo de custos, requisitos de compliance e características dos workloads