Introdução
Nas ruínas antigas de uma civilização perdida, um grupo de exploradores modernos tropeçou em um templo escondido dedicado ao deus do conhecimento e da sabedoria. As paredes do templo eram adornadas com hieróglifos intrincados, guardando os segredos de um sistema avançado de processamento de dados usado pelos antigos sacerdotes.
Um dos exploradores, um engenheiro Hadoop experiente, assumiu o papel de Sumo Sacerdote, decifrando os hieróglifos e desvendando os mistérios do templo. O objetivo era reconstruir o antigo sistema de processamento de dados, aproveitando o poder do cache distribuído do Hadoop para processar eficientemente grandes conjuntos de dados, assim como os antigos sacerdotes faziam séculos atrás.
Prepare os Dados e o Código
Nesta etapa, configuraremos os arquivos e o código necessários para simular o antigo sistema de processamento de dados.
Primeiro, altere o usuário para hadoop e, em seguida, mude para o diretório home do usuário hadoop:
su - hadoop
Crie um novo diretório chamado distributed-cache-lab e navegue até ele:
mkdir distributed-cache-lab
cd distributed-cache-lab
Em seguida, crie um arquivo de texto chamado ancient-texts.txt com o seguinte conteúdo:
The wisdom of the ages is eternal.
Knowledge is the path to enlightenment.
Embrace the mysteries of the universe.
Este arquivo representará os textos antigos que queremos processar.
Agora, crie um arquivo Java chamado AncientTextAnalyzer.java com o seguinte código:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
public class AncientTextAnalyzer {
public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> {
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
StringTokenizer itr = new StringTokenizer(value.toString());
while (itr.hasMoreTokens()) {
word.set(itr.nextToken());
context.write(word, one);
}
}
}
public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable> values, Context context)
throws IOException, InterruptedException {
int sum = 0;
for (IntWritable val : values) {
sum += val.get();
}
result.set(sum);
context.write(key, result);
}
}
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
if (otherArgs.length != 2) {
System.err.println("Usage: AncientTextAnalyzer <in> <out>");
System.exit(2);
}
Job job = Job.getInstance(conf, "Ancient Text Analyzer");
job.setJarByClass(AncientTextAnalyzer.class);
job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumReducer.class);
job.setReducerClass(IntSumReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
Este código é um programa MapReduce simples que conta as ocorrências de cada palavra no arquivo de entrada. Usaremos este código para demonstrar o uso do cache distribuído no Hadoop.
Compilar e Empacotar o Código
Nesta etapa, compilaremos o código Java e criaremos um arquivo JAR para implantação.
Primeiro, certifique-se de ter o arquivo JAR do núcleo do Hadoop em seu classpath. Você pode baixá-lo do site da Apache Hadoop ou usar o fornecido em sua instalação do Hadoop.
Compile o arquivo AncientTextAnalyzer.java:
javac -source 8 -target 8 -classpath "/home/hadoop/hadoop/share/hadoop/common/hadoop-common-3.3.6.jar:/home/hadoop/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:/home/hadoop/hadoop/share/hadoop/common/lib/*" AncientTextAnalyzer.java
Agora, crie um arquivo JAR com os arquivos de classe compilados:
jar -cvf ancient-text-analyzer.jar AncientTextAnalyzer*.class
Executar o Job MapReduce com Cache Distribuído
Nesta etapa, executaremos o job MapReduce e aproveitaremos o cache distribuído para fornecer o arquivo de entrada a todos os nós no cluster.
Primeiro, copie o arquivo de entrada ancient-texts.txt para o Hadoop Distributed File System (HDFS):
hadoop fs -mkdir /input
hadoop fs -put ancient-texts.txt /input/ancient-texts.txt
Em seguida, execute o job MapReduce com a opção de cache distribuído:
hadoop jar ancient-text-analyzer.jar AncientTextAnalyzer -files ancient-texts.txt /input/ancient-texts.txt /output
Este comando executará o job MapReduce AncientTextAnalyzer, usando a opção -files para distribuir o arquivo ancient-texts.txt para todos os nós no cluster. O caminho de entrada é /input/ancient-texts.txt e o caminho de saída é /output.
Após a conclusão do job, você pode verificar a saída:
hadoop fs -cat /output/part-r-00000
Você deve ver a saída da contagem de palavras, semelhante a:
Embrace 1
Knowledge 1
The 1
ages 1
enlightenment. 1
eternal. 1
is 2
mysteries 1
of 2
path 1
the 4
to 1
universe. 1
wisdom 1
Resumo
Neste laboratório, exploramos o poder do recurso de cache distribuído do Hadoop implementando um sistema de análise de texto antigo. Ao alavancar o cache distribuído, fomos capazes de distribuir eficientemente o arquivo de entrada para todos os nós no cluster, permitindo o processamento paralelo e reduzindo a sobrecarga da transferência de dados pela rede.
Através desta experiência prática, obtive uma compreensão mais profunda de como o cache distribuído do Hadoop pode otimizar o processamento de dados em ambientes de computação distribuída. Ao armazenar em cache dados acessados com frequência em todo o cluster, podemos melhorar significativamente o desempenho e reduzir o tráfego de rede, especialmente ao lidar com grandes conjuntos de dados ou computações complexas.
Além disso, este laboratório me proporcionou experiência prática em trabalhar com Hadoop MapReduce, programação Java e execução de jobs em um cluster Hadoop. A combinação de conhecimento teórico e prática prática aprimorou minha proficiência no processamento de big data e me preparou para desafios mais avançados relacionados ao Hadoop.
