¿Qué es Hadoop? Explique brevemente su arquitectura y componentes.
Hadoop es un marco informático distribuido de código abierto para procesar y almacenar conjuntos de datos a gran escala. Está diseñado para proporcionar una alta tolerancia a fallos en hardware económico y para poder manejar grandes cantidades de datos. La arquitectura de Hadoop consta de dos componentes principales: Hadoop Distributed File System (HDFS) y MapReduce.
- Sistema de archivos distribuido de Hadoop (HDFS):
HDFS es el sistema de archivos distribuido de Hadoop que se utiliza para almacenar conjuntos de datos a gran escala. Está diseñado para proporcionar una alta tolerancia a fallos en hardware económico. HDFS divide archivos grandes en varios bloques y distribuye el almacenamiento en varias máquinas. Esto permite una alta confiabilidad y escalabilidad de los datos. La arquitectura de HDFS incluye los siguientes componentes:
- NameNode: NameNode es el nodo maestro de HDFS y es responsable de administrar el espacio de nombres del sistema de archivos y los metadatos de los bloques de almacenamiento. Mantiene el árbol de directorios y la información de ubicación del bloque de archivos de todo el sistema de archivos.
- DataNode: DataNode es el nodo de trabajo de HDFS y es responsable de almacenar bloques de datos reales. Recibe instrucciones del NameNode y gestiona bloques de datos almacenados localmente. DataNode también es responsable de la replicación de datos y la tolerancia a fallas.
- NameNode secundario: El NameNode secundario es el nodo auxiliar del NameNode y es responsable de fusionar y verificar periódicamente el registro de edición del sistema de archivos y generar nuevos archivos de imagen. Ayuda a reducir la presión de carga sobre NameNode y mejora la confiabilidad del sistema.
- MapReduce:
MapReduce es el modelo informático y el marco de ejecución de Hadoop. Divide las tareas informáticas en dos etapas: etapa de mapa y etapa de reducción. La arquitectura de MapReduce incluye los siguientes componentes:
- JobTracker: JobTracker es el nodo maestro de MapReduce y es responsable de programar y monitorear la ejecución del trabajo. Recibe solicitudes de trabajo de los clientes y asigna trabajos a TaskTrackers disponibles para su ejecución.
- TaskTracker: TaskTracker es el nodo de trabajo de MapReduce y es responsable de realizar tareas específicas. Recibe instrucciones de JobTracker y ejecuta tareas de mapa y tareas de reducción. TaskTracker también es responsable de monitorear el progreso y el estado de las tareas e informar los resultados a JobTracker.
- Tarea de mapa: la tarea de mapa es la primera etapa de MapReduce y es responsable de convertir los datos de entrada en forma de pares clave-valor y generar resultados intermedios. Cada tarea de Mapa procesa de forma independiente un subconjunto de los datos de entrada y genera resultados intermedios.
- Tarea Reducir: La tarea Reducir es la segunda etapa de MapReduce y es responsable de agregar y calcular resultados intermedios y generar el resultado final. Cada tarea de Reducir procesa los resultados intermedios generados por una o más tareas de Mapa.
El siguiente es un código de ejemplo que utiliza el marco MapReduce de Hadoop para contar las apariciones de cada palabra en un archivo de texto de entrada:
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;
public class WordCount {
// Mapper class
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);
}
}
}
// Reducer class
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();
Job job = Job.getInstance(conf, "word count");
job.setJarByClass(WordCount.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(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
En el ejemplo anterior, hemos definido una clase Java llamada WordCount. Contiene una clase Mapper (TokenizerMapper) y una clase Reducer (IntSumReducer). La clase Mapper es responsable de dividir los datos del texto de entrada en palabras y usar cada palabra como clave, estableciendo el valor en 1. La clase Reducer es responsable de sumar los recuentos de las mismas palabras y generar el resultado.
En la función main(), creamos un objeto Job y configuramos el nombre del trabajo, las clases Mapper y Reducer, y los tipos de datos de entrada y salida. También especificamos las rutas de entrada y salida y llamamos al método job.waitForCompletion() para ejecutar el trabajo.
Con los datos de entrada adecuados y las clases personalizadas de Mapper y Reducer, podemos manejar varios tipos de datos a gran escala y realizar los análisis y cálculos correspondientes. Utilizando el sistema de archivos distribuido HDFS de Hadoop y el marco informático MapReduce, podemos construir un sistema de procesamiento de big data altamente confiable y escalable.