El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Técnicas de Optimización de MapReduce

Siguiente ►
►

En este módulo, aprenderemos diversas técnicas para optimizar los trabajos de MapReduce. La optimización es crucial para mejorar el rendimiento y la eficiencia de los trabajos de procesamiento de datos en Hadoop. A continuación, se presentan las técnicas más importantes:

  1. Compresión de Datos

¿Por qué es importante?

La compresión de datos reduce el tamaño de los datos que se transfieren y almacenan, lo que puede mejorar significativamente el rendimiento de los trabajos de MapReduce.

Tipos de Compresión

  • Gzip: Buena compresión, pero no soporta división.
  • Bzip2: Mejor compresión que Gzip y soporta división, pero es más lento.
  • Snappy: Rápida, pero con menor compresión.
  • LZO: Rápida y soporta división, pero requiere instalación adicional.

Ejemplo de Configuración

<configuration>
    <property>
        <name>mapreduce.map.output.compress</name>
        <value>true</value>
    </property>
    <property>
        <name>mapreduce.map.output.compress.codec</name>
        <value>org.apache.hadoop.io.compress.SnappyCodec</value>
    </property>
    <property>
        <name>mapreduce.output.fileoutputformat.compress</name>
        <value>true</value>
    </property>
    <property>
        <name>mapreduce.output.fileoutputformat.compress.codec</name>
        <value>org.apache.hadoop.io.compress.SnappyCodec</value>
    </property>
</configuration>

  1. Uso de Combiners

¿Qué es un Combiner?

Un Combiner es una mini-reducción que se ejecuta en el nodo de mapeo para reducir la cantidad de datos transferidos a los nodos de reducción.

Ejemplo de Implementación

public class MyCombiner extends Reducer<Text, IntWritable, Text, IntWritable> {
    public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable val : values) {
            sum += val.get();
        }
        context.write(key, new IntWritable(sum));
    }
}

Configuración del Combiner

job.setCombinerClass(MyCombiner.class);

  1. Particionadores Personalizados

¿Qué es un Particionador?

Un particionador determina en qué partición (reductor) se enviará una clave específica. Un particionador personalizado puede balancear la carga entre los reductores.

Ejemplo de Implementación

public class MyPartitioner extends Partitioner<Text, IntWritable> {
    @Override
    public int getPartition(Text key, IntWritable value, int numReduceTasks) {
        return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
    }
}

Configuración del Particionador

job.setPartitionerClass(MyPartitioner.class);

  1. Ajuste del Número de Reducers

¿Por qué es importante?

El número de reducers puede afectar el rendimiento del trabajo. Demasiados reducers pueden causar sobrecarga, mientras que muy pocos pueden causar cuellos de botella.

Configuración del Número de Reducers

job.setNumReduceTasks(10);

  1. Uso de Contadores

¿Qué son los Contadores?

Los contadores son herramientas útiles para monitorear y depurar trabajos de MapReduce. Pueden ayudar a identificar cuellos de botella y problemas de rendimiento.

Ejemplo de Uso

public class MyMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    private static final IntWritable one = new IntWritable(1);
    public static enum COUNTERS {
        RECORD_COUNT
    }

    public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        context.getCounter(COUNTERS.RECORD_COUNT).increment(1);
        // Lógica del mapeo
    }
}

  1. Configuración de Parámetros de Hadoop

Parámetros Clave

  • mapreduce.task.io.sort.mb: Tamaño de la memoria para la clasificación de datos.
  • mapreduce.task.io.sort.factor: Número de archivos que se pueden mezclar simultáneamente.
  • mapreduce.reduce.shuffle.parallelcopies: Número de copias paralelas durante la fase de shuffle.

Ejemplo de Configuración

<configuration>
    <property>
        <name>mapreduce.task.io.sort.mb</name>
        <value>100</value>
    </property>
    <property>
        <name>mapreduce.task.io.sort.factor</name>
        <value>10</value>
    </property>
    <property>
        <name>mapreduce.reduce.shuffle.parallelcopies</name>
        <value>5</value>
    </property>
</configuration>

Ejercicio Práctico

Ejercicio

  1. Escribe un programa MapReduce que cuente la frecuencia de palabras en un conjunto de datos.
  2. Implementa un Combiner para reducir la cantidad de datos transferidos.
  3. Configura la compresión de salida usando Snappy.
  4. Ajusta el número de reducers a 5.

Solución

public class WordCount {
    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> {
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }

    public static class IntSumCombiner extends Reducer<Text, IntWritable, Text, IntWritable> {
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            context.write(key, new IntWritable(sum));
        }
    }

    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(IntSumCombiner.class);
        job.setReducerClass(IntSumReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        job.setNumReduceTasks(5);

        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        // Configuración de compresión
        FileOutputFormat.setCompressOutput(job, true);
        FileOutputFormat.setOutputCompressorClass(job, SnappyCodec.class);

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

Conclusión

En este módulo, hemos cubierto varias técnicas de optimización para trabajos de MapReduce, incluyendo la compresión de datos, el uso de combiners, particionadores personalizados, ajuste del número de reducers, uso de contadores y configuración de parámetros de Hadoop. Estas técnicas son esenciales para mejorar el rendimiento y la eficiencia de los trabajos de MapReduce en Hadoop. Asegúrate de aplicar estas técnicas en tus proyectos para obtener el máximo rendimiento.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados