CEDS-841-Big Data-(Banco Itaú) == CES-229-Teste de Software-(ITA)

1º SEMESTRE 2020 – Aula 10.3b – Apache Spark

Prof. MSc. Emanuel Mineda (FATEC-SP) – Prof. Dr. Adilson Cunha (ITA)
Prof. Dr. Vieira Dias (ITA) – Prof. Dr. Lineu Mialaret (IFSP e ITA)
2.3a.1/29
 Bibliografia

• Karau, Holden; Konwinski, Andy;

Wendell, Patrick; Zaharia, Matei;
Learning Spark: Lightning Fast Data
Analysis; O'Reilly; 2015
• Kienzler, Romeo; Mastering Apache
Spark 2.x; Second Edition; Packt;
2017

2.3a.2/29
 Matei Zaharia

Alma mater UC Berkeley (Ph.D.)

University of Waterloo (BSc)
Known for
Apache Spark
Scientific career
Fields Computer science
Institutions Stanford University (Prof.)
Databricks (CTO)
Thesis An Architecture for Fast and
General Data Processing on
Large Clusters (2013)
Doctoral Ion Stoica
advisor Scott Shenker
Website cs.stanford.edu/~matei/

2.3a.3/29
Matei Zaharia is a computer scientist and the creator of Apache Spark.[1][2]

Zaharia was an undergraduate at the University of Waterloo.[3] While at University of

California, Berkeley 's AMPLab in 2009, he created Apache Spark as a faster alternative
to MapReduce.[4] He received the 2015 ACM Doctoral Dissertation Award for his PhD
research on large-scale computing.
In 2013 Zaharia was one of the co-founders of Databricks where he serves as Chief
Technology Officer.[2]
He joined the faculty of MIT in 2015, and then became an assistant professor of computer
science at Stanford University in 2016.[5]
In 2019, Zaharia received the Presidential Early Career Award for Scientists and
Engineers.[3]
In 2019 he was spearheading MLflow at Databricks, while still teaching.[6][7][8]
Zaharia is also a past gold medalist at the International Collegiate Programming Contest,
where his team University of Waterloo placed 4th in the world and 1st in North America in
2005.[9] (Wikipedia)

2.3a.4/29
 Apache Spark – Histórico

• 2009 – Início do Spark como um projeto do RAD Lab da universidade

de Berkley (Coordenado pelo Prof. Zaharia Matei*)
• Criado após observação da ineficiência do MapReduce ao lidar com tarefas
computacionais iterativas e interativas
• 10 a 20 vezes mais rápido que o MapReduce para determinadas tarefas
• Foi desenvolvido visando rapidez em consultas interativas e algoritmos iterativos

• 2010 – Transformado em um projeto Open-Source

• 2013 – Transferido para a Apache Foundation
• (*) Atualmente Professor de Stanford University e CTO

2.3a.5/29
 Apache Spark – Características

• Plataforma computacional de propósito geral em cluster

• Habilidade de executar operações computacionais em memória
• Maior velocidade
• Requer maior quantidade de memória RAM em cada nó do cluster
• Recomendado mínimo de 8 GB, mas quanto mais melhor
• Recomendada alocação de 75% da memória para o Apache Spark

• APIs em Python, Scala, Java e SQL

2.3a.6/29
Apache Spark – Componentes

2.3a.7/29
 Apache Spark – Componentes

• O Apache Spark pode executar sobre os seguintes gerenciadores de

cluster
• Apache Hadoop YARN (Yet Another Resource Negotiator) – Gerenciador de
recursos e agendador de tarefas introduzido com o Hadoop v2
• Apache Mesos – Gerenciador de Cluster que fornece uma abstração de
recursos (recursos do cluster podem ser utilizados como um único recurso
virtual)
• Standalone Scheduler – Gerenciador embutido no Spark, para utilização em
um cluster de máquinas sem gerenciador instalado

2.3a.8/29
 Apache Spark – Componentes

• Spark Core – Funcionalidades básicas do Spark

• Agendamento de tarefas, gerenciamento de memória, recuperação de falhas,
interação com sistemas de armazenamento, etc
• API para defini RDDs (Resilient Distributed Datasets) – vide Seção RDD

• Spark SQL – Biblioteca para trabalhar com dados estruturados.

• Em vez de RDD utiliza as estruturas DataFrame e Dataset, próprias para dados
colunares
• Suporta SQL e HiveQL

• Spark Streaming – Biblioteca para processamento de fluxos de

dados (dados em movimento)
2.3a.9/29
 Apache Spark – Componentes

