Dominando Hadoop MapReduce: Personalizando formatos de entrada y salida

Introducción

En este laboratorio, aprenderá a personalizar los formatos de salida y entrada en Hadoop MapReduce para procesar datos de manera efectiva. Con la instrucción guiada del Ghost Tutor, adquirirá las habilidades para trabajar con diferentes tipos de datos y desbloquear todo el potencial del ecosistema Hadoop. Prepárese para emprender un emocionante viaje para dominar el arte de la computación en el reino sobrenatural.

Escribiendo el Mapper y el Reducer

En este paso, profundizaremos en el corazón de Hadoop MapReduce y crearemos nuestras propias clases Mapper y Reducer.

Explorar el archivo de datos

Primero, use el comando su - hadoop para cambiar de identidad. El archivo de datos data.txt se almacena en el directorio /user/hadoop/input de HDFS, que almacena el contenido de algunas conversaciones de personas. Use el siguiente comando para ver el contenido:

hdfs dfs -cat /user/hadoop/input/data.txt

Mapper personalizado

A continuación, crearemos una clase Mapper personalizada llamada WordCountMapper que extiende Mapper. Este Mapper procesará los datos de entrada y emitirá pares clave-valor, teniendo en cuenta que los datos procesados son el contenido de cada línea de la conversación, no los nombres de las personas. Consulte el siguiente ejemplo para completar el método map en WordCountMapper.java en /home/hadoop/.

@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    // Convertir el objeto Text a una String
    String line = value.toString();
    // Tokenizar la cadena usando StringTokenizer
    StringTokenizer tokenizer = new StringTokenizer(line);
    // Iterar a través de cada token y escribirlos en el contexto
    while (tokenizer.hasMoreTokens()) {
        // Establecer la palabra actual
        word.set(tokenizer.nextToken().trim());
        // Escribir la palabra y su conteo en el contexto
        context.write(word, one);
    }
}

Luego use el siguiente comando para compilar el código en la versión de java 8:

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. WordCountMapper.java

Reducer personalizado

Finalmente, crearemos una clase Reducer personalizada llamada WordCountReducer que extiende Reducer. Este Reducer agregará los valores para cada clave y emitirá el resultado final. Complete el método reduce en WordCountReducer.java en /home/hadoop/ con el siguiente ejemplo.

@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context)
        throws IOException, InterruptedException {
    // Inicializar una variable para almacenar la suma de los conteos para cada palabra
    int sum = 0;
    // Iterar a través de todos los conteos para la palabra actual y calcular la suma total
    for (IntWritable value : values) {
        sum += value.get();
    }
    // Establecer el conteo final para la palabra actual
    result.set(sum);
    // Escribir la palabra y su conteo final en el contexto
    context.write(key, result);
}

Luego use el siguiente comando para compilar el código en la versión de java 8:

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. WordCountReducer.java

Escribiendo formatos de entrada y salida personalizados

En este paso, especificaremos los formatos de entrada y salida para el trabajo de MapReduce.

Formato de entrada personalizado

Primero, creemos un formato de entrada personalizado para leer datos de una fuente específica. Definiremos una clase llamada PersonInputFormat que extiende TextInputFormat y sobrescribirá el método getCurrentValue para manejar el formato de entrada. Complete el método getCurrentValue en PersonInputFormat.java en /home/hadoop/ con el siguiente ejemplo.

@Override
public synchronized Text getCurrentValue() {
    // Devolver el valor del registro actual, dividirlo según ":", eliminar los espacios en blanco del primer y último y establecerlo en el objeto Text.
    Text value = new Text();
    Text line = super.getCurrentValue();
    String[] parts = line.toString().split(":");
    if (parts.length == 2) {
        value.set(parts[1].trim());
    }
    return value;
}

Luego use el siguiente comando para compilar el código en la versión de java 8:

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. PersonInputFormat.java

Formato de salida personalizado

A continuación, creemos un formato de salida personalizado. Definiremos una clase llamada CSVOutputFormat que extiende TextOutputFormat. Complete el método write en CSVOutputFormat.java en /home/hadoop/ con el siguiente ejemplo.

// Escribir el par clave-valor en el flujo de salida en formato CSV
@Override
public void write(Text key, IntWritable value) throws IOException, InterruptedException {
    out.writeBytes(key.toString() + "," + value.toString() + "\n");
}

Luego use el siguiente comando para compilar el código en la versión de java 8:

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. CSVOutputFormat.java

Integrando con el Controlador

En este último paso, modificaremos la clase WordCountDriver para utilizar los formatos de entrada y salida personalizados que creamos anteriormente.

Controlador personalizado

Complete la función main de WordCountDriver.java en /home/hadoop/ con el siguiente ejemplo.

// Establecer las clases Mapper y Reducer
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);

// Establecer la clase de formato de entrada al formato de entrada personalizado PersonInputFormat
job.setInputFormatClass(PersonInputFormat.class);

// Establecer la clase de formato de salida al formato de salida personalizado CSVOutputFormat
job.setOutputFormatClass(CSVOutputFormat.class);

Ejecutando el trabajo

Para ejecutar el trabajo de Hadoop MapReduce con los formatos de entrada y salida personalizados, siga estos pasos:

Compile WordCountDriver.java usando las dependencias de Hadoop adecuadas.

javac -source 8 -target 8 -cp $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. WordCountDriver.java

Cree un archivo JAR que contenga las clases compiladas.
```
jar -cvf mywordcount.jar *.class
```
Ejecute la clase WordCountDriver con las rutas de entrada y salida adecuadas. Asegúrese de que la ruta de salida no exista previamente.
```
hadoop jar./mywordcount.jar WordCountDriver /user/hadoop/input /output
```

Este comando ejecutará el trabajo de Hadoop MapReduce usando los formatos de entrada y salida personalizados que definimos.

Ver los resultados de la salida

Use el siguiente comando para comprobar si el archivo de resultado se generó correctamente:

hdfs dfs -ls /output
hdfs dfs -cat /output/part.csv

Resumen

¡Felicidades! En este laboratorio, has explorado con éxito las complejidades de Hadoop MapReduce y dominado la personalización de los formatos de salida y entrada bajo la guía del Ghost Tutor. Desde la creación de clases Mapper y Reducer hasta superar desafíos como el manejo de archivos de entrada no divisible, has adquirido valiosos conocimientos. A través de ejercicios prácticos, has profundizado tu comprensión de las capacidades de Hadoop MapReduce y ahora estás capacitado para enfrentar retos de datos con confianza. Este viaje no solo ha mejorado tus habilidades técnicas, sino que también ha ampliado tu perspectiva sobre el potencial de Hadoop MapReduce para el procesamiento de grandes cantidades de datos.