FRAMEWORK

DE BIG DATA

Fabiano Berlinck Neumann

Aplicações simples
utilizando frameworks
de big data
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:

 Explicar como funciona o MapReduce.

 Aplicar, no Hadoop, uma aplicação que utiliza MapReduce.
 Executar, no Spark, uma aplicação que utiliza MapReduce.

Introdução
Big data é um termo muito utilizado tanto por profissionais de TI quanto
por empresários: alguns em busca de especialização em áreas mais avan-
çadas da tecnologia; outros procurando obter vantagens competitivas
para as suas empresas com a ajuda de profissionais de TI. Isso ocorre pela
possibilidade de diminuição de custos; pela aquisição de informações e
conhecimentos adequados para uma melhor tomada de decisão; pelo
aumento na lucratividade e pela possibilidade de crescimento do negócio;
ou, em alguns casos, por serem os profissionais capazes de garantir a
sobrevivência da empresa.
Nesse contexto, o termo é utilizado para representar uma quantidade
de dados tão grande a ponto de tornar o seu processamento inviável em
métodos tradicionais de processamento de dados, o que gerou interesse
da comunidade em contribuir com a manutenção e a evolução dos
frameworks de big data. Suas principais aplicações são de código livre e
contam com o apoio de grandes empresas, que acabam por utilizá-las
no dia a dia dos seus negócios.
Neste capítulo, você conhecerá aplicações simples, utilizando fra-
meworks de big data, por meio de conceitos do MapReduce e de um
exemplo de aplicação de contagem de palavras que utiliza o MapReduce
tanto no Apache Hadoop quanto no Apache Spark.
2 Aplicações simples utilizando frameworks de big data

1 Funcionamento do MapReduce
Conforme apresentado no artigo da Google, por Dean e Ghemawat (2004),
o MapReduce é um modelo de programação e implementação associada a
esse modelo, que permite o processamento e a geração de grandes conjuntos
de dados. Nele, os usuários especificam uma função de mapeamento para
processar um par chave-valor, o que gera um conjunto de pares chave-valor
intermediários, além de uma função de redução para mesclar os valores in-
termediários associados à mesma chave intermediária. Além disso, muitas
das tarefas do mundo real são expressáveis nesse modelo.
Segundo a The Apache Software Foundation (2019), o MapReduce é um
framework de software para a fácil escrita de aplicações que processam
uma vasta quantidade de dados em paralelo, com conjuntos que podem
chegar a vários terabytes, em clusters que podem alcançar milhares de nós,
compostos por máquinas comuns, de maneira confiável e com tolerância
a falhas.
Conforme pode ser observado na Figura 1, no processamento paralelo
e distribuído tradicional, antes da existência do MapReduce, o conjunto de
dados era dividido em partes menores ou blocos para que fossem armazena-
dos em máquinas diferentes. Em seguida, era realizada a busca de alguma
característica em cada parte armazenada por meio do comando grep,
que permite realizar a busca de palavras em vários arquivos diferentes,
de forma que cada uma retorna seus próprios resultados nas máquinas
correspondentes, para que todos sejam concatenados por meio do comando
cat, que pode ser utilizado para a criação de arquivo, concatenação e
apresentação de conteúdo na tela, gerando como resultado final o conjunto
dos resultados.

grep
Dados divididos Resultados
grep
Dados divididos Resultados cat Todos os
Big Data grep resultados
Dados divididos Resultados
grep
Dados divididos Resultados

Figura 1. Processamento paralelo e distribuído anterior à existência do MapReduce.

Fonte: Adaptada de Kiran (2020).
 Aplicações simples utilizando frameworks de big data 3

Os principais desafios associados a essa abordagem – que precisam ser cuidados

individualmente – têm relação com: problemas em caminhos críticos, quando uma
das máquinas atrasa a tarefa e gera atraso em todo o processamento; problemas de
confiabilidade, causados pelo desafio de gerenciamento de uma máquina que falha
durante a execução de uma tarefa; problemas de divisão de tarefas, que podem
gerar sobrecarga ou subutilização das máquinas; problemas de falha de um nó,
que podem impossibilitar a geração do resultado final; desafios de agregação,
para que os dados possam ser concatenados para gerar o resultado final.
Com o MapReduce, esses desafios são superados, tendo em vista que ele
permite computação paralela e distribuída sem a necessidade de cuidar de
problemas como confiabilidade, tolerância a falhas, entre outros, o que gera
flexibilidade aos desenvolvedores para criarem as aplicações de big data
focando apenas na abstração do problema que a aplicação se propõe a resolver,
sem a preocupação com o paralelismo ou a distribuição dos dados.
De acordo com a The Apache Software Foundation (2019), no MapReduce,
um Job divide o conjunto de dados em partes menores independentes, que são
processadas por tarefas de mapeamento e executadas paralelamente. Nessa fase,
são produzidos pares com chave-valor. Em seguida, acontece a classificação
das saídas das tarefas de mapeamento apresentadas como funções Map(),
que são inseridas nas tarefas de redução, descritas como funções Reduce(),
que agregam os pares em um conjunto menor de chave-valor para gerar o
resultado final. Esse processo pode ser observado na Figura 2.

Figura 2. Processamento paralelo e distribuído com o MapReduce.

Fonte: Sharda, Delen e Turban (2019, p. 453).
4 Aplicações simples utilizando frameworks de big data

No Hadoop, de modo geral, os dados de entrada e as saídas são armaze-

nados em um sistema de arquivos, mesmo que venham a ser reprocessados
posteriormente. Todavia, no Spark, os dados podem ser mantidos em memória
para os casos de processamento iterativo. Em ambos os casos, o framework
fica responsável pelo agendamento e pelo monitoramento das tarefas, bem
como pelas novas tentativas de execução das tarefas que falharem.

Interfaces para utilização do Hadoop MapReduce

Como observado na Figura 2, duas das principais interfaces implementadas
para utilizar o MapReduce são as interfaces Mapper e Reducer, que dispo-
nibilizam os métodos map() e reduce(). Outras interfaces que fazem parte
do conjunto das principais interfaces são Counter, Job, Partitioner,
InputFormat e OutputFormat.
Segundo Coulouris et al. (2013), a função map() é responsável por receber
um conjunto de pares chave-valor como entrada e produzir um conjunto de
pares chave-valor intermediários como saída. No caso de contagem de palavras
em um texto, com diversas linhas e várias palavras em cada linha, essa é a
função que separará cada palavra do texto e atribuirá um valor para cada uma
delas, gerando os pares chave-valor intermediários.
Em se tratando da classe Reducer, os valores intermediários de saída da
função map() são classificados utilizando o valor da chave, de forma que
todos os resultados intermediários fiquem ordenados pela chave intermediária
e que sejam decompostos em grupos, para que sejam passados como entrada
para instâncias da classe Reducer. Dessa forma, a função reduce() tem
como responsabilidade realizar o processamento dessa entrada para produzir
uma lista de valores para cada um dos grupos, de forma que fiquem prontos
para serem combinados em um índice completo.
A classe Partitioner controla a divisão das chaves da saída do ma-
peamento intermediário, chaves — ou seu subconjunto — que são utilizadas
para derivar a partição, bem como definir para qual tarefa de redução a chave
intermediária é enviada para redução. O número total de partições é o mesmo
de tarefas de redução.
No entanto, a classe Job representa o trabalho do MapReduce. Por meio
da sua interface, o usuário descreve o trabalho do MapReduce, que deve ser
executado no Hadoop, e com essa classe, geralmente, são especificadas as
implementações das classes Mapper, Reducer, Partitioner, Inpu-
tFormat e OutputFormat. Como o MapReduce opera de forma exclusiva
com pares chave-valor, as classes chave e valor precisam ser serializáveis e,
 Aplicações simples utilizando frameworks de big data 5

por consequência, implementar a interface Writable. Além disso, as classes

chave precisam implementar a interface WritableComparable para facilitar
a sua classificação.

Conceito do contador de palavras com MapReduce

Antes da apresentação da implementação com o MapReduce no Hadoop e no
Spark, é importante entender o domínio do problema que será abordado. Nesse
caso, será um contador que separará cada uma das palavras de um arquivo
texto e informará o número de ocorrências para cada uma delas ao longo do
arquivo. Com isso, será possível visualizar o funcionamento do MapReduce
por meio de um exemplo, que será implementado nos próximos tópicos, a
partir de um arquivo de entrada que contém as seguintes palavras: ciência
computação dados computação dados nuvem ciência dados dados.
Como é possível observar na Figura 3, no primeiro passo, o arquivo é divido
em três partes: a primeira, ciência computação dados; a segunda, computação
dados nuvem; e a terceira, ciência dados dados. Nessa fase, são formadas as
primeiras saídas intermediárias de chave-valor, ou C1, V1. Em um segundo
momento, é realizado o mapeamento das palavras, no qual acontece a sepa-
ração delas, e o valor 1 é atribuído para cada uma, formando a segunda saída
intermediária de chave-valor, ou C2, V2. Em seguida, acontece a combinação
das palavras, adicionando o valor 1 na lista de valores para cada chave. Na
sequência, ocorre a redução, que soma o valor 1 da lista para gerar a saída
final e, por consequência, o último par chave-valor, ou C3, V3.

Figura 3. Processamento do exemplo do contador de palavras com o MapReduce.

Fonte: Adaptada de Kiran (2020).

Com isso, os tipos de entradas e saídas de cada etapa de uma tarefa no

MapReduce podem ser observados no seguinte esquema:

C1, V1 → mapeamento → C2, V2 → combinação → C2, V2 → redução → C3, V3

6 Aplicações simples utilizando frameworks de big data

A seguir, é possível observar a implementação do exemplo do contador de

palavras utilizando o Hadoop MapReduce em Java.

2 Aplicação com o Hadoop MapReduce

De acordo com a The Apache Software Foundation (2019), na documentação
do framework Hadoop, para que seja possível rodar as aplicações com o Ha-
doop MapReduce, é necessário que o Hadoop esteja instalado, configurado e
rodando, seja por meio da configuração em um único nó, geralmente utilizado
para questões de aprendizado, ou por meio da configuração para clusters, que
possibilita trabalhar com clusters grandes e distribuídos.
Para programar a aplicação do contador de palavras no Hadoop, é neces-
sário criar três classes: a de mapeamento WordCountMapper, a de redução
WordCountReducer e a principal WordCountDriver, que chama as duas
primeiras, além de ter o método main, que configura o Job informando as classes
WordCountMapper e WordCountReducer e chama a função de execução da
aplicação. A primeira classe é a WordCountMapper, que realiza o mapeamento e
herda da classe Mapper, conforme é possível observar no código da classe a seguir:

import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class WordCountMapper extends Mapper<LongWritable,

Text, Text, IntWritable>
{
private final static IntWritable one = new IntWritable(1);
private Text wordObject = new Text();

@Override
public void map(LongWritable key, Text value, Context context)
throws IOException, InterruptedException {

String line = value.toString();

for (String word : line.split("\\W+")) {
if (word.length() > 0) {
 Aplicações simples utilizando frameworks de big data 7

wordObject.set(word);
context.write(wordObject, one);
}
}
}
}

Nesse código, a variável line recebe o valor do parâmetro word do mé-

todo map, convertido para String, para ser dividido em palavras que serão
armazenadas individualmente. Dessa forma, é possível executar um loop, que
verifica se o input contém mais palavras. No trecho de código a seguir, pode ser
observada a segunda classe, que realiza a redução e herda da classe Reducer:

import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class WordCountReducer extends Reducer<Text, IntWrita-

ble, Text, IntWritable>
{

private IntWritable wordCountWritable = new IntWritable();

@Override
public void reduce(Text key, Iterable<IntWritable> values,
Context context)
throws IOException, InterruptedException {
int wordCount = 0;
for (IntWritable value : values) {
wordCount += value.get();
}
wordCountWritable.set(wordCount);
context.write(key, wordCountWritable);
}
}

Essa classe inicia a variável wordCount com o valor 0, para, então,

executar o loop, que soma cada valor do vetor valores na variável soma.
Quando o loop termina, é escrito no contexto o valor da variável chave e a
8 Aplicações simples utilizando frameworks de big data

soma dos valores da chave. A terceira classe, que engloba as duas anteriores
e contém o método main para executar o código delas, pode ser observada
a seguir:

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class WordCountDriver extends Configured implements

Tool {
public int run(String[] args) throws Exception {
if (args.length != 2) {
System.out.printf("Usage: %s [generic options] <inputdir>
<outputdir>\n", getClass().getSimpleName());
return -1;
}

Job job = Job.getInstance(getConf(), "Word Count");

job.setJarByClass(WordCountDriver.class);
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
boolean success = job.waitForCompletion(true);
return success ? 0 : 1;
}

public static void main(String[] args) throws Exception {

 Aplicações simples utilizando frameworks de big data 9

int exitCode = ToolRunner.run(new Configuration(), new

WordCountDriver(), args);
System.exit(exitCode);
}
}

Nessa classe, os códigos das classes WordCountMapper e WordCoun-

tReducer são omitidos por já terem sido apresentados separadamente. Por
conter o método main, é a classe WordCountDriver que será chamada
para executar a aplicação. Nesse método, são criadas as variáveis de con-
figuração do Job e, em seguida, ele é executado. No Job, são informadas
as classes para gerar o arquivo executável, ou jar, bem como a classe de
mapeamento, de redução, de saída da chave e do valor, e do formato de
saída e de entrada.
Assim como no comando de execução da aplicação, são passados os parâ-
metros que informam qual é o arquivo de entrada e de saída, respectivamente,
bem como as demais variáveis de configuração. Em seguida, o Job é executado
pela função waitForCompletion, que representa a conclusão quando
retorna 1, fechando o sistema.
Nesse código, o arquivo de entrada será enviado ao Hadoop Distributed
Fyle System, do inglês, (HDFS), assim como o resultado, que também será
salvo no HDFS. Para executar essa aplicação no Hadoop, é necessário seguir
o passo a passo descrito a seguir.

Exemplo de execução do contador de palavras no Hadoop usando uma máquina

virtual da Cloudera
Requisitos:
1. Faça o download do Virtual box: https://www.virtualbox.org/wiki/Downloads
2. Faça o download da Cloudera CDH pelo site www.cloudera.com, ou use a versão
disponível neste link: https://downloads.cloudera.com/demo_vm/virtualbox/
cloudera-quickstart-vm-5.12.0-0-virtualbox.zip
3. Instale o Virtual box e inicie a VM da Cloudera
4. Já logado na VM, faça o download do código fonte, disponível na seção Conteúdo
do Livro da Unidade de Aprendizagem
5. Abra o shell do Linux, vá até a pasta onde fez o download e descompacte:
$ unzip Codigo.zip /contador
10 Aplicações simples utilizando frameworks de big data

6. Crie uma pasta no Hadoop com o nome contador:

$ hdfs dfs -mkdir /contador
7. Faça o upload do arquivo de texto para o Hadoop:
$ hdfs dfs -put ~/Downloads/contador/livro.txt /contador
8. Faça login como root:
$ sudo su
9. Acesse a pasta que contém o exemplo do Hadoop:
$ cd ~/Downloads/contador/Hadoop/
10. Compile o código Java para criar os arquivos.class:
$ javac -cp /usr/lib/hadoop/*:/usr/lib/hadoop-mapreduce/*
*.java
11. Liste para verificar se os arquivos foram criados:
$ ls
12. Crie o arquivo jar:
$ jar cvf wc.jar *.class
13. Execute o programa:
$ hadoop jar wc.jar WordCountDriver -D mapreduce.job.re-
duces=2 /contador/livro.txt wordcount
14. Verifique o conteúdo do diretório “wordcount” com o resultado da execução
$ hadoop fs -ls wordcount

Resultado:
Found 3 items
-rw-r--r-- 1 root supergroup 0 2020-10-16 12:40 wordcount/_SUCCESS
-rw-r--r-- 1 root supergroup 139484 2020-10-16 12:40 wordcount/part-r-00000
-rw-r--r-- 1 root supergroup 139028 2020-10-16 12:40 wordcount/part-r-00001
15. Inspecione o conteúdo dos arquivos
$ hadoop fs -tail wordcount/part-r-00000
$ hadoop fs -tail wordcount/part-r-00001

Resultado no arquivo part-r-00000:

7
workman 5
workmanship 1
workmen 3
worldlings 2
worldly 15
worlds 4
worm 38
…
 Aplicações simples utilizando frameworks de big data 11

3 Aplicação com o MapReduce no Spark

Nesse exemplo, o projeto utiliza o Maven para adicionar as dependências,
portanto, não é necessário instalar e configurar o Apache Spark, pois o Maven
fará o download das dependências do projeto. Entretanto, é necessário utilizar
o arquivo pom.xml, que apresenta essas dependências e é descrito no tutorial
após a explicação do código em Java.
No caso da criação da aplicação que utiliza o mapeamento e a redução
com o Spark, é necessário criar apenas a classe principal WordCounter, que
contém o método wordCount e o método main para chamar a execução do
primeiro método, conforme pode ser observado no código a seguir:

package com.Sagah;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.Arrays;

public class WordCounter {

private static void wordCount(String fileName) {

SparkConf sparkConf = new SparkConf().setMaster("local").

setAppName("Contador");

JavaSparkContext sparkContext = new

JavaSparkContext(sparkConf);

JavaRDD<String> inputFile = sparkContext.textFile(fileName);

JavaRDD<String> wordsFromFile = inputFile.flatMap(content

-> Arrays.asList(content.split(" ")));

JavaPairRDD countData = wordsFromFile.mapToPair(t ->

new Tuple2(t, 1)).reduceByKey((x, y) -> (int) x + (int) y);
12 Aplicações simples utilizando frameworks de big data

countData.saveAsTextFile("CountData");
}

public static void main(String[] args) {

if (args.length == 0) {
System.out.println("Sem arquivo para contar.");
System.exit(0);
}

wordCount(args[0]);
}
}

Nesse código, é possível observar a configuração do Spark, no qual o

nó mestre é definido como “local”, e o nome da aplicação é definido
como “Contador”. Em seguida, é declarada a variável contexto do
tipo JavaSparkContext e instanciada a partir da configuração anterior.
A variável inputFile declarada com o tipo JavaRDD é instanciada a
partir do comando textFile do contexto, e a variável wordsFromFile
recebe as palavras contidas no arquivo de entrada a partir da função
flatMap, que recebe o conteúdo com as palavras separadas por espaço
em branco.
Em seguida, são realizadas as operações de transformação do Spark,
em que são realizados o mapeamento das palavras por meio do método
mapToPair e a redução do resultado do mapeamento por meio da função
reduceByKey, armazenando o resultado na variável countData do tipo
JavaPairRDD. A variável CountData é utilizada, então, para salvar o
arquivo de texto do diretório informado a partir do método saveAsTex-
tFile, que é uma das operações de ação do framework. A aplicação criará
uma pasta com o nome CountData e, dentro dela, estarão os arquivos que
indicam que a aplicação foi executada com sucesso, bem como o respectivo
resultado. Para executar a aplicação no Spark, é necessário seguir o tutorial
do exemplo a seguir.
 Aplicações simples utilizando frameworks de big data 13

Exemplo de execução do programa Spark usando Linux

Para seguir esse tutorial, você precisa ter acesso de administrador em um computador
com Linux. Para os testes, foi utilizado o Ubuntu 20.
1. Instale os requisitos: Maven, Java JDK, Scala, Git:
$ sudo apt install maven default-jdk scala git -y
2. Crie o projeto Maven em uma pasta de sua preferência:
$ mvn archetype:generate -DgroupId=com.Sagah
-DartifactId=Spark-WordCount -DarchetypeArtifactId=maven-
-archetype-quickstart -DinteractiveMode=false
3. Faça download do projeto Spark na página da UA, junto ao capítulo do Livro. Subs-
titua os arquivos criados pelos arquivos baixados. Coloque os arquivos pom.xml
e livro.txt na raiz da pasta (pasta Spark-WordCount). Coloque o arquivo
WordCounter.java no diretório Spark-WordCount/src/main/java/com/
Sagah, e delete o arquivo .java que estiver lá.
4. Acesse o diretório onde tem o arquivo pom.xml e compile usando Maven:
$ cd Spark-WordCount
$ mvn compile
5. Execute o programa com o arquivo de texto “livro.txt” de exemplo:
$ mvn exec:java -Dexec.mainClass=com.Sagah.WordCounter
-Dexec.args="livro.txt"
6. Aguarde o término da execução e verifique se foi criada a pasta Countdata:
$ ls

Resultado esperado:
CountData livro.txt pom.xml src target
7. Acesse a pasta e liste o resultado:
$ cd CountData
$ ls

_SUCCESS part-00000
8. Veja o resultado da execução no arquivo part-00000:
$ cat part-00000
14 Aplicações simples utilizando frameworks de big data

Resultado esperado:
....
(memorable,4)
(scratching,1)
(rip,2)
(quired,1)
(vine,7)
(heart-sore,2)
(Able,2)
(Presumptuous,3)
(subsidies,1)
(absolutely,2)

No Spark, as linguagens de programação mais utilizadas são Python, Scala

e Java. A seguir, é possível observar um exemplo do contador de palavras
utilizando a biblioteca pyspark, usando a ferramenta Google Colab (O QUE
É O COLABORATORY?, [2020]).

Tutorial Spark com Python usando o Google Colab – Baseado em Kwon (c2020):
1. Faça login em https://colab.research.google.com
2. Clique em upload e faça o upload do arquivo WordCountPySpark.ipynb
3. Execute célula por célula
4. Quando solicitar o upload de um arquivo para processamento, use o arquivo
utilizado anteriormente ("livro.txt")

# Instalar o Spark
!apt-get install openjdk-8-jdk-headless -qq > /dev/null
!wget -q https://downloads.apache.org/spark/spark-3.0.0/
spark-3.0.0-bin-hadoop3.2.tgz
!tar xf spark-3.0.0-bin-hadoop3.2.tgz
!pip install -q findspark
 Aplicações simples utilizando frameworks de big data 15

# Configurar as variáveis de ambiente

import os
os.environ["JAVA _ HOME"] = "/usr/lib/jvm/
java-8-openjdk-amd64"
os.environ["SPARK _ HOME"] = "/content/
spark-3.0.0-bin-hadoop3.2"

# Testar a instalação
import findspark
findspark.init()
from pyspark.sql import SparkSession
spark = SparkSession.builder.master("local[*]").
getOrCreate()

# Ler os dados de um arquivo txt

from google.colab import files
uploaded = files.upload()

for fn in uploaded.keys():
print('Arquivo "{name}" de tamanho {length} bytes foi
adicionado.'.format(
name=fn, length=len(uploaded[fn]))

from pyspark import SparkContext, SparkConf

# Cria a aplicação e instacia o SparkContext

conf = SparkConf().setAppName("ContaPalavras")
sc = SparkContext.getOrCreate()

# Cria o RDD com o conteúdo do livro.txt

conteudoRDD = sc.textFile("livro.txt")

# Elimina as linha em branco

remove _ linha _ vazia = conteudoRDD.filter(lambda x:
len(x) > 0)
16 Aplicações simples utilizando frameworks de big data

# Separa as palavras usando o espaço em branco entre

# elas
palavras = remove _ linha _ vazia.flatMap(lambda x:
x.split(' '))

# Map-Reduce da contagem das palavras

contapalavras = palavras.map(lambda x:(x,1)) \
.reduceByKey(lambda x, y: x + y) \
.map(lambda x: (x[1], x[0])).sortByKey(False)

# Imprime o resultado
for palavra in contapalavras.collect():
print(palavra)

Resultado esperado, se você utilizar o mesmo arquivo usado nas aplicações

anteriores (livro.txt):

A saída de streaming foi truncada nas últimas 5000

linhas.
(1, "midwife's")
(1, "justices'")
(1, 'Wenches')
(1, 'dear-a')
(1, "new'st")

Dessa forma, a partir do entendimento do funcionamento do MapReduce

e das funções de mapeamento e redução, que fazem parte do conjunto mí-
nimo de funções de uma aplicação que utiliza o MapReduce, bem como do
exemplo de uma aplicação MapReduce para a contagem de palavras de um
conjunto de dados, tanto no Hadoop quanto no Spark, é possível dar início ao
desenvolvimento de outras aplicações que utilizam o framework, de forma a
praticar os conceitos e aprofundar os conhecimentos que são cada dia mais
valorizados pelo mercado.
 Aplicações simples utilizando frameworks de big data 17

COULOURIS, G. et al. Sistemas distribuídos: conceitos e projetos. 5. ed. Porto Alegre:

Bookman, 2013.
DEAN, J.; GHEMAWAT, S. MapReduce: simplified data processing on large clusters.
In: SYMPOSIUM ON OPERATING SYSTEM DESIGN AND IMPLEMENTION, 6., 2004, San
Francisco. Anais [...]. San Francisco: USENIX, 2004. Disponível em: https://static.googleu-
sercontent.com/media/research.google.com/pt-BR//archive/mapreduce-osdi04.pdf.
Acesso em: 28 out. 2020.
KIRAN, R. MapReduce tutorial: fundamentals of MapReduce with MapReduce example.
edureka!, 2020. Disponível em: https://www.edureka.co/blog/mapreduce-tutorial/.
Acesso em: 28 out. 2020.
KWON, H. wordcount.py. GitHub, c2020. Disponível em: https://github.com/apache/
spark/blob/master/examples/src/main/python/wordcount.py. Acesso em: 28 out. 2020.
O QUE É O COLABORATORY?. Google Research, [2020]. Disponível em: https://colab.
research.google.com/notebooks/intro.ipynb. Acesso em: 28 out. 2020.
SHARDA, R.; DELEN, D.; TURBAN, E. Business intelligence e análise de dados para gestão
do negócio. 4. ed. Porto Alegre: Bookman, 2019.
THE APACHE SOFTWARE FUNDATION. MapReduce tutorial. Apache Hadoop, c2019.
Disponível em: https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/
hadoop-mapreduce-client-core/MapReduceTutorial.html. Acesso em: 28 out. 2020.

Os links para sites da web fornecidos neste livro foram todos testados, e seu funciona-
mento foi comprovado no momento da publicação do material. No entanto, a rede
é extremamente dinâmica; suas páginas estão constantemente mudando de local
e conteúdo. Assim, os editores declaram não ter qualquer responsabilidade sobre
qualidade, precisão ou integralidade das informações referidas em tais links.