GCP - Dataproc

Dataproc é o serviço gerenciado de Apache Hadoop e Apache Spark do GCP. Permite executar workloads Spark, Hive, Flink e outros componentes do ecossistema Hadoop sem gerenciar a infraestrutura de cluster.

É a escolha principal para migrar workloads Spark existentes para a GCP, ou para times que já dominam PySpark e não precisam do modelo de programação do Dataflow (Apache Beam).

Dataproc vs Dataflow

	Dataproc	Dataflow
SDK	PySpark / Scala Spark	Apache Beam
Workloads existentes	Migração direta	Reescrita necessária
Curva de aprendizado	Menor (PySpark familiar)	Maior (modelo Beam)
Streaming	Spark Structured Streaming	Nativo e robusto
Gerenciamento	Cluster gerenciado ou Serverless	Totalmente serverless
Ideal para	Migrar Spark existente, Hive, Presto	Pipelines novos, streaming complexo

Modos de execução

Clusters gerenciados

Cluster de VMs com master e workers. Criado sob demanda e destruído após o job para minimizar custo:

# Criar cluster efêmero
gcloud dataproc clusters create meu-cluster \
  --region=us-central1 \
  --num-workers=4 \
  --worker-machine-type=n1-standard-4 \
  --image-version=2.1-debian11
 
# Submeter job PySpark
gcloud dataproc jobs submit pyspark gs://meu-bucket/jobs/meu_job.py \
  --cluster=meu-cluster \
  --region=us-central1 \
  -- --input=gs://meu-bucket/raw/ --output=gs://meu-bucket/processed/
 
# Destruir cluster após uso
gcloud dataproc clusters delete meu-cluster --region=us-central1

Dataproc Serverless

Executa jobs Spark sem criar ou gerenciar cluster. O GCP aloca recursos automaticamente e cobra apenas pela duração do job:

gcloud dataproc batches submit pyspark gs://meu-bucket/jobs/meu_job.py \
  --region=us-central1 \
  --deps-bucket=gs://meu-bucket/deps \
  -- --input=gs://meu-bucket/raw/ --output=gs://meu-bucket/processed/

Dataproc Serverless é o modo recomendado para novos jobs batch sem necessidade de sessão interativa.

Job PySpark típico

from pyspark.sql import SparkSession
from pyspark.sql import functions as F
import argparse
 
parser = argparse.ArgumentParser()
parser.add_argument("--input",  required=True)
parser.add_argument("--output", required=True)
args = parser.parse_args()
 
spark = SparkSession.builder.appName("meu-job").getOrCreate()
 
df = (
    spark.read.parquet(args.input)
    .filter(F.col("status") == "ativo")
    .withColumn("ano_mes", F.date_format("data_criacao", "yyyy-MM"))
    .groupBy("ano_mes", "regiao")
    .agg(
        F.count("*").alias("total"),
        F.sum("valor").alias("receita"),
    )
)
 
df.write.mode("overwrite").parquet(args.output)
 
spark.stop()

Componentes do ecossistema suportados

Componente	Uso
Apache Spark	Processamento batch e streaming em memória
Apache Hive	SQL sobre dados no GCS/HDFS
Apache Flink	Streaming com baixa latência
Presto / Trino	SQL analítico interativo e federado
Jupyter Notebooks	Análise interativa via Component Gateway

Integração com o ecossistema GCP

GCS como sistema de arquivos: Dataproc usa o conector gs:// nativamente, substituindo o HDFS local. Dados ficam no GCS mesmo após o cluster ser destruído.

Metastore: usar o Dataproc Metastore (Hive Metastore gerenciado) para compartilhar esquemas de tabelas entre clusters e com o BigQuery.

BigQuery Connector: lê e escreve tabelas BigQuery diretamente do Spark sem exportar para GCS:

df = (
    spark.read.format("bigquery")
    .option("table", "meu-projeto.dataset.tabela")
    .load()
)
 
df.write.format("bigquery") \
    .option("table", "meu-projeto.dataset.resultado") \
    .mode("overwrite") \
    .save()

Cloud Composer: operadores DataprocCreateClusterOperator, DataprocSubmitJobOperator e DataprocDeleteClusterOperator permitem orquestrar o ciclo completo (criar, executar, destruir) como um DAG Airflow.

from airflow.providers.google.cloud.operators.dataproc import (
    DataprocCreateClusterOperator,
    DataprocSubmitJobOperator,
    DataprocDeleteClusterOperator,
)
 
criar   = DataprocCreateClusterOperator(task_id="criar_cluster",   ...)
executar = DataprocSubmitJobOperator(task_id="executar_job", ...)
destruir = DataprocDeleteClusterOperator(task_id="destruir_cluster", ...)
 
criar >> executar >> destruir

Boas práticas

Clusters efêmeros: criar o cluster, executar o job e destruir imediatamente. Clusters ociosos são o principal gerador de custo desnecessário.
Separar compute de storage: manter todos os dados no GCS, não no HDFS local do cluster.
Dataproc Serverless primeiro: para novos jobs batch, preferir Serverless antes de provisionar clusters gerenciados.
Autoscaling: ativar autoscaling policies em clusters de longa duração para ajustar o número de workers conforme a carga.
Preemptible workers: usar VMs preemptíveis (70% mais baratas) para workers secundários em jobs tolerantes a falha.

Second Brain

Explorer