• MLlib – Biblioteca que provê as funcionalidades mais comuns de

Aprendizagem de Máquina (Machine Learning), como classificação,
regressão, agrupamento (clustering), etc
• SparkML – Biblioteca de ML que trabalha com DataFrames e Datasets (dados
colunares)

• GraphX – Biblioteca para manipulação de grafos

• GraphFrames – Equivalente ao GraphX com suporte a DataFrames

2.3a.10/29
 Apache Spark – Programação

• Toda aplicação Spark consiste de: (i) um programa principal, (ii) o

driver program, que lança várias operações paralelas em um cluster
• Cada shell fornecido pelo Spark (spark-shell e pyspark) é um driver program

• Cada Driver Program acessa o Spark por meio de um objeto

SparkContext
• Dentro de um shell o SparkContext é instanciado automaticamente, com
configurações padrão (basta usar diretamente a variável sc)

2.3a.11/29
 Apache Spark – Programação

• Um Driver Program tipicamente gerencia um conjunto de nós

denominados Executors, responsáveis por executar tarefas
• Quando executado em um cluster, o Spark acessa os Executors por meio de
um gerenciador de cluster

2.3a.12/29
 Apache Spark – RDD

• Resilient Distributed Dataset (RDD) – O Apache Spark

distribui automaticamente os dados contidos em um RDD pelo
cluster e paraleliza todas as operações realizadas nele
• Podem ser criados de duas formas: carregando um dataset externo (um
arquivo, por exemplo) ou distribuindo um collection de objetos (uma list ou um
set, por exemplo)

2.3a.13/29
 Apache Spark – RDD

• Carregando um dataset externo:

lines = sc.textFile("/path/to/README.md")

• É importante notar que o arquivo indicado não é completamente lido

(geralmente somente a primeira linha é lida)

• Distribuindo uma collection:

lines = sc.parallelize(["pandas", "i like pandas"])

2.3a.14/29
 Apache Spark – RDD – Operações

• RDDs suportam dois tipos de operações: Transformação

(Transformation) e Ação (Action)
• Transformações geram um novo RDD a partir do RDD em que são
executadas
• Aplicam funções sobre os atributos de cada registro, gerando novos atributos ou
registros e filtrando atributos ou registros. Operações de conjunto também estão
disponíveis
• Transformações não são executadas imediatamente (Lazy). Apenas após a
realização de uma Ação sobre um RDD todas as transformações realizadas até o
momento são aplicadas

• Uma Ação realiza uma computação e retorna o resultado (que não é um RDD)
ao Driver Program ou o grava em um meio de armazenamento 2.3a.15/29
 Apache Spark – RDD – Operações

Dados

RDD Transformação1 RDD' Transformação2 RDD''

Resultado Ação
Antes de executar a ação, os dados são efetivamente
lidos e as transformações 1 e 2 executadas.
Isso ocorre para evitar manter uma quantidade grande
de dados em memória e para fins de otimização. 2.3a.16/29
 Apache Spark – RDD – Operações

• Transformações comuns:
• map – Aplica uma função a um registro

lines = sc.textFile("/path/to/example.csv")
linesSplit = lines.map(lambda line: line.split(","))

• Nesse exemplo, cada registro corresponde a uma linha do arquivo. Ao executar

map, cada registro passa a ser um array de strings
• Supondo registros ['1,Daisy,10.0', '2,Donald,3.5'], os registros resultantes seriam
[['1','Daisy','10.0'],['2','Donald','3.5']]

2.3a.17/29
 Apache Spark – RDD – Operações

• Transformações comuns (cont.):

• flatMap – Similar ao map, mas o resultado é "achatado" (se o resultado for um
array ou lista, cada elemento será transformado em um novo registro)

lines = sc.textFile("/path/to/words.txt")
words = lines.map(lambda line: line.split(","))

• Nesse exemplo, cada registro corresponde a uma linha do arquivo. Ao executar

flatMap, cada registro é dividido em vários registros
• Supondo dois registros ['1,Daisy,10.0', '2,Donald,3.5'], os seis registros resultantes
seriam ['1', 'Daisy', '10.0', '2', 'Donald', '3.5']

2.3a.18/29
 Apache Spark – RDD – Operações

• Transformações comuns (cont.):

2.3a.19/29
 Apache Spark – RDD – Operações

• Transformações comuns (cont.):

• filter – Retorna um RDD contendo somente os registros que satisfazem um
critério

inputRDD = sc.textFile("log.txt")
errorsRDD = inputRDD.filter(lambda x: "error" in x)

• Nesse exemplo, somente registros contendo a palavra "error" permanecem no RDD

resultante

2.3a.20/29
 Apache Spark – RDD – Operações

• Transformações comuns (cont.):

2.3a.21/29
 Apache Spark – RDD – Operações

• Transformações comuns (cont.):

• Operações de conjuntos

2.3a.22/29
 Apache Spark – RDD – Operações

• Ações comuns:
• reduce – Função que toma dois registros do RDD, realiza uma operação e
retorna um registro do mesmo tipo. O processo é repetido até que sobre
apenas um registro

sum = rdd.reduce(lambda x, y: x + y)

2.3a.23/29
 Apache Spark – RDD – Operações

• Ações comuns (cont.):

• collect – Recolhe o RDD completo para a máquina executando o Driver
Program. O resultado pode ser iterado e trabalhado. Isso gerará erro se o RDD
não couber na memória da máquina destino

>>> lines = sc.parallelize(["panda", "lion", "orca", "lion", "lion"])

>>> lines.filter(lambda line: "o" in line).collect()
Out[8]: (['lion', 'orca', 'lion', 'lion'])

2.3a.24/29
 Apache Spark – RDD – Operações

• Ações comuns (cont.):

• take(n) – Recolhe n registros do RDD para a máquina executando o Driver
Program. O resultado pode ser iterado e trabalhado. A máquina destino deve
comportar n registros

>>> lines = sc.parallelize(["panda", "lion", "orca", "lion", "lion"])

>>> lines.take(2)
Out[4]: (['panda', 'lion'])

2.3a.25/29
 Apache Spark – RDD – Operações

• Ações comuns (cont.):

• count – Conta a quantidade de registros do RDD

>>> lines = sc.parallelize(["panda", "lion", "orca", "lion", "lion"])

>>> lines.count()
Out[9]: 5

2.3a.26/29
 Apache Spark – RDD – Persistência

• A cada avaliação (quando da execução de uma ação) de um RDD

todas as transformações necessárias para gerá-lo são executadas.
• Para evitar isso, caso um RDD precise ser avaliado múltiplas vezes, existe o
comando persist, que avalia e armazena o resultado

result.persist(pyspark.StorageLevel.DISK_ONLY_2)

• Os seguintes níveis de armazenamento estão disponíveis: DISK_ONLY,

DISK_ONLY_2, MEMORY_AND_DISK, MEMORY_AND_DISK_2,
MEMORY_AND_DISK_SER, MEMORY_AND_DISK_SER_2, MEMORY_ONLY,
MEMORY_ONLY_2, MEMORY_ONLY_SER, MEMORY_ONLY_SER_2
• "_2" indica fator de replicação 2 e "_SER" indica serializado
2.3a.27/29
 Apache Spark – RDD – Submit

• Para submeter um programa Spark para execução em um cluster

utiliza-se o comando spark-submit no terminal

spark-submit myapp.py

• É importante lembrar que o programa deve instanciar um SparkContext

manualmente

2.3a.28/29
 Apache Spark – RDD – Submit

#myapp.py

from pyspark.sql import SparkSession

logFile = "YOUR_SPARK_HOME/README.md" # Should be some file on your system

spark = SparkSession.builder.appName("SimpleApp").getOrCreate()
logData = spark.read.text(logFile).cache()

numAs = logData.filter(logData.value.contains('a')).count()
numBs = logData.filter(logData.value.contains('b')).count()

print("Lines with a: %i, lines with b: %i" % (numAs, numBs))

spark.stop()

2.3a.29/29
 Apache Spark – Exemplo
#Calculo da tabela de conversão da transformacao SR
dataset=sc.parallelize([["k", "p"], ["k", "e"], ["n", "e"], ["n", "p"], ["k", "e"],
["n", "e"], ["g", "e"], ["n", "e"], ["p", "p"], ["g", "e"], ["g", "e"]])
positiveValue = "p"
negativeValue = "e"
attributeIndex = 0
targetIndex = 1
p = dataset.map(
lambda x: (
x[attributeIndex],
( 1 if x[targetIndex] == positiveValue else 0,
1 if x[targetIndex] == negativeValue else 0,
1 if x[targetIndex] == positiveValue else 0) ) )
.reduceByKey(
lambda x, y: (
x[0]+y[0],
x[1]+y[1],
1.0 * (x[0] + y[0])/(x[0] + y[0] + x[1] + y[1])
)
)

2.3a.30/29