Engine unificado para analytics em larga escala com processamento em memória
Apache Spark é um engine unificado para analytics em larga escala que fornece APIs de alto nível em Java, Scala, Python e R, além de um engine otimizado que suporta grafos de execução gerais. Ele também suporta um conjunto rico de ferramentas de alto nível incluindo Spark SQL para SQL e processamento de dados estruturados, pandas API no Spark para processamento pandas, MLlib para machine learning, GraphX para processamento de grafos, e Structured Streaming para processamento incremental e stream.
O Apache Spark foi desenvolvido inicialmente na UC Berkeley em 2009 como parte do projeto AMPLab. Foi open-sourced em 2010 e doado para a Apache Software Foundation em 2013. O projeto se tornou um Apache Top-Level Project em 2014. Spark foi criado para superar as limitações do MapReduce, especialmente para workloads iterativos e interativos.
Spark utiliza uma arquitetura master-worker onde o driver program coordena a execução através de um cluster manager (como YARN, Mesos ou Kubernetes). Os dados são representados como Resilient Distributed Datasets (RDDs) ou DataFrames/Datasets, que são distribuídos através dos nós do cluster. O engine utiliza lazy evaluation e otimizações como o Catalyst optimizer para melhorar performance.
Engine fundamental com RDDs, task scheduling, memory management e fault recovery.
Módulo para trabalhar com dados estruturados usando SQL ou DataFrame API.
Processamento de stream escalável e fault-tolerant baseado no Spark SQL engine.
Biblioteca de machine learning escalável com algoritmos comuns e utilitários.
API para processamento de grafos e computação paralela de grafos.
API compatível com pandas para processamento distribuído de DataFrames.
| Versão Atual | 3.5.0 |
| Linguagens Suportadas | Scala, Java, Python, R, SQL |
| Cluster Managers | YARN, Mesos, Kubernetes, Standalone |
| Formatos de Dados | Parquet, JSON, CSV, Avro, ORC, Delta Lake |
| Sistemas de Armazenamento | HDFS, S3, Azure Blob, GCS, Cassandra, HBase |
| Requisitos Mínimos | Java 8+, 1GB RAM por executor |
Transformação de grandes volumes de dados com performance superior ao MapReduce tradicional. Ideal para pipelines de dados complexos que requerem múltiplas transformações.
Consultas ad-hoc em grandes datasets com resposta em segundos. Perfeito para data scientists e analistas que precisam explorar dados rapidamente.
Processamento de dados em tempo real de fontes como Kafka, Kinesis ou TCP sockets. Ideal para detecção de fraudes, monitoramento e alertas.
Treinamento de modelos ML em larga escala com MLlib. Suporte a algoritmos distribuídos para classificação, regressão, clustering e filtragem colaborativa.
Análise de redes sociais, detecção de comunidades e algoritmos de grafos como PageRank usando GraphX.
# Download e instalação
wget https://archive.apache.org/dist/spark/spark-3.5.0/spark-3.5.0-bin-hadoop3.tgz
tar -xzf spark-3.5.0-bin-hadoop3.tgz
export SPARK_HOME=/path/to/spark-3.5.0-bin-hadoop3
export PATH=$PATH:$SPARK_HOME/bin
# Instalação via pip (PySpark)
pip install pyspark
# Instalação via conda
conda install pyspark# spark-defaults.conf
spark.master yarn
spark.driver.memory 2g
spark.executor.memory 4g
spark.executor.cores 2
spark.sql.adaptive.enabled true
spark.sql.adaptive.coalescePartitions.enabled true
spark.serializer org.apache.spark.serializer.KryoSerializerfrom pyspark.sql import SparkSession
from pyspark.sql.functions import col, count, avg
# Criar SparkSession
spark = SparkSession.builder \
.appName("ExemploSpark") \
.config("spark.sql.adaptive.enabled", "true") \
.getOrCreate()
# Ler dados
df = spark.read.parquet("s3://bucket/dados.parquet")
# Transformações
resultado = df.filter(col("idade") > 18) \
.groupBy("categoria") \
.agg(count("*").alias("total"),
avg("valor").alias("valor_medio")) \
.orderBy("total", ascending=False)
# Ação
resultado.show()
# Salvar resultado
resultado.write.mode("overwrite").parquet("s3://bucket/resultado.parquet")
spark.stop()import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions._
object ExemploSpark {
def main(args: Array[String]): Unit = {
val spark = SparkSession.builder()
.appName("ExemploSpark")
.config("spark.sql.adaptive.enabled", "true")
.getOrCreate()
import spark.implicits._
// Ler dados
val df = spark.read.parquet("s3://bucket/dados.parquet")
// Transformações e agregações
val resultado = df
.filter($"idade" > 18)
.groupBy("categoria")
.agg(count("*").alias("total"),
avg("valor").alias("valor_medio"))
.orderBy($"total".desc)
resultado.show()
spark.stop()
}
}# Structured Streaming com Kafka
from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col
from pyspark.sql.types import StructType, StructField, StringType, IntegerType
spark = SparkSession.builder \
.appName("StreamingExample") \
.getOrCreate()
# Schema dos dados
schema = StructType([
StructField("user_id", StringType(), True),
StructField("event_type", StringType(), True),
StructField("timestamp", StringType(), True),
StructField("value", IntegerType(), True)
])
# Ler stream do Kafka
df = spark.readStream \
.format("kafka") \
.option("kafka.bootstrap.servers", "localhost:9092") \
.option("subscribe", "events") \
.load()
# Parse JSON e transformações
parsed_df = df.select(
from_json(col("value").cast("string"), schema).alias("data")
).select("data.*")
# Agregação em janela de tempo
windowed_counts = parsed_df \
.groupBy(
window(col("timestamp"), "1 minute"),
col("event_type")
) \
.count()
# Output para console
query = windowed_counts.writeStream \
.outputMode("update") \
.format("console") \
.trigger(processingTime='30 seconds') \
.start()
query.awaitTermination()| Tecnologia | Performance | Facilidade de Uso | Comunidade | Licença |
|---|---|---|---|---|
| Apache Spark | Excelente | Alta | Muito Ativa | Apache 2.0 |
| Apache Flink | Excelente | Média | Ativa | Apache 2.0 |
| Hadoop MapReduce | Média | Baixa | Ativa | Apache 2.0 |
| Dask | Boa | Alta | Ativa | BSD |
| Ray | Excelente | Boa | Crescente | Apache 2.0 |