Apache Spark: Guia Completo de Processamento Distribuído com Python

O que é o Apache Spark?

O Apache Spark é um motor de processamento unificado e de código aberto para análise de dados em larga escala. Diferente do modelo clássico MapReduce do Hadoop que persiste dados em disco entre cada etapa o Spark realiza processamento in-memory o que o torna até 100x mais rápido para certas cargas de trabalho.

Lançado em 2014 pela UC Berkeley AMPLab e hoje mantido pela Apache Software Foundation o Spark se consolidou como a plataforma padrão para engenharia de dados ciência de dados e machine learning em ambientes corporativos.

Arquitetura do Spark

A arquitetura do Spark segue o modelo master-slave (ou driver-executor):

• Driver Program: o processo principal que coordena a execução. Ele mantém o SparkContext analisa o DAG (Directed Acyclic Graph) de transformações e distribui tarefas aos executores.
• Cluster Manager: gerencia os recursos do cluster. Pode ser o escalonador interno (Standalone) YARN (Hadoop) Mesos ou Kubernetes.
• Executors: processos worker que executam as tarefas atribuídas pelo driver armazenam dados em cache e retornam resultados.

Quando você submete um job o driver converte seu código em um DAG de estágios onde cada estágio contém múltiplas tarefas que rodam em paralelo nos executores. Essa abstração permite que o Spark otimize automaticamente o plano de execução.

Estruturas de Dados: RDD DataFrame e Dataset

RDD (Resilient Distributed Dataset)

O RDD é a abstração fundamental do Spark uma coleção imutável e distribuída de objetos particionada entre os nós do cluster. Suas propriedades principais:

• Resiliente: se uma partição for perdida o Spark a recalcula a partir do lineage (grafo de transformações).
• Distribuído: os dados são automaticamente particionados entre os executores.
• Imutável: uma vez criado um RDD não pode ser modificado apenas transformado em um novo RDD.

# Criando um RDD a partir de uma lista
dados = sc.parallelize([1, 2, 3, 4, 5])
pares = dados.filter(lambda x: x % 2 == 0)
print(pares.collect())  # [2, 4]

DataFrame

Inspirado no Pandas e no R o DataFrame organiza os dados em colunas com nomes e tipos. Ele oferece uma API de alto nível com otimização via Catalyst Optimizer que gera planos de execução mais eficientes que RDDs manuais.

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("Exemplo").getOrCreate()
df = spark.read.json("vendas.json")
df.filter(df.valor > 1000).groupBy("categoria").agg({"valor": "sum"}).show()

Dataset

Disponível apenas em linguagens com tipagem estática (Scala e Java) o Dataset combina a otimização do DataFrame com a segurança de tipos em tempo de compilação. Em PySpark o DataFrame é um alias para Dataset[Row].

Spark SQL: Consultas SQL sobre Dados Distribuídos

O módulo Spark SQL permite executar consultas SQL diretamente sobre DataFrames além de ler de fontes como Parquet JSON Avro JDBC e Hive.

df.createOrReplaceTempView("vendas")
resultado = spark.sql("SELECT categoria SUM(valor) as total FROM vendas GROUP BY categoria ORDER BY total DESC")
resultado.show()

A integração com SQL torna o Spark acessível até para analistas que não dominam Python ou Scala democratizando o acesso a dados massivos.

MLlib: Machine Learning Distribuído

O MLlib é a biblioteca de machine learning do Spark oferecendo algoritmos escaláveis para classificação regressão clustering recomendação e processamento de texto.

• Algoritmos: regressão linear/logística árvores de decisão Random Forest Gradient-Boosted Trees K-Means ALS (recomendação) PCA SVD.
• Pipelines: API de pipelines inspirada no Scikit-learn combinando transformadores e estimadores em fluxos reutilizáveis.
• Feature engineering: VectorAssembler StringIndexer OneHotEncoder StandardScaler e dezenas de outros transformadores.

from pyspark.ml.classification import RandomForestClassifier
from pyspark.ml.feature import VectorAssembler

assembler = VectorAssembler(inputCols=["idade" "salario" "score"] outputCol="features")
rf = RandomForestClassifier(labelCol="aprovado" numTrees=100)
pipeline = Pipeline(stages=[assembler rf])
modelo = pipeline.fit(treino)
predicoes = modelo.transform(teste)

Spark Streaming: Processamento em Tempo Real

O Spark Streaming (na API Structured Streaming) permite processar fluxos contínuos de dados com a mesma abstração de DataFrame que você usa para dados em lote.

eventos = spark.readStream.format("kafka").option("kafka.bootstrap.servers" "localhost:9092").option("subscribe" "eventos-usuarios").load()
contagem = eventos.groupBy("acao").count()
query = contagem.writeStream.outputMode("complete").format("console").start()
query.awaitTermination()

O Structured Streaming oferece garantias exactly-once e integração com Kafka Kinesis arquivos sockets e muito mais.

Otimizações e Boas Práticas

Para extrair o máximo do Spark em produção siga estas práticas:

• Cache inteligente: use .cache() ou .persist() em DataFrames que serão reutilizados múltiplas vezes. Prefira MEMORY_AND_DISK para evitar recomputação.
• Particionamento adequado: ajuste o número de partições com repartition() ou coalesce(). A regra prática é 2-3 partições por núcleo de CPU disponível.
• Evite shuffles desnecessários: operações como groupBy join e distinct causam shuffles. Sempre filtre e projete colunas antes dessas operações.
• Prefira DataFrame a RDD: o Catalyst Optimizer e o Tungsten engine geram código compilado altamente otimizado para DataFrames.
• Formato Parquet: sempre que possível armazene dados em Parquet (colunar comprimido com schema embutido) em vez de CSV ou JSON.

Spark no Ecossistema Moderno

• Delta Lake: camada de armazenamento ACID sobre Parquet que adiciona transações versionamento e otimizações de layout.
• Apache Iceberg / Apache Hudi: formatos de tabela abertos que competem com o Delta Lake suportados nativamente pelo Spark 3.x.
• Koalas (pandas API on Spark): permite escrever código Pandas que executa distribuído no Spark ideal para migração gradual.
• Spark Connect: nova arquitetura cliente-servidor do Spark 3.4+ permitindo conexões remotas via gRPC e integração com notebooks.

Conclusão

O Apache Spark não é apenas um motor de processamento é um ecossistema completo para engenharia e ciência de dados. Com sua capacidade de processar desde gigabytes até petabytes unificar workloads de batch e streaming e oferecer APIs em Python Scala SQL e R ele se tornou a espinha dorsal da infraestrutura de dados em empresas como Netflix Uber Amazon e Spotify.

Se você está começando na área de dados dominar Spark junto com SQL e Python é um dos investimentos de maior retorno na sua carreira. Comece com pequenos datasets locais explore o Spark Shell interativo e aos poucos escale para clusters maiores. O caminho dos dados é distribuído e o Spark é o mapa.