Introduction
Dans les ruines anciennes d'une civilisation perdue, un groupe d'explorateurs modernes est tombé sur un temple caché dédié au dieu de la connaissance et de la sagesse. Les murs du temple étaient ornés d'héroglyphes complexes, contenant les secrets d'un système avancé de traitement de données utilisé par les prêtres anciens.
L'un des explorateurs, un ingénieur Hadoop expérimenté, a pris le rôle d'un grand prêtre, décodant les hiéroglyphes et débloquant les mystères du temple. L'objectif était de reconstruire le système ancien de traitement de données, en utilisant la puissance du cache distribué de Hadoop pour traiter efficacement de grands ensembles de données, tout comme les prêtres anciens le faisaient il y a des siècles.
Préparer l'ensemble de données et le code
Dans cette étape, nous allons configurer les fichiers et le code nécessaires pour simuler le système ancien de traitement de données.
Tout d'abord, changez l'utilisateur en hadoop puis accédez au répertoire personnel de l'utilisateur hadoop :
su - hadoop
Créez un nouveau répertoire appelé distributed-cache-lab et accédez-y :
mkdir distributed-cache-lab
cd distributed-cache-lab
Ensuite, créez un fichier texte nommé ancient-texts.txt avec le contenu suivant :
La sagesse des âges est éternelle.
La connaissance est le chemin vers l'éveil.
Embrassez les mystères de l'univers.
Ce fichier représentera les textes anciens que nous souhaitons traiter.
Maintenant, créez un fichier Java nommé AncientTextAnalyzer.java avec le code suivant :
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);
}
}
Ce code est un programme MapReduce simple qui compte les occurrences de chaque mot dans le fichier d'entrée. Nous utiliserons ce code pour démontrer l'utilisation du cache distribué dans Hadoop.
Compiler et emballer le code
Dans cette étape, nous allons compiler le code Java et créer un fichier JAR pour le déploiement.
Tout d'abord, assurez-vous d'avoir le fichier JAR du noyau Hadoop dans votre classpath. Vous pouvez le télécharger sur le site web d'Apache Hadoop ou utiliser celui fourni dans votre installation Hadoop.
Compilez le fichier 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
Maintenant, créez un fichier JAR avec les fichiers de classes compilés :
jar -cvf ancient-text-analyzer.jar AncientTextAnalyzer*.class
Exécuter le travail MapReduce avec le cache distribué
Dans cette étape, nous allons exécuter le travail MapReduce et utiliser le cache distribué pour fournir le fichier d'entrée à tous les nœuds du cluster.
Tout d'abord, copiez le fichier d'entrée ancient-texts.txt dans le Hadoop Distributed File System (HDFS) :
hadoop fs -mkdir /input
hadoop fs -put ancient-texts.txt /input/ancient-texts.txt
Ensuite, exécutez le travail MapReduce avec l'option de cache distribué :
hadoop jar ancient-text-analyzer.jar AncientTextAnalyzer -files ancient-texts.txt /input/ancient-texts.txt /output
Cette commande exécutera le travail MapReduce AncientTextAnalyzer, en utilisant l'option -files pour distribuer le fichier ancient-texts.txt à tous les nœuds du cluster. Le chemin d'entrée est /input/ancient-texts.txt et le chemin de sortie est /output.
Une fois le travail terminé, vous pouvez vérifier la sortie :
hadoop fs -cat /output/part-r-00000
Vous devriez voir la sortie du comptage de mots, similaire à :
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
Résumé
Dans ce laboratoire, nous avons exploré le pouvoir de la fonction de cache distribué de Hadoop en mettant en œuvre un système d'analyse de textes anciens. En utilisant le cache distribué, nous avons pu distribuer efficacement le fichier d'entrée à tous les nœuds du cluster, permettant un traitement parallèle et réduisant la surcharge de transfert de données sur le réseau.
Grâce à cette expérience pratique, j'ai acquis une compréhension plus approfondie de la manière dont le cache distribué de Hadoop peut optimiser le traitement de données dans les environnements de calcul distribué. En mettant en cache les données fréquemment consultées sur le cluster, nous pouvons considérablement améliorer les performances et réduire la circulation de données sur le réseau, en particulier lorsqu'il s'agit de grands ensembles de données ou de calculs complexes.
De plus, ce laboratoire m'a procuré une expérience pratique dans le travail avec Hadoop MapReduce, la programmation Java et l'exécution de travaux sur un cluster Hadoop. La combinaison de connaissances théoriques et de pratique a amélioré ma maîtrise du traitement de données volumineuses et m'a préparé à relever des défis plus avancés liés à Hadoop.
