Fundamentos de Apache Spark e Big Data

Bem-vindo ao guia definitivo sobre os Fundamentos de Apache Spark e Big Data! Se você é estudante e busca dominar o processamento de grandes volumes de dados, chegou ao lugar certo. Este artigo lhe proporcionará uma compreensão sólida de Apache Spark, desde sua instalação até suas capacidades avançadas, ideal para aqueles que estão começando no mundo do Big Data. Exploraremos o que é Spark, seus componentes, como ele se compara com outras ferramentas e como você pode começar a trabalhar com ele de maneira prática.

O que é Apache Spark e por que ele é fundamental em Big Data?

Apache Spark é um sistema distribuído projetado para processar grandes volumes de dados de forma eficiente e rápida. Representa uma evolução do popular modelo MapReduce, oferecendo a capacidade de executar cálculos em memória, o que o torna significativamente mais veloz. Spark é projetado para cobrir uma ampla gama de cargas de trabalho que antes exigiam sistemas distribuídos separados, como consultas interativas e processamento de streams.

Uma de suas características principais é sua acessibilidade. Oferece APIs simples em linguagens como Python, Java, Scala, R e SQL, o que facilita combinar diferentes tipos de processamento e reduz a carga administrativa. É uma ferramenta indispensável para a análise de dados produtivos e complexos.

Componentes Essenciais de Apache Spark

Spark se organiza em vários componentes que trabalham juntos para oferecer sua potente funcionalidade:

• Spark Core: Contém a funcionalidade básica, incluindo o agendamento de tarefas, a gestão de memória, a recuperação de falhas e a interação com sistemas de armazenamento. Aqui reside a API que define os RDDs.
• Spark SQL: O pacote do Spark para trabalhar com dados estruturados. Permite misturar consultas SQL com manipulação de dados programática compatível com RDDs em Python, R, Java e Scala, tudo dentro de uma única aplicação.
• Spark Streaming: Permite o processamento de streams de dados em tempo real, como as atualizações de status de usuários de um serviço web, com a mesma tolerância a falhas e escalabilidade que o Spark Core.
• MLlib: Fornece vários algoritmos de aprendizado de máquina, incluindo classificação, regressão, agrupamento (clustering) e filtragem colaborativa, juntamente com funções de apoio.
• GraphX: Uma biblioteca para manipular dados em forma de grafos, estendendo a API RDD do Spark e oferecendo operadores e algoritmos comuns de grafos como PageRank.

Quem utiliza Spark e para quê?

Os usuários de Spark podem ser divididos em dois grandes grupos:

• Cientistas de Dados: Focados na análise de dados, utilizam Spark por sua velocidade e APIs simples para realizar análises interativas e ver os resultados rapidamente. Têm experiência em SQL, estatística, modelagem preditiva e programação.
• Engenheiros de Dados: Empregam Spark para criar aplicações de processamento de dados em ambientes produtivos. Spark simplifica a paralelização de aplicações em clusters e oculta a complexidade da programação distribuída, da comunicação de rede e da tolerância a falhas.

Instalação do Spark no Google Colaboratory: Um Guia Prático

Para começar a trabalhar com Apache Spark, o Google Colaboratory (Colab) é uma excelente opção devido à sua acessibilidade e simplicidade. Colab é um serviço hospedado de Jupyter Notebook que não requer configuração e oferece acesso gratuito a recursos computacionais. É ideal para tarefas de aprendizado de máquina, análise de dados e educação.

Passos para Configurar o Spark no Colab

Siga estes passos para instalar e configurar o Spark em seu ambiente Colab:

1. Criar uma conta Gmail: Necessária para acessar os serviços do Google.
2. Acessar o Google Drive: Abra seu Google Drive.
3. Selecionar 'Novo' e 'Conectar mais aplicativos': Busque e conecte "Collaboratory" se você ainda não o tiver instalado.
4. Instalar SDK Java 8: Spark requer Java para ser executado. Execute o seguinte comando em uma célula do Colab:

!apt-get install openjdk-8-jdk-headless -qq > /dev/null

5. Baixar Spark 3.2.3: Baixe a versão do Spark compatível com Hadoop 3.2:

!wget -q 

6. Descompactar o arquivo do Spark:

!tar xf spark-3.2.3-bin-hadoop3.2.tgz

7. Definir as variáveis de ambiente: Defina os caminhos para JAVA_HOME e SPARK_HOME:

import os
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-8-openjdk-amd64"
os.environ["SPARK_HOME"] = "/content/spark-3.2.3-bin-hadoop3.2"

8. Instalar a biblioteca findSpark: Esta biblioteca ajuda o Spark a encontrar a instalação:

!pip install -q findspark

9. Instalar pySpark: A interface do Python para Spark:

!pip install -q pyspark

10. Verificar a instalação e testar a sessão do Spark: Inicialize o findSpark e crie uma sessão Spark:

import findspark
findspark.init()
from pyspark.sql import SparkSession
spark = SparkSession.builder.master("local[*]").getOrCreate()
# Probar la sesión
df = spark.createDataFrame([{"Hola": "Mundo"} for x in range(10)])
df.show(10, False)

O parâmetro master("local[*]") indica que o Spark deve usar todos os cores disponíveis localmente. Você também pode usar .appName('Modulo 3') para nomear sua aplicação. Para verificar se a sessão está em execução, basta digitar spark e o resultado deve mostrar os detalhes da sessão.

Compreendendo o PySpark: A união de Python e Spark

PySpark é a interface do Python para Apache Spark. Permite que os programadores de Python interajam com o framework do Spark, combinando a simplicidade do Python com o poder do Apache Spark para lidar com Big Data. Enquanto o Spark é escrito principalmente em Scala e é executado na JVM, o PySpark facilita o uso do Spark para cientistas e engenheiros de dados familiarizados com Python.

Com o PySpark, você pode dominar o Big Data, manipular dados em escala e trabalhar com objetos e algoritmos em um sistema de arquivos distribuído, sem a necessidade de aprender Scala ou Java.

DataFrames no PySpark vs. Pandas: Qual escolher?

Quando trabalhamos com processamento de dados em Python, duas das bibliotecas mais utilizadas são Pandas e PySpark. Embora compartilhem semelhanças, especialmente nos nomes de algumas funções, suas diferenças são cruciais, especialmente ao lidar com Big Data.

DataFrames no Pandas

• Estrutura de dados: Um DataFrame do Pandas é uma estrutura de dados chave para a manipulação de dados tabulados (linhas e colunas), construída sobre o pacote Numpy.
• Desempenho: Suporta até aproximadamente 2 milhões de registros de forma eficiente. Para arquivos maiores, o desempenho pode ser um problema.
• Manipulação de dados: Permite aplicar funções personalizadas diretamente às colunas. Pode-se acessar linhas específicas por meio de sua posição com o comando .iloc.
• Uso: Ideal para arquivos pequenos e médios, aproveitando sua versatilidade e facilidade de uso em ambientes de nó único.

DataFrames no PySpark

• Estrutura de dados: Um DataFrame no PySpark é construído sobre RDDs (conjuntos de dados distribuídos resilientes). Eles são organizados em colunas, o que permite consultas mais rápidas e aproveita a computação em paralelo.
• Desempenho: Projetado para trabalhar com volumes de dados muito superiores a 2 milhões de registros, aproveitando a computação distribuída.
• Manipulação de dados: A manipulação pode ser mais complexa do que com Pandas. Não é possível aplicar funções personalizadas diretamente ao DataFrame da mesma maneira. Acessar uma linha específica requer uma coluna com um número incremental como índice guia.
• Uso: É a opção preferível quando se trabalha com computação paralela, como clusters de Databricks, e arquivos de grandes volumes para aproveitar os recursos distribuídos.

Ambiente de Operação do Spark

O ambiente de operação do Spark é diferente do Pandas, envolvendo vários atores:

• Job: Uma peça de código que lê uma entrada do usuário.
• Etapas (Stages): Os jobs são divididos em etapas, baseadas em limites computacionais.
• Tarefas (Tasks): Cada etapa tem tarefas, uma por partição. Uma tarefa é executada sobre uma partição em um executor.
• Executor: O processo responsável por executar uma tarefa.
• Master: A máquina onde roda o programa líder (driver program).
• Slave: A máquina onde roda o programa de execução (executor program).

Resilient Distributed Datasets (RDDs): O coração do Spark

Um Resilient Distributed Dataset (RDD) representa uma coleção de elementos posicionados através dos nós de um cluster, os quais podem ser operados em paralelo. Eles são a base sobre a qual os DataFrames do Spark são construídos.

Características de um RDD

Um RDD possui três características principais:

• Dependências: Uma lista que indica ao Spark como um RDD é construído a partir de suas entradas. Isso permite ao Spark recriar um RDD a partir dessas dependências quando necessário, conferindo resiliência.
• Partições: Proporcionam a capacidade de dividir o trabalho para paralelizar o cálculo entre executors. Você pode visualizar o número de partições com .getNumPartitions().
• Função de Cálculo: Produz um iterador para os dados que serão armazenados no RDD.

Formas de Criar um RDD no Spark

Para criar um RDD, primeiro você precisa de uma sessão Spark e um SparkContext (sc = spark.sparkContext).

• RDD Vazio: Você pode criar um RDD vazio com ou sem partição:

rdd_vacio = sc.emptyRDD
# O con particiones
rdd_vacio3 = sc.parallelize([], 3)

• RDD com dados: Utilizando a função parallelize:

rdd = sc.parallelize([1, 2, 3, 4, 5])
# Para visualizar el contenido: rdd.collect()

• RDD a partir de um arquivo de texto: Com o comando textFile:

rdd_texto = sc.textFile('./rdd_source.txt')
# Cada línea del archivo es un registro. Para visualizar: rdd_texto.collect()

Se você deseja que todo o arquivo seja um único registro, use wholeTextFiles:

rdd_text_completo = sc.wholeTextFiles('./rdd_source.txt')
rdd_text_completo.collect()

• RDD a partir de outro existente: Por meio de transformações, por exemplo, map:

rdd_suma = rdd.map(lambda x: x + 1)

• RDD a partir de um DataFrame: Primeiro crie um DataFrame e depois o converta:

df = spark.createDataFrame([(1, 'Jose'), (2, 'Juan')], ['id', 'Nombre'])
rdd_desde_df = df.rdd

MapReduce e o Processamento Distribuído em Big Data

MapReduce é um modelo ou padrão de programação que se integra dentro do framework de Apache Hadoop. Sua função principal é facilitar o processamento simultâneo de grandes quantidades de dados, dividindo-os em fragmentos menores e processando-os em paralelo em servidores Hadoop. MapReduce não envia os dados para a aplicação, mas sim é executado onde os dados estão localizados, o que acelera o processamento.

Arquitetura do MapReduce

A arquitetura do MapReduce se baseia em dois processos chave:

• JobTracker: É o processo mestre responsável pela coordenação e completude da operação MapReduce. Gerencia e rastreia os recursos para seguir as solicitações.
• TaskTracker: É um processo slave do JobTracker. Envia mensagens ao JobTracker a cada 3 segundos, informando sobre os slots disponíveis e o status das tarefas.

Fases de uma Operação MapReduce

Os trabalhos de MapReduce envolvem vários passos complexos que são executados em três fases principais:

1. Map: A primeira fase do programa. Envolve:

• Dividir: O arquivo de entrada é dividido em partes iguais menores (input splits).
• Mapear: Hadoop utiliza um RecordReader para transformar os splits de entrada em pares chave-valor. O mapper processa esses pares e produz uma saída da mesma forma (pares chave-valor). Um mapper é instanciado para cada split de entrada, alcançando paralelismo.

2. Shuffle and Sorting: São passos intermediários entre o mapper e o reducer, gerenciados pelo Hadoop. O processo de shuffle agrupa os valores-chave da saída do mapper e adiciona os valores a uma lista. A saída será um mapa <chave, Lista<lista de valores>>. As chaves são consolidadas e ordenadas.
3. Reducer: A saída da fase de shuffle and sorting é utilizada como entrada para a fase reducer. Aqui, a lista de valores é processada. Cada chave pode ser enviada a um reducer diferente, o qual estabelece o valor final, que é consolidado no resultado final do trabalho de MapReduce e salvo no HDFS.

Operações Essenciais com Spark SQL para Manipulação de Dados

Spark SQL é o componente do Spark para trabalhar com dados estruturados, oferecendo operações mais relacionais em comparação com os RDDs. Assim como com os RDDs, as operações são divididas em transformações e ações. É importante lembrar que os DataFrames são imutáveis, o que significa que suas operações de transformação sempre retornam um novo DataFrame.

Selecionar e Filtrar Colunas

• Selecionar colunas: Você pode escolher quais colunas visualizar utilizando select:

df_p.select('departamento').show()

• select e selectExpr: select também pode ser usado com a função col de pyspark.sql.functions para criar expressões a partir de outras colunas:

from pyspark.sql.functions import col
df_p.select(col('precio_normal')).show()
df_p.select((col('precio_normal') - col('preciotc')).alias('diferencia')).show()

selectExpr permite expressões SQL diretamente como strings:

df_p.selectExpr('precio_normal', 'preciotc', '(precio_normal - preciotc) as diferencia').show()

• filter e where: Para filtrar dados com base em condições:

df_p.filter(col('precio_normal') == '699990.00').show()
# Con where, puedes filtrar al cargar el DataFrame:
df_p1 = spark.read.parquet('parquet_sample').where(col('precio_normal') == '699990.00')

Remover Duplicados

• distinct: Remove linhas completamente duplicadas em um DataFrame:

df_p_sin_duplicados = df_p.distinct()

• dropDuplicates: Permite remover duplicados com base em um subconjunto específico de colunas:

dataframe = spark.createDataFrame([(1, 'azul', 567), (2, 'rojo', 567), (1, 'azul', 567), (2, 'verde', 567)]).toDF('id', 'color', 'importe')
# Ejemplo de uso: dataframe.dropDuplicates(['id', 'color'])

Criação e Manipulação de Tabelas com Arquivos CSV e Parquet

Spark SQL facilita a leitura e escrita de diferentes formatos de arquivo, sendo CSV e Parquet muito comuns:

• Ler CSV: Para carregar um arquivo CSV, especificando o separador e se ele tem cabeçalho:

df = spark.read.csv('./marketplace_20221227.csv', sep=';', header=True)
# Puedes verificar con df.count() y df.show()

• Escrever Parquet: Salvar um DataFrame no formato Parquet, que é um formato colunar otimizado para Big Data:

df.write.parquet('parquet_sample', mode='overwrite')

• Ler Parquet: Para carregar um arquivo Parquet:

df_p = spark.read.parquet('parquet_sample')

Os workshops de Spark SQL, como os mencionados nos materiais, permitirão que você aplique esses conhecimentos em problemas reais de análise de dados, como os casos de COVID-19 na Coreia do Sul ou dados de futebol, reforçando sua compreensão de como trabalhar com grandes volumes de informação.

Perguntas Frequentes sobre Spark e Big Data

Quais são as principais vantagens do Apache Spark para Big Data?

Apache Spark se destaca por sua velocidade, graças à capacidade de executar cálculos em memória, e sua versatilidade para lidar com diversas cargas de trabalho (consultas interativas, streaming, Machine Learning). Além disso, oferece APIs simples em múltiplas linguagens, facilitando sua adoção por cientistas e engenheiros de dados.

O que é um RDD no Spark e por que ele é importante?

Um RDD (Resilient Distributed Dataset) é uma coleção imutável de elementos distribuídos através dos nós de um cluster, que podem ser operados em paralelo. Sua importância reside no fato de que eles são a base das estruturas de dados no Spark, proporcionando resiliência a falhas e a capacidade de processar dados de forma distribuída e eficiente.

Quando devo usar Pandas e quando PySpark para o processamento de dados?

Você deve usar Pandas para conjuntos de dados pequenos a médios (até 2 milhões de registros) que podem ser manipulados eficientemente em um único equipamento, aproveitando sua versatilidade e facilidade de manipulação. PySpark é a opção recomendada para grandes volumes de dados que requerem processamento distribuído e paralelo em clusters, como os que superam os 2 milhões de registros, devido à sua escalabilidade e desempenho em Big Data.

Qual é o primeiro passo para instalar o Spark em um ambiente local ou Colab?

O primeiro passo fundamental para instalar o Spark é instalar o SDK do Java 8. Spark é escrito em Scala, que é executado na JVM (Java Virtual Machine), portanto, Java é um requisito prévio indispensável para seu funcionamento. No Colab, isso é feito com !apt-get install openjdk-8-jdk-headless -qq > /dev/null.

Que ações posso realizar através de uma sessão do Spark?

Uma sessão do Spark (SparkSession) fornece um único ponto de entrada unificado para todas as funções do Spark. Através dela, você pode criar DataFrames, ler fontes de dados (CSV, Parquet, etc.), acessar metadados do catálogo e emitir consultas Spark SQL. Essencialmente, é sua porta de entrada para interagir com todas as capacidades de processamento de dados do Spark.