Aula 10 - Framework Spark

Prévia do material em texto

/
Big Data
Aula 10: Framework Spark
Apresentação
 Na aula anterior, estudamos o sistema de arquivo distribuído do Hadoop, o HDFS. A ênfase foi explicar a estratégia
utilizada para armazenar dados de forma distribuída. O HDFS divide um grande conjunto de dados em pequenos blocos,
que são distribuídos entre os nós do cluster de forma redundante, com o objetivo de garantir a disponibilidade dos dados
mesmo em caso de falha de hardware.
Nesta aula, estudaremos o framework Apache Spark desenvolvido para computação distribuída em cluster, semelhante ao
modelo MapReduce, porém projetado para ser rápido para processamento interativo e em tempo real.
Objetivos
Identi�car as características e funcionalidades do Spark;
Explicar a arquitetura do Spark;
Descrever alguns dos módulos do Spark.
Introdução
O Spark começou como um projeto de pesquisa no AMPLab da Universidade da California em Berkeley, em 2009, e teve o
código aberto no início de 2010. Ao longo dos anos, foi crescendo com a ajuda de uma ampla comunidade de desenvolvedores
e mudou-se para a Apache Software Foundation em 2013.
O projeto continua sendo desenvolvido de forma colaborativa pela comunidade, que já contou com a participação de mais de
1200 desenvolvedores de aproximadamente 300 organizações distintas. Atualmente, participam do comitê do projeto mais de
25 organizações.
Essa comunidade concentra esforços para dar continuidade ao desenvolvimento de Apache Spark como uma plataforma de
computação em cluster que ofereça uma API (Application Programmer Interface) para programação distribuída, semelhante ao
modelo MapReduce, porém projetada para ser rápida para consultas interativas e algoritmos iterativos.
/
Saiba mais
Sua execução pode ser realizada em clusters do Hadoop, sob gerenciamento do YARN, ou no seu modo autônomo (stand alone),
proporcionando �exibilidade para processar dados em HDFS, HBase, Cassandra, Hive e qualquer outro formato de entrada aceito
pelo Hadoop, tanto para processamento em lote quanto em tempo real (streaming).
Ele consegue realizar isso principalmente fazendo caching dos dados necessários para processamento na memória dos nós
do cluster, que permite ao Apache Spark executar algoritmos iterativos, pois os programas podem criar pontos de veri�cação
(checkpoint) de dados e consultá-los novamente sem recarregá-los de disco.
Com isso, o Spark mantém o conjunto de dados em memória o máximo possível no decorrer da aplicação, evitando a recarga
dos dados entre as iterações.
Desse modo, os jobs não são programados somente para especi�car os passos de mapeamento e redução, como no
MapReduce, mas uma série de passos de transformações com �uxos de dados a ser aplicada aos dados de entrada antes da
execução de alguma ação que exija coordenação, como uma redução ou uma escrita em disco.
Como os �uxos de dados são organizados em grafos direcionados acíclicos (Directed Acyclic Graphs - DAG), o Spark sabe, com
antecedência, como distribuir o processamento no cluster e administra os detalhes do processamento.
Ao combinar o �uxo de dados acíclico e processamento em memória, o Spark se torna extremamente rápido, em particular
quando o cluster é grande o su�ciente para armazenar todos os dados em memória.
De fato, ao aumentar o tamanho do cluster e, desse modo, a quantidade de memória disponível para armazenar um conjunto
de dados bem grande e completo, a velocidade do Spark permite que ele possa ser usado interativamente.
Além disso, embora o Spark seja implementado na linguagem Scala, tem
APIs de programação tanto em Scala quanto em Java, R e Python, bem
como um rico conjunto de bibliotecas para implementar processamentos em
estilo SQL, processamento de �uxo, algoritmos de grafos e aprendizado de
máquina.
Todas essas características fazem do Apache Spark um mecanismo de análise uni�cado para processamento de dados em
grande escala, com as seguintes vantagens:
/
Clique nos botões para ver as informações.
O Apache Spark tem alto desempenho para dados em lote e streaming, usando um agendador DAG, um otimizador de
consulta e um mecanismo de execução física, chegando a executar até 100 vezes mais rápido do que outros recursos
oferecidos pelo Hadoop;
Rapidez 
Os aplicativos podem ser escritos em Java, Scala, Python, R e SQL. Além disso, o Spark oferece mais de 80 operadores de
alto nível que facilitam a construção de aplicativos paralelos. Pode ser usado interativamente a partir dos shells Scala,
Python, R e SQL;
Facilidade de uso 
O Apache Spark provê uma coleção de bibliotecas para realização de consultas SQL, processamento de streaming e
análises complexas que podem ser perfeitamente combinadas no mesmo aplicativo;
Generalidade 
O Apache Spark pode ser executado em plataforma Hadoop, Apache Mesos, Kubernetes, de forma autônoma ou na
nuvem. Além disso, pode acessar diversas fontes de dados.
Flexibilidade de execução 
 Arquitetura
O Spark segue a arquitetura mestre-escravo. Seu cluster consiste em um único mestre, o driver program, e vários escravos,
chamados de workers nodes. O driver program contém um SparkContext e cada worker node tem um executor, um cache e
várias tarefas (tasks), conforme ilustrado a seguir.
/
 Arquitetura do Apache Spark. Fonte: Autor.
 Aplicações Spark
 Clique no botão acima.
Essencialmente, as aplicações Spark são executadas como conjuntos independentes de processos, coordenadas por
um SparkContext no driver program. O driver program é um processo que executa a função main () do aplicativo e cria
o objeto SparkContext. O SparkContext converte um aplicativo em um DAG de tarefas individuais executadas dentro de
um processo de executor nos workers nodes.
Cada aplicativo obtém seus próprios processos executores. Esses processos são mantidos durante a execução do
aplicativo e executam tarefas em vários threads.
A distribuição de tarefas ocorre através da conexão entre o SparkContext e um gerenciador de cluster (cluster
manager), por exemplo, o YARN do Hadoop, para que os recursos necessários sejam alocados.
Após a conexão, o SparkContext adquire executores dos workers nodes e envia o código do aplicativo para eles. Por
�m, o SparkContext envia tarefas para serem realizadas pelos executores, isto é, processos que realizam cálculos e
armazenam dados para o seu aplicativo.
Dessa forma, o SparkContext executa a função principal do aplicativo e as várias operações paralelas são executadas
nos workers nodes. Os resultados das operações realizadas nos workers nodes são coletados pelo SparkContext. Cada
worker node é administrado por um executor que, por sua vez, é gerenciado pelo SparkContext. O executor administra
o processamento, bem como a armazenagem e o caching em cada nó.
/
Durante a execução das operações, os workers nodes armazenam os dados na memória em cache organizados em um
conjunto de dados distribuídos resilientes (Resilient Distributes Datasets – RDD), eliminando assim as escritas intermediárias
custosas em disco.
Comentário
O RDD tem a característica de ser resiliente devido à capacidade de restauração dos dados em caso de falha e, também, tem a
característica de ser distribuído devido aos dados �carem armazenados no cache de vários workers nodes. Além disso, os
workers nodes podem obter dados de um sistema de arquivo, por exemplo do HDFS do Hadoop, para realizar suas operações, e
ao conclui-las pode gravar os dados em um sistema de arquivos.
Sendo assim, as tarefas individuais, de�nidas no DAG pelo SparkContext, formam um grá�co direto �nito para representar uma
sequência de transformações nos dados, em que cada nó representa uma partição RDD, e as arestas são as operações sobre
os dados. Nesse sentido, os DAGs são direcionados porque um ou mais passos seguem uns aos outros, e são acíclicos porque
um único passo não se repete.
Quando um �uxo de dados é descrito como um DAG, uma sincronização custosa é eliminada e aplicações paralelas são mais
fáceis de serem construídas.
Esse mecanismo garante a segurança dos dados, pois os RDDs representamuma coleção de dados somente para leitura,
particionada em um conjunto de máquinas. Os RDDs podem ser criados a partir de uma linhagem e são acessados por meio
de operações paralelas.
Podem ser lidos e inscritos em repositórios distribuídos, por exemplo, o HDFS, e, acima de tudo, podem ser colocados em
cache na memória dos nós trabalhadores para a reutilização imediata.
Esse recurso de caching em memória permite velocidades extremamente
mais altas e possibilita um processamento interativo necessário para
aprendizado de máquina e análises interativas centradas no usuário.
As operações aplicadas nos RDDs podem ser de dois tipos: Transformações e ações. As transformações são operações
aplicadas a um RDD existente para criar um novo RDD. Algumas das transformações suportadas pelo Spark são:
/
map
Aplica uma função em um RDD e
retorna um novo conjunto de
dados distribuído transformado.
Outras funções semelhantes são:
�atMap, mapPartitions,
mapPartitionsWithIndex.
�lter
Aplica uma função em um RDD
para �ltrar os elementos de um
RDD e retorna um novo conjunto
de dados.
union
Retorna um novo conjunto de
dados contendo a união de
elementos de dois RDDs. Outras
funções semelhantes são:
intersection, distinct, join,
cartesian.
reduceByKey
Retorna um novo conjunto de
dados contendo os dados
agregados por uma chave
usando uma função reduce
fornecida. Outras funções
semelhantes são: groupByKey,
aggregateByKey, distinct.
As ações, porém, são operações que, na verdade, devolvem um resultado ao driver program, resultante de uma coordenação ou
de uma agregação de todas as participações em um RDD. A maioria das ações no Spark está projetada unicamente para gerar
uma saída, isto é, devolver um único valor, uma pequena lista de valores ou escrever dados de volta no repositório distribuído.
Algumas das ações comuns suportadas pelo Spark são:
/
Clique nos botões para ver as informações.
agrega os elementos de conjunto de dados usando uma função.
reduce 
retorna todos os elementos de um conjunto de dados como um array no drive program.
collect 
retorna a quantidade de elementos em um conjunto de dados. A função countByKey é uma variante dessa função.
count 
retorna um array com os primeiros n elementos passados como parâmetro para função. Outras funções semelhantes são:
�rst, takeSample, takeOrdered.
take 
grava os elementos do conjunto de dados como um arquivo de texto em um determinado diretório no sistema de arquivos
local, HDFS ou qualquer outro sistema de arquivos compatível com Hadoop. Outras funções semelhantes são:
saveAsSequenceFile, saveAsObjectFile.
saveAsTextFile 
Tais transformações são executadas de forma preguiçosa (lazy), de forma que uma sequência completa de transformações e
uma ação são inspecionadas antes de serem submetidas ao cluster.
Essa execução preguiçosa proporciona otimizações signi�cativas de armazenagem e de processamento, pois permite ao
Spark construir uma linhagem dos dados e avaliar a cadeia completa de transformações para efetuar um processamento
apenas sobre os dados necessários a um resultado.
Exemplo
Para executar a ação �rst em um RDD (função que retorna somente a primeira linha de um RDD), o Spark evitará ler todo o
conjunto de dados e devolverá apenas a primeira linha correspondente.
/
Para realizar essas operações, pode ser usado o shell do Spark, que pode ser acessado via console digitando o comando
./bin/spark/shell no diretório de instalação do Spark. Quando o shell for carregado automaticamente, um SparkContext é criado
e pode ser acessado através de uma variável chamada sc.
Outra opção para realizar as operações é desenvolver uma aplicação em Scala, Java ou Phyton e submetê-la ao Spark. Nesse
caso, antes de programar as operações, deve ser construído um SparkConf com as informações sobre o aplicativo e um
SparkContext para informar ao Spark como acessar um cluster.
Após a conclusão do desenvolvimento da aplicação, ela deve ser empacotada e submetida a um cluster como um JAR, se for
uma aplicação Scala ou Java, ou um conjunto de arquivo .py ou .zip, se for uma aplicação Python.
Notas
 Módulos
Apache Spark é um conjunto rico de módulos de nível superior, incluindo Spark SQL para realizar consultas estilo SQL e
processamento de dados estruturados, MLlib para aprendizado de máquina, GraphX para processamento de grafo e
Streams estruturados para computação incremental e processamento de �uxo.
Spark SQL
Spark SQL é um módulo Spark para processamento de dados estruturados. Existem várias maneiras de interagir com o
Spark SQL, incluindo consultas SQL, a API Dataset e a API DataFrame.
Saiba mais
O Spark SQL oferece uma interface relacional para trabalhar com dados estruturados usando operações conhecidas
baseadas em SQL que podem ser usadas por meio de conectores JDBC/ODBC, um console embutido e interativo do Hive,
para executar SQL de dentro de outra linguagem de programação ou através de linha de comando no shell.
Ao executar consultas SQL, os resultados são retornados como um Dataset ou DataFrame. Os DataFrames podem ser
construídos a partir de uma ampla variedade de fontes, tais como: Arquivos de dados estruturados, tabelas no Hive,
bancos de dados externos ou RDDs existentes. A API DataFrame está disponível em Scala, Java, Python e R.
Para exempli�car o uso do Spark SQL, veja a seguir extrato de um programa Java que carrega dados em um DataFrame e
os consulta. Os dados estão em um arquivo JSON, denominado cliente.json, que contém informação de nome, endereço e
telefone de vários clientes.
O uso do Spark SQL em Java se inicia com a construção de uma SparkSession para depois os dados serem carregados e
consultados através de um comando SQL, conforme abaixo:
import org.apache.spark.sql.SparkSession; 
import org.apache.spark.sql.Dataset; 
import org.apache.spark.sql.Row; 
/
De forma semelhante à apresentada no �nal da Seção 2, para executar esse aplicativo ele deve ser transformado em um
arquivo.JAR e submetido ao Spark.
Spark Streaming
Spark Streaming é uma extensão da API principal do Spark que permite o processamento escalonável, de alto rendimento e
tolerante a falhas de �uxos de dados em tempo real. Os dados podem ser ingeridos de várias fontes, como HDFS, Kafka,
Kinesis ou soquetes TCP através de um objeto que recebe um �uxo contínuo de dados chamado �uxo discretizado
(Discretized Stream – DStream).
//Construção do SparkSession SparkSession spark = SparkSession.builder().appName(“Exemplo Spark SQL”) 
.con�g(“spark.some.con�g.option”,”some-value”) .getOrCreate(); 
//Carrega os dados de um arquivo JSON em um DataFrame 
Dataset< Row > df = spark.read().json("cliente.json");
// Registra o DataFrame como uma view temporária 
df.createOrReplaceTempView(“cliente”);
// Consulta dados usando SQL Dataset< Row > sqlDF = spark.sql("SELECT nome FROM cliente"); 
sqlDF.show();
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
Saiba mais
Esse �uxo é dividido em lotes, representado como uma sequência de RDDs, que são processados usando algoritmos
complexos expressos com funções de alto nível (por exemplo, as funções citadas na Seção 2), algoritmos de aprendizado de
máquina da biblioteca MLlib ou algoritmos de processamento de grafos da biblioteca GraphX.
Finalmente, os dados processados podem ser enviados para sistemas de arquivos, bancos de dados e painéis dinâmicos.
Os programas Spark Streaming podem ser escritos em Scala, Java ou Python. Eles devem conter a seguinte estrutura:
Criar um objeto SparkConf;
Criar um objeto StreamContext, a partir do objeto SparkConf, que é o principal ponto de entrada para todas as
funcionalidades de streaming. Ao criar esse objeto, internamente um SparkContext é criado;
Criar um Dstream, a partir do objeto StreamContext, para receber o �uxo de dados de streaming de uma fonte;
De�nir as operações que devem ser realizadas no DStream;
Iniciar o Dstream;
Aguardar até que o processamento seja interrompido manualmente ou devido a qualquer erro.
/
A seguir, veja um exemplode programa Java que recebe linhas de texto de uma fonte TCP (Transmission Control Protocol)
e retorna a quantidade de vezes que cada palavra se repetiu. Para tal, foi criado um Dstream para receber um �uxo de
dados local com dois threads de execução e um intervalo de lote de 1 segundo para receber dados de streaming de uma
fonte TCP, especi�cada com nome de host localhost e porta 9999.
Cada registro s �uxo é uma linha de texto dividida em várias palavras através da função �atMap e, em seguida, as palavras
foram contadas através das funções mapToPair e reduceByKey.
import org.apache.spark.*; 
import org.apache.spark.api.java.function.*; 
import org.apache.spark.streaming.*; 
import org.apache.spark.streaming.api.java.*; 
import scala.Tuple2;
// Criar um objeto SparkConf om dois threads de execução 
SparkConf conf = new 
SparkConf().setMaster("local[2]").setAppName("Exemplo Spark Streaming");
// Cria um objeto StreamContext com duração de 1 segundo 
JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(1));
// Cria um DStream que recebe dados do localhost na porta 9999 
JavaReceiverInputDStream < String > lines = jssc.socketTextStream("localhost", 9999);
// Cria um novo Dstream resultante da transformação do �uxo de dados em palavras 
JavaDStream < String > words = lines.�atMap(x -> Arrays.asList(x.split(" ")).iterator());
// Cria um novo Dstream resultante da transformação das palavras em pares palavra e valor 1 
JavaPairDStream < String, Integer > pairs = words.mapToPair(s -> new Tuple2<>(s, 1));
// Usa a função reduceByKey para contar as palavras 
JavaPairDStream < String, Integer > wordCounts = pairs.reduceByKey((i1, i2) -> i1 + i2);
// Exibe cada palavra e a quantidade com que ela se repete no console 
wordCounts.print();
//Iniciar o Dstream para receber dados de uma fonte TCP 
jssc.start();
// Aguardar até que o processamento seja interrompido 
jssc.awaitTermination();
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
MLlib
A biblioteca de aprendizado de máquina (Machine Learning Library- MLlib) do Spark foi construída com o objetivo de tornar
o aprendizado de máquina prático, escalonável e fácil. A MLlib contém um conjunto de algoritmos e utilitários comuns de
estatística e de aprendizado de máquina, todos projetados para funcionar em um cluster. Em alto nível, a biblioteca
oferece:
/
Algoritmos de aprendizado de máquina (AM) de classi�cação, regressão, agrupamento e �ltragem colaborativa;
Funcionalidades para caracterização dos dados para processamento, tais como extração, transformação, redução de
dimensionalidade e seleção;
Ferramentas para construir, avaliar e ajustar pipelines de aprendizado de máquina;
Operações para persistência de informações que permitem salvar e carregar os algoritmos, os modelos e os
pipelines;
Utilitários estatísticos e de tratamento de dados.
Todas essas funcionalidades foram desenvolvidas para serem usadas em um sistema de armazenamento de dados
distribuídos com processamento paralelo, tornando possível analisar conjuntos grandes de dados. Nesse processo, os
algoritmos de AM têm papel fundamental para realizar previsões ou identi�car padrões para tomar decisões com base em
dados históricos.
Comentário
As análises, em geral, iniciam com a de�nição e extração de um conjunto de características que será usado para alimentar o
algoritmo de AM. No caso das análises prescritivas, o conjunto de dados tipicamente é separado em dois grupos: Base de
dados de treinamento e base de dados de teste.
A base de dados de treinamento é processada pelo algoritmo de AM para que ele identi�que padrões e gere um modelo
prescritivo. Posteriormente, esse modelo é testado através da submissão da base de dados de teste ao modelo e
comparação do resultado real com os resultados produzidos pelo modelo. Isso permite avaliar a precisão do modelo e
ajustá-lo conforme a necessidade.
Para realizar esse tipo de análise, a biblioteca MLlib disponibiliza uma série de algoritmos de regressão e de classi�cação
para treinar os dados de acordo com suas características e requisitos de análise.
Exemplo
Alguns exemplos de algoritmos são: DecisionTree, RandomForest, Gradient-boosted tree (GBT) e LinearSVC.
Os algoritmos de AM também são utilizados para análise descritiva, cuja meta é explorar ou descrever um conjunto de
dados. Uma tarefa descritiva de agrupamento de dados, por exemplo, tem por meta encontrar semelhanças entre os
dados e rotulá-los em grupos. Para tal, a biblioteca MLlib dispõe de vários algoritmos de clusterização, tais como: KMeans,
BisectingKMeans, GaussianMixture e PowerIterationClustering.
Para exempli�car o uso da biblioteca MLlib, utilizamos um arquivo contendo características dos clientes de uma Livraria
Virtual para agrupá-los em dois grupos. Para tal, foi desenvolvido um programa Java e utilizado o algoritmo de
agrupamento KMeans, conforme extrato do código abaixo:
import org.apache.spark.ml.clustering.KMeansModel; 
import org.apache.spark.ml.clustering.KMeans; 
import org.apache.spark.ml.evaluation.ClusteringEvaluator; 
/
import org.apache.spark.ml.linalg.Vector; 
import org.apache.spark.sql.Dataset; 
import org.apache.spark.sql.Row;
// Carrega os dados de um arquivo txt em um DataFrame 
Dataset dataset = spark.read().format("libsvm").load("cliente.txt");
// Con�gura o algoritmo KMeans para separar a base de dados em 2 grupos 
KMeans kmeans = new KMeans().setK(2).setSeed(1L);
//Submete a base de dados ao algoritmo 
KMeansModel model = kmeans.�t(dataset);
// Realiza as predições 
Dataset predictions = model.transform(dataset);
// Mostra o resultado 
Vector[] centers = model.clusterCenters(); 
System.out.println("Cluster Centers: "); 
for (Vector center: centers) { System.out.println(center); }
GraphX
A biblioteca GraphX cria e manipula grafos através de computação paralela. O grafo é uma estrutura de dados composta
por vértices interligados por meios de arestas, utilizada para modelar relação entre objetos. Adicionalmente, os vértices e
arestas podem ter propriedades.
O GraphX simpli�ca as tarefas de análise de grafos, fornece a capacidade
de realizar operações em grafos direcionados e com propriedades
anexadas a cada vértice e aresta. Também estende o RDD para
representar um grafo utilizando um objeto chamado Graph composto de
duas coleções de RDDs, uma para representar os vértices e outra para
representar as arestas.
Cada vértice tem um identi�cador único e um conjunto de propriedades, representados como uma coleção de dados
paralelizados (parallelize). As arestas têm identi�cadores de vértice de origem e destino e propriedades que também são
representadas como uma coleção de dados paralelizados.
Para exempli�car o uso da biblioteca GraphX, vamos criar um grafo para representar os relacionamentos entre pessoas.
Os vértices são as pessoas e a arestas representam as relações que podem ser do tipo amizade, trabalho e casamento,
conforme código a seguir construído diretamente no shell.
/
import org.apache.spark._ 
import org.apache.spark.graphx._ 
import org.apache.spark.rdd.RDD
// Ao abrir o shell um SparkContext é construído automaticamente 
val sc: SparkContext
// Cria os vértices 
val pessoas: RDD[(VertexId, String))] = sc.parallelize(Seq((1L,"Amanda"), (2L, "Bruno"), (3L,"Carlos"), (4L, "Henrique"), (5L,
"Juliana")))
// Cria as arestas 
val relacionamentos: RDD[Edge[String]] = sc.parallelize(Seq(Edge(1L, 4L, "casamento"), Edge(2L, 3L, "trabalho"), Edge(4L, 5L,
"amizade"), Edge(4L, 5L, "trabalho")))
// Constrói o grá�co 
val grafoPessoasRelacionamento = Graph(pessoas, relacionamentos)
O código inicia com a importação das bibliotecas necessárias para criar um grafo. Posteriormente, os vértices para
representar as pessoas Amanda, Bruno, Carlos, Henrique e Juliana foram criados através do RDD pessoas.
A relação de casamento entre Amanda e Henrique, de trabalho entre Bruno e Carlos, de amizade e de trabalho entre
Henrique e Juliana foram representadas através do RDD relacionamentos.Por �m, esses vértices e arestas foram
utilizados para criar o grafo grafoPessoasRelacionamento.
Saiba mais
Os grafos têm a característica de serem imutáveis, distribuídos e tolerantes a falhas. As alterações nos valores ou na
estrutura do grá�co são realizadas e produzem um novo grá�co com as alterações. O grafo é particionado entre os
executores usando uma variedade de heurísticas de particionamento de vértice. Cada partição do grafo pode ser recriada em
uma máquina diferente no caso de uma falha.
O GraphX tem vários tipos de operações para grafo, tais como:
Informações sobre o grafo
numEdges, numVertices, inDegrees, outDegrees, degrees.

Visualização de grafo como coleções
vertices, edges, triplets.
/

Funções para trabalhar com grafo em cache
persist, cache, unpersistVertices

Transformações de vértices, arestas e propriedades
mapVertices, mapEdges, mapTriplets.

Transformações na estrutura do grafo
reverse, subgraph, mask, groupEdges, joinVertices, outerJoinVertices.

Algoritmos para grafo
pageRank, connectedComponents, triangleCount, stronglyConnectedComponents.

Diante do exposto, podemos perceber que a arquitetura e o conjunto de componentes do Spark possibilitam realizar
captura, armazenamento, preparação e análise de grande volume de dados com agilidade, e podem ser muito bem
aproveitados em projetos de Big Data que necessitem de processamento em tempo real.
Atenção! Aqui existe uma videoaula, acesso pelo conteúdo online
/
Atividade
O framework utilizado para processamento em tempo real, considerado uma evolução do Hadoop MapReduce, denomina-
se:
a) Sqoop
b) Spark
c) Flume
d) Storm
e) MLlib
A arquitetura do Apache Spark é composta por nós mestre e escravo que são respectivamente denominados:
a) Driver program e worker node;
b) Main node e slave node;
c) Main node e worker node;
d) Driver program e NodeManager;
e) ApplicationMaster e NodeManager.
Uma das principais característica do Spark consiste em armazenar os dados na memória em cache, eliminando assim as
escritas intermediárias custosas em disco. O nome dado ao conjunto de dados distribuídos utilizado pelo Spark para
armazenar dados na memória é:
a) RAM
b) DAG
c) RDM
d) SQL
e) RDD
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Referências
/
BENGFOR, B.; KIM, J. Analítica de dados com Hadoop: Uma introdução para cientistas de dados. 1.ed. São Paulo: Novatec,
2016.
Próxima aula
Explore mais
Leia a reportagem da revista exame “Disney+ pode ocupar segundo lugar no streaming do Brasil“, de 25/10/2020, que
mostra a importância do processamento streaming no mercado.
Veja exemplo de utilização de aprendizado de máquina lendo a reportagem da BBC Brasil “Como a Inteligência Arti�cial
detecta sinais de doenças que humanos não podem enxergar” de 15/03/2019.