O que Spark & PySpark faz?
Quase todo job Spark lento é lento por uma de três razões: um shuffle evitável, uma chave desbalanceada (skew) ou linhas vazando pelo Python uma a uma. O erro custoso é ajustar o tamanho do cluster antes de ler o plano — pagar por mais executores para executar o mesmo DAG ineficiente mais rápido.
Procedimento operacional
Etapa 1: Coletar entradas
- O código do job e, para um job lento, a visualização da Spark UI do estágio lento (distribuição da duração das tarefas, tamanhos de leitura/escrita de shuffle) e a saída de
df.explain(True). - Tamanho e formato dos dados de entrada, e os tamanhos de ambos os lados de cada join.
- Configuração do cluster: número de executores, núcleos e memória.
- Se o job é uma nova criação ou um ajuste — para ajuste, diagnostique a partir do plano antes de tocar no código.
Etapa 2: Começar com uma sessão adequada
from pyspark.sql import SparkSession
from pyspark.sql import functions as F
spark = (
SparkSession.builder
.appName("etl")
.config("spark.sql.shuffle.partitions", "200")
.config("spark.sql.adaptive.enabled", "true")
.getOrCreate()
)
Habilite a Adaptive Query Execution (AQE); ela coalesce partições de shuffle e altera estratégias de join em tempo de execução. Em seguida, dimensione spark.sql.shuffle.partitions deliberadamente: aponte para 100-200 MB por partição de shuffle, então partições ≈ dado de shuffle ÷ 128 MB, e no mínimo 2-3x o total de núcleos de executores para que nenhum núcleo fique ocioso.
Etapa 3: Permanecer na API DataFrame e fora do Python
Operações com DataFrame passam pelo Catalyst e Tungsten, proporcionando otimização de consulta e memória off-heap. Desça para RDDs apenas quando não existir primitiva de DataFrame. UDFs Python serializam cada linha para o worker Python e de volta, quebrando a geração de código. Ordem de preferência:
- Funções embutidas
pyspark.sql.functions(ex.:F.regexp_extract,F.when). - UDFs Pandas (vetorizadas) quando Python for inevitável.
- UDFs Python escalares apenas como último recurso.
from pyspark.sql.functions import pandas_udf
@pandas_udf("double")
def normalize(s):
return (s - s.mean()) / s.std()
Etapa 4: Escolher a estratégia de join pelo tamanho
- Faça broadcast do lado menor quando ele couber em memória. Spark faz broadcast automático abaixo de
spark.sql.autoBroadcastJoinThreshold(padrão 10 MB); faça broadcast explícito de tabelas de até algumas centenas de MB quando a memória do executor permitir, e trate ~1 GB como o teto prático — broadcast copia a tabela para cada executor e causa OOM no job quando mal avaliado.
from pyspark.sql.functions import broadcast
result = large.join(broadcast(small), "key")
- Filtre e projete colunas antes de fazer join para reduzir o shuffle; cada coluna e linha removidas são bytes de shuffle economizados.
- Duas tabelas grandes → aceite o sort-merge join, mas verifique primeiro se há skew (Etapa 5).
Etapa 5: Diagnosticar e corrigir skew
Sintomas de skew: o estágio está quase completo, exceto por uma ou duas tarefas; a duração máxima da tarefa excede ~3-5x a mediana; uma partição de leitura de shuffle é muito maior que as demais na Spark UI. O tratamento de skew-join da AQE divide uma partição quando ela está tanto acima de 5x o tamanho mediano da partição quanto acima de 256 MB (os padrões) — verifique se ele foi ativado no plano. Quando a AQE não puder ajudar (ex.: agregação desbalanceada), faça salting das chaves quentes: adicione um sufixo aleatório 0..N à chave no lado grande, exploda o lado pequeno por todos os N sufixos, faça o join e depois remova o sal. Escolha N ≈ o fator de skew (uma chave 20x maior que a mediana recebe N=20).
Etapa 6: Controlar particionamento e layout de saída
repartition(n, col)faz um shuffle completo para balancear dados; use antes de writes amplos.coalesce(n)reduz partições sem shuffle; use para evitar arquivos de saída muito pequenos.- Aponte para arquivos de saída de 128 MB-1 GB; milhares de arquivos pequenos penalizam todo leitor downstream.
- Faça partitioning da saída apenas por colunas de baixa cardinalidade (data, região — dezenas a centenas de valores, nunca IDs):
df.write.partitionBy("dt").mode("overwrite").parquet("/data/out")
Etapa 7: Fazer cache apenas do que for reutilizado
Faça cache apenas quando um DataFrame for usado múltiplas vezes no DAG, materialize-o e limpe o cache quando terminar:
df.cache()
df.count() # materializar
# ... reutilizar df ...
df.unpersist()
Fazer cache de um DataFrame usado uma vez só desperdiça memória e pode despejar dados que importavam.
Etapa 8: Verificar com o plano
Execute novamente df.explain(True) e confirme que a estratégia pretendida aparece (BroadcastHashJoin, filtros empurrados, sem Exchange onde um foi eliminado). Leia formatos colunares (Parquet, ORC) para que a poda por predicados funcione, nunca use collect() em dados grandes para o driver, e prefira referências F.col em vez de colunas string ao encadear.
Exemplo prático: join ruim vs bom
Ruim — uma tabela de eventos de 2 TB juntada a uma dimensão de 200 MB, largura total, UDF Python para parsing:
result = (events.join(dims, "store_id") # sort-merge: faz shuffle de todos os 2 TB
.withColumn("region", parse_region_udf("meta")) # Python linha a linha
.filter(F.col("dt") == "2024-06-01")) # filtra DEPOIS do join
O plano mostra um Exchange em ambos os lados (2 TB shuffled), e a UDF bloqueia a geração de código.
Bom — filtre e projete primeiro, faça broadcast da dimensão, use função embutida:
result = (events
.filter(F.col("dt") == "2024-06-01") # poda para ~30 GB primeiro
.select("store_id", "amount", "meta")
.join(broadcast(dims.select("store_id", "region_code")), "store_id")
.withColumn("region", F.regexp_extract("meta", r"region=(\w+)", 1)))
O plano agora mostra BroadcastHashJoin sem Exchange do lado grande: ~30 GB escaneados, zero shuffle da tabela grande, sem fronteira Python.
Resultado
Produza o código revisado do job mais uma nota de ajuste contendo: a estratégia de join para cada join com a evidência de tamanho, a configuração de shuffle-partitions com sua aritmética, qualquer skew encontrado (razão max-vs-median das tarefas) e a correção aplicada, decisões de cache, expectativas de tamanho de arquivo de saída e os deltas do explain antes/depois para uma passagem de ajuste.
NÃO FAÇA
- NÃO faça broadcast de uma tabela que você não dimensionou — um broadcast mal avaliado causa OOM em todos os executores de uma vez.
- NÃO escreva uma UDF Python antes de verificar
pyspark.sql.functions; quase toda lógica de string, data e condicional tem uma função embutida. - NÃO use
collect()outoPandas()em um DataFrame grande; isso canaliza todos os dados do cluster por um único driver. - NÃO faça partition da saída por uma coluna de alta cardinalidade — milhões de diretórios, uma linha cada.
- NÃO jogue executores em um job cujo estágio lento é uma tarefa desbalanceada; mais núcleos não conseguem dividir uma partição.
- NÃO faça cache por reflexo; faça cache apenas de DataFrames reutilizados downstream, e limpe o cache.
Nível de qualidade
Um job finalizado só é aprovado quando: cada join nomeia sua estratégia e a evidência de tamanho para ela; spark.sql.shuffle.partitions é derivada do tamanho dos dados, não deixada em um valor de hábito; a Spark UI não mostra nenhuma tarefa acima de ~3x a duração mediana em estágios de shuffle (ou o skew é explicado e corrigido); nenhuma UDF Python escalar sobrevive onde existe função embutida; os arquivos de saída se enquadram na faixa de 128 MB-1 GB; e o explain final confirma o plano pretendido.