hadoop
Introduction à MapReduce

Syntaxe

• Pour exécuter l'exemple, la syntaxe de la commande est la suivante:

  bin/hadoop jar hadoop-*-examples.jar wordcount [-m <#maps>] [-r <#reducers>] <in-dir> <out-dir>
  

• Pour copier des données dans HDFS (à partir du local):

  bin/hadoop dfs -mkdir <hdfs-dir> //not required in hadoop 0.17.2 and later
  bin/hadoop dfs -copyFromLocal <local-dir> <hdfs-dir>
  

Remarques

Programme de comptage de mots (en Java et Python)

Le programme de comptage de mots est similaire au programme "Hello World" dans MapReduce.

Hadoop MapReduce est une infrastructure logicielle permettant d'écrire facilement des applications qui traitent de grandes quantités de données (ensembles de données de plusieurs téraoctets) en parallèle sur de grands clusters (des milliers de nœuds) de matériel de base de manière fiable et tolérante aux pannes.

Un travail MapReduce divise généralement le jeu de données d'entrée en blocs indépendants qui sont traités par les tâches de carte de manière totalement parallèle. Le framework trie les sorties des cartes, qui sont ensuite entrées dans les tâches de réduction. Généralement, l'entrée et la sortie du travail sont stockées dans un système de fichiers. La structure prend en charge la planification des tâches, leur surveillance et la ré-exécution des tâches ayant échoué.

Exemple de compte de mots:

WordCount exemple lit des fichiers texte et compte combien de fois les mots se produisent. L'entrée est constituée de fichiers texte et la sortie est constituée de fichiers texte, dont chaque ligne contient un mot et le nombre de fois où elle s'est produite, séparés par un onglet.

Chaque mappeur prend une ligne en entrée et la divise en mots. Il émet alors une paire clé / valeur du mot et chaque réducteur additionne les comptes pour chaque mot et émet une seule clé / valeur avec le mot et la somme.

En tant qu'optimisation, le réducteur est également utilisé comme combineur sur les sorties de la carte. Cela réduit la quantité de données envoyées sur le réseau en combinant chaque mot en un seul enregistrement.

Code de nombre de mots:

package org.myorg;
        
import java.io.IOException;
import java.util.*;
        
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.*;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
        
public class WordCount {
        
 public static class Map extends Mapper<LongWritable, Text, Text, IntWritable> {
    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();
        
    public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString();
        StringTokenizer tokenizer = new StringTokenizer(line);
        while (tokenizer.hasMoreTokens()) {
            word.set(tokenizer.nextToken());
            context.write(word, one);
        }
    }
 } 
        
 public static class Reduce 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 = new Job(conf, "wordcount");
    
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);
        
    job.setMapperClass(Map.class);
    job.setReducerClass(Reduce.class);
        
    job.setInputFormatClass(TextInputFormat.class);
    job.setOutputFormatClass(TextOutputFormat.class);
        
    FileInputFormat.addInputPath(job, new Path(args[0]));
    FileOutputFormat.setOutputPath(job, new Path(args[1]));
        
    job.waitForCompletion(true);
 }
        
}

Pour exécuter l'exemple, la syntaxe de la commande est la suivante:

bin/hadoop jar hadoop-*-examples.jar wordcount [-m <#maps>] [-r <#reducers>] <in-dir> <out-dir>

Tous les fichiers du répertoire d'entrée (appelés in-dir dans la ligne de commande ci-dessus) sont lus et les comptes de mots dans l'entrée sont écrits dans le répertoire de sortie (appelé out-dir ci-dessus). Il est supposé que les entrées et les sorties sont stockées dans HDFS. Si votre entrée n'est pas déjà dans HDFS, mais plutôt dans un système de fichiers local, vous devez copier les données dans HDFS en utilisant une commande comme celle-ci:

bin/hadoop dfs -mkdir <hdfs-dir> //not required in hadoop 0.17.2 and later
bin/hadoop dfs -copyFromLocal <local-dir> <hdfs-dir>

Word Count exemple en Python:

mapper.py

import sys 
for line in sys.stdin: 
    # remove leading and trailing whitespace 
    line = line.strip() 
    # split the line into words 
    words = line.split() 
    # increase counters 
    for word in words: 
        print '%s\t%s' % (word, 1)

réducteur.py

import sys
current_word = None
current_count = 0
word = None
for line in sys.stdin:
    # remove leading and trailing whitespaces
    line = line.strip()
    # parse the input we got from mapper.py
    word, count = line.split('\t', 1)
    # convert count (currently a string) to int
    try:
        count = int(count)
    except ValueError:
        # count was not a number, so silently
        # ignore/discard this line
        continue
    if current_word == word:
        current_count += count
    else:
        if current_word:
            print '%s\t%s' % (current_word, current_count)
        current_count = count
        current_word = word
if current_word == word:
    print '%s\t%s' % (current_word, current_count)

Le programme ci-dessus peut être exécuté en utilisant cat filename.txt | python mapper.py | sort -k1,1 | python reducer.py