O RDD, bem como as principais operações que podem ser executadas sobre RDDs. Vamos também examinar alguns exemplos concretos de aplicações Spark. Você vai aprender a instalar o Spark e vai começar a se familiarizar com o código de aplicações Spark.

A arquitetura do Apache Spark

Já sabemos que o Spark é uma plataforma para processamento de grandes volumes de dados em um ambiente de computação distribuída, isto é, composta por mais uma unidade de computação independente (vários computadores reais ou virtuais). Vamos, agora, entender mais sobre a arquitetura do Spark, seus principais componentes e como eles interagem.

A Figura 9 ilustra a arquitetura geral do Spark. Ela é composta por três componentes principais:

·        O driver program.

·        O gestor do cluster (cluster manager).

·        Um conjunto de worker nodes.

O driver é o “main()” de uma aplicação Spark. Ele é responsável por:

·        Orquestrar as operações paralelas executadas no cluster.

·        Comunicar com o gestor do cluster e agendar operações a serem executadas no cluster.

·        Distribuir a alocação de recursos nos executores, que são os processos que de fato executam as tarefas, dentro dos nodos que chamamos de workers.

O cluster manager, por sua vez, é um serviço que gerencia e aloca recursos do cluster. Vários gestores de cluster podem ser “plugados” aqui: o gestor de cluster padrão do Spark ou outros, como o Hadoop YARN, Apache Mesos e Kubernetes.

Por fim, os workers são nós do cluster que executa tarefas da aplicação Spark.

O processo dentro do worker que executa a aplicação é chamado de executor.

Figura 9 – A arquitetura do Apache Spark.

Fonte: https://spark.apache.org/

RDD

O RDD é a principal estrutura de dados e abstração do Spark. RDD significa Resilient Distributed Dataset, (1) um conjunto de dados que é (2) distribuído no cluster e (3) tolerante (resiliente) a falhas. A Figura 10 representa um RDD: o programador interage com uma estrutura de dados que, por debaixo dos panos, representa uma coleção de objetos que está particionada fisicamente no cluster, em potencialmente

dezenas ou milhares de nós. O programador, no entanto, não precisa conhecer como isso é feito; ele lida com uma estrutura de dados única e o fato de que os dados estão potencialmente particionados no cluster é transparente para ele. Mais formalmente, o RDD é uma abstração de memória distribuída que permite aos programadores executarem computações em memória em clusters de maneira tolerante a falhas.

Figura 10 – RDDs: Resilient Distributed Datasets. O RDD guarda os dados de forma distribuída em vários nodos de forma transparente para o programador.

Fonte: https://medium.com/@lavishj77/spark-fundamentals-part-2-a2d1a78eff73

O Spark tenta manter, sempre que possível, os RDDs na memória dos nodos do cluster. Diferentemente de outros frameworks como o Apache Hadoop MapReduce, manter os dados em memória traz ganhos de desempenho de uma ordem de magnitude ou, mais especialmente, em algoritmos iterativos (típicos do mundo de aprendizado de máquina), quando os mesmos dados são lidos processados múltiplas vezes.

Uma aplicação Spark tipicamente opera sobre RDDs da seguinte forma:

1.     Lê dados do disco (potencial, de um sistema de arquivos distribuído como o HDFS) para um RDD.

2.     Aplica uma sequência de transformações sobre um RDD, como, por exemplo, filtrar o RDD para apenas manter itens que satisfazem um critério.

3.     Aplica uma sequência de ações que retornam para o driver um resultado, por exemplo, contar quantos itens fazem parte do RDD.

Existem três formas de se criar um RDD. A primeira é a partir de uma coleção em memória, o driver vai dividir a coleção em partes e enviá-las para os workers. A Figura 11 mostra um código em Python que lê uma lista da memória do driver e cria um RDD.

Figura 11 – Criando um RDD a partir de uma coleção em memória.

A segunda forma é a partir da leitura de um arquivo que está no sistema de arquivos local ou um sistema de arquivos distribuído como o Apache HDFS:

Figura 12 – Criando um RDD a partir de um arquivo.

Finalmente, a terceira forma é criar um RDD a partir de um RDD existente, a partir de uma operação de transformação. Na Figura 13 o rdd2 é alvo de uma transformação flatMap(), que quebra as linhas do arquivo em palavras e produz um rddf cujos objetos são palavras do arquivo. No decorrer deste capítulo vamos estudar em detalhes as principais transformações que podem ser aplicadas sobre RDDs.

O Spark implementa tolerância a falhas da seguinte forma: o sistema mantém registro das transformações executadas sobre um RDD; caso a comunicação com o executor responsável por uma partição do RDD seja perdida, o Spark detém toda a informação necessária para recomputar o estado do RDD desde o princípio. A sequência de transformações aplicadas a um RDD é chamada no mundo Spark de lineage (linhagem).

Figura 13 – Criando um RDD a partir de uma transformação.

Instalando o Spark e executando uma aplicação Spark em Python

Nesta seção vamos baixar e instalar o Spark. Siga os passos:

1.     Confirme que você tem o Java e o Python instalado com java -version e

python --version. Caso contrário, instale o Java e o Python.

Figura 14 – Verificando que o Java e o Python estão instalados.

1.     Baixe o Spark em https://spark.apache.org/downloads.html;

Figura 15 – Site para download do Spark.

Confirme que o arquivo foi baixado para a sua máquina:

Figura 16 – Verificando que arquivo contendo a instalação do Spark foi baixado.

1.     https://phoenixnap.com/kb/install-spark-on-ubuntu                               e https://phoenixnap.com/kb/install-spark-on-windows-10 são links utéis com o passo a passo para instalar o Spark no Linux e Windows. No Linux, mova o arquivo tgz para a pasta /opt:

Figura 17 – Movendo o arquivo de instalação do Spark para a pasta /opt.

Em seguida, vá para a pasta /opt (com cd /opt) e descompacte o arquivo:

Figura 18 – Descompactando o arquivo de instalação do Spark.

Em seguida, renomeie o diretório recém-criado spark-3.2.1-bin-hadoop3.2 para

spark, para facilitar nosso trabalho:

Figura 19 – Renomeando a pasta que contém os arquivos do Spark.

1.     No Linux, ajuste as variáveis de ambiente como no demonstrado no link https://phoenixnap.com/kb/install-spark-on-ubuntu e na Figura 14.

Figura 20 – Ajustando as variáveis de ambiente do Spark no Linux.

Com o Spark instalado, você pode executar o spark-shell e ter acesso a um ambiente interativo em que você pode programar na linguagem Scala e interagir com o Spark:

Figura 21 – Entrando no spark-shell.

Veja na Figura 21 que o sistema carrega o objeto spark, que é do tipo SparkSession: o SparkSession é um objeto como ponto de entrada para interagir com o Spark. No spark-shell, que é um modo interativo, o SparkSession é criado automaticamente para o programador, e em uma aplicação Spark convencional, o programador deve criá-lo. Na Figura 21, o comando spark.version mostra a versão do Spark que está instalada. Na Figura 22, usamos o objeto spark para ler um arquivo-texto, mostrar as 10 primeiras linhas e contar o número de linhas.

Figura 22 – Lendo um arquivo texto por meio de um objeto SparkSession.

O spark-shell é um ambiente para programar na linguagem Scala; para usar o Python é necessário instalarmos o PySpark. Siga as instruções descritas no link: https://spark.apache.org/docs/latest/api/python/getting_started/install.html            ou simplesmente execute pip install pyspark ou pip3 install pyspark (para Python 3).

O PySpark é um ambiente interativo similar ao spark-shell, porém a linguagem suportada é o Python, como você pode ver na Figura 23.

Figura 23 – ambiente interativo do PySpark, útil para interagir com a API do Spark na linguagem Python.

Por fim, é útil instalar um ambiente web para desenvolvimento interativo, como o JupyterLab (https://jupyter.org/install). Após instalá-lo, você poderá programar em Spark em Python em um ambiente interativo, conforme mostra a Figura 24.

Figura 24 – interface do Jupyter-Lab permite a criação de um Python Notebook.

Alternativa: usando uma imagem do Docker que já tem o Spark instalado.

Alguns alunos costumam ter dificuldade para instalar o Apache Spark no Linux ou no Windows. Ao invés de instalar o Spark na sua máquina, você pode baixar uma imagem de uma instalação Linux que já contém o Spark instalado. O Docker é uma plataforma para criar, implantar e gerir aplicações em containers, que são componentes que contém aplicações junto com o sistema operacional e bibliotecas já instaladas. Para subir um container Docker que contém o sistema operacional Linux com o Spark já instalado, siga os passos:

1.     Instale o Docker. No Windows, você pode seguir as instruções em: https://docs.docker.com/desktop/windows/install/.

2.     Vá em https://hub.docker.com/r/bitnami/spark e siga as instruções:

a.     Execute:

curl -L0

  https://raw.githubusercontent.com/bitnami/bitnami- docker-spark/master/docker-compose.ymlb.     Execute: docker-compose up

3.     Agora você tem um container docker de pé que já tem o spark instalado.

4.     Após subir o container via docker-compose up, encontre uma linha de log como esta: "spark-worker-2_1 | 21/11/11 00:30:05 INFO Worker: Successfully registered with master spark://156fbd78435c:7077"

5.     A linha acima indica o ID do container. 156fbd78435c, no exemplo acima.

6.     Entre no container: docker exec -ti 156fbd78435 /bin/bash.

7.     Pronto, agora você já está dentro de uma máquina que tem o spark-shell e

pyspark de pé e funcionando! Execute “pyspark” para testar.

8.     Para copiar um arquivo da sua máquina para o container, você pode fazer: docker cp titanic.csv 156fbd78435:/var/tmp/, em que 156fbd78435 deve ser substituído pelo identificador que você encontrou no passo 4.