Introducción
En las ruinas antiguas de una civilización perdida, un grupo de exploradores modernos descubrió por casualidad un templo escondido dedicado al dios de la sabiduría y el conocimiento. Las paredes del templo estaban adornadas con complejos jeroglíficos que guardaban los secretos de un sistema avanzado de procesamiento de datos utilizado por los sacerdotes antiguos.
Uno de los exploradores, un experto ingeniero de Hadoop, asumió el papel de Alto Sacerdote, descifrando los jeroglíficos y desbloqueando los misterios del templo. El objetivo era reconstruir el antiguo sistema de procesamiento de datos, aprovechando el poder de la memoria caché distribuida de Hadoop para procesar eficientemente grandes conjuntos de datos, tal como lo hicieron los sacerdotes antiguos hace siglos.
Preparar el Conjunto de Datos y el Código
En este paso, configuraremos los archivos y el código necesarios para simular el antiguo sistema de procesamiento de datos.
Primero, cambie el usuario a hadoop y luego cambie al directorio home del usuario hadoop:
su - hadoop
Cree un nuevo directorio llamado distributed-cache-lab y navegue hasta él:
mkdir distributed-cache-lab
cd distributed-cache-lab
A continuación, cree un archivo de texto llamado ancient-texts.txt con el siguiente contenido:
La sabiduría de las edades es eterna.
El conocimiento es el camino hacia la iluminación.
Abrace los misterios del universo.
Este archivo representará los textos antiguos que queremos procesar.
Ahora, cree un archivo Java llamado AncientTextAnalyzer.java con el siguiente 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 es un programa simple de MapReduce que cuenta la frecuencia de cada palabra en el archivo de entrada. Usaremos este código para demostrar el uso de la memoria caché distribuida en Hadoop.
Compilar y Empaquetar el Código
En este paso, compilaremos el código Java y crearemos un archivo JAR para la implementación.
Primero, asegúrese de tener el archivo JAR del núcleo de Hadoop en su clasepath. Puede descargarlo desde el sitio web de Apache Hadoop o usar el proporcionado en su instalación de Hadoop.
Compile el archivo 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
Ahora, cree un archivo JAR con los archivos de clase compilados:
jar -cvf ancient-text-analyzer.jar AncientTextAnalyzer*.class
Ejecutar el Trabajo de MapReduce con Memoria Caché Distribuida
En este paso, ejecutaremos el trabajo de MapReduce y aprovecharemos la memoria caché distribuida para proporcionar el archivo de entrada a todos los nodos del clúster.
Primero, copie el archivo de entrada ancient-texts.txt al Sistema de Archivos Distribuido de Hadoop (HDFS):
hadoop fs -mkdir /input
hadoop fs -put ancient-texts.txt /input/ancient-texts.txt
A continuación, ejecute el trabajo de MapReduce con la opción de memoria caché distribuida:
hadoop jar ancient-text-analyzer.jar AncientTextAnalyzer -files ancient-texts.txt /input/ancient-texts.txt /output
Este comando ejecutará el trabajo de MapReduce AncientTextAnalyzer, utilizando la opción -files para distribuir el archivo ancient-texts.txt a todos los nodos del clúster. La ruta de entrada es /input/ancient-texts.txt, y la ruta de salida es /output.
Después de que el trabajo se complete, puede verificar la salida:
hadoop fs -cat /output/part-r-00000
Debería ver la salida de conteo de palabras, similar 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
Resumen
En este laboratorio, exploramos el poder de la característica de memoria caché distribuida de Hadoop al implementar un sistema de análisis de textos antiguos. Al aprovechar la memoria caché distribuida, pudimos distribuir eficientemente el archivo de entrada a todos los nodos del clúster, lo que permitió el procesamiento en paralelo y redujo la sobrecarga de transferencia de datos a través de la red.
A través de esta experiencia práctica, adquirí una comprensión más profunda de cómo la memoria caché distribuida de Hadoop puede optimizar el procesamiento de datos en entornos de computación distribuida. Al almacenar en caché datos accesados con frecuencia en todo el clúster, podemos mejorar significativamente el rendimiento y reducir el tráfico de red, especialmente cuando se tratan de grandes conjuntos de datos o cálculos complejos.
Además, este laboratorio me proporcionó experiencia práctica en el trabajo con Hadoop MapReduce, programación Java y la ejecución de trabajos en un clúster de Hadoop. La combinación de conocimiento teórico y práctica práctica ha mejorado mi competencia en el procesamiento de grandes datos y me ha preparado para desafíos más avanzados relacionados con Hadoop.
