Hadoop MapReduce Join & Counter avec exemple

⚡ Résumé intelligent

Les jointures MapReduce combinent deux grands ensembles de données sur une clé partagée, soit à l'intérieur du mapper, soit à l'intérieur du reducer, tandis que les compteurs MapReduce collectent des statistiques sur la tâche afin que les enregistrements erronés puissent être mesurés plutôt que devinés.

  • (I.e. Principes de base de l'adhésion : Le plus petit des deux ensembles de données est distribué à chaque nœud de données et utilisé comme côté de recherche.
  • ☑️ Jointure côté carte : Nécessite que chaque entrée soit partitionnée, divisée en parts égales et triée par la clé de jointure avant l'exécution de la fonction map.
  • ✅ Jointure côté réduction : Aucun partitionnement n'est nécessaire, car chaque tuple partageant une clé de jointure atterrit dans le même réducteur.
  • 🧪 Exemple concret : Les fichiers DeptName.txt et DeptStrength.txt sont copiés dans HDFS et joints sur Dept_ID par un fichier jar empaqueté.
  • ️ Types de compteurs : Cinq groupes de compteurs intégrés sont fournis avec chaque tâche, et les compteurs définis par l'utilisateur sont déclarés comme un Java énumération.
  • ⚠️ Utilisation du compteur : L'incrémentation d'un compteur pour chaque enregistrement manquant ou invalide transforme les problèmes de qualité des données en un chiffre dans le rapport d'activité.

Tutoriel sur les jointures et les compteurs dans Hadoop MapReduce avec un exemple concret

Qu'est-ce qu'une jointure dans MapReduce ?

L'opération de jointure MapReduce permet de combiner deux grands ensembles de données. Cependant, ce processus nécessite l'écriture d'une quantité importante de code pour réaliser la jointure proprement dite. La jointure de deux ensembles de données commence par une comparaison de leur taille. Si l'un des ensembles est plus petit que l'autre, il est distribué sur tous les nœuds de données du cluster.

Une fois que vous vous inscrivez MapReduce Dans le cas d'une distribution, le Mapper ou le Reducer utilise le plus petit ensemble de données pour effectuer une recherche d'enregistrements correspondants dans le grand ensemble de données, puis combine ces enregistrements pour former des enregistrements de sortie.

Types de jointure

Selon l'endroit où la jointure est effectivement effectuée, les jointures dans Hadoop sont classées en deux types.

  1. jointure côté carte Lorsque la jointure est effectuée par le mappeur, on parle de jointure côté map. Dans ce cas, la jointure est réalisée avant que les données ne soient effectivement utilisées par la fonction map. Chaque map doit impérativement fournir des données d'entrée sous forme de partitions triées. De plus, le nombre de partitions doit être identique et elles doivent être triées selon la clé de jointure.
  2. Jointure du côté réduit Lorsque la jointure est effectuée par le réducteur, on parle de jointure côté réducteur. Dans ce cas, il n'est pas nécessaire que les données soient structurées (ou partitionnées). Le traitement côté map génère la clé de jointure et les tuples correspondants des deux tables. De ce fait, tous les tuples ayant la même clé de jointure sont traités par le même réducteur, qui effectue ensuite la jointure des enregistrements ayant cette même clé.

Un flux de processus global de jointures dans Hadoop est représenté dans le diagramme ci-dessous.

Diagramme de flux de processus comparant une jointure côté map avec une jointure côté reduce dans Hadoop
Types de jointures dans Hadoop MapReduce

Les deux variantes étant désormais claires, la section suivante décrit une jointure de type « reduce side » sur deux petits fichiers de département.

Comment joindre deux ensembles de données : exemple MapReduce

Deux ensembles de données sont présents dans deux fichiers distincts (voir ci-dessous). La clé Dept_ID est commune aux deux fichiers. L'objectif est de combiner ces fichiers à l'aide d'une jointure MapReduce.

Premier fichier d'entrée listant les identifiants des départements ainsi que leurs noms.

fichier 1
Deuxième fichier d'entrée répertoriant les identifiants des départements ainsi que leurs valeurs de force.

fichier 2

Entrées : Les données d'entrée sont un fichier texte : DeptName.txt et DeptStrength.txt

Téléchargez les fichiers d'entrée à partir d'ici

Assurez-vous d'avoir Hadoop Une fois installé, avant de commencer le processus d'exemple MapReduce Join, changez d'utilisateur pour 'hduser' (identifiant utilisé lors de la configuration Hadoop ; vous pouvez le remplacer par l'identifiant utilisé lors de votre configuration Hadoop).

su - hduser_

L'invite modifie le compte Hadoop, comme indiqué ci-dessous.

Terminal après être passé au compte hduser avec la commande su

Étape 1) Copiez le fichier zip à l'emplacement de votre choix

L'archive MapReduceJoin téléchargée a été placée dans le répertoire de travail choisi.

Étape 2) Décompressez le fichier Zip

sudo tar -xvf MapReduceJoin.tar.gz

L' extracLes noms des fichiers ted défilent pendant que tar décompresse l'archive.

Liste des fichiers dans la console extracted à partir de MapReduceJoin.tar.gz

Étape 3) Allez dans le répertoire MapReduceJoin/

cd MapReduceJoin/

Invite de commande après avoir accédé au répertoire MapReduceJoin

Étape 4) Démarrer Hadoop

$HADOOP_HOME/sbin/start-dfs.sh
$HADOOP_HOME/sbin/start-yarn.sh

Les deux scripts affichent les démons qu'ils invoquent.

Messages de démarrage des scripts démons HDFS et YARN

Étape 5) DeptStrength.txt et DeptName.txt sont les fichiers d'entrée utilisés pour cet exemple de programme MapReduce Join.

Ces fichiers doivent être copiés vers HDFS utiliser la commande ci-dessous :

$HADOOP_HOME/bin/hdfs dfs -copyFromLocal DeptStrength.txt DeptName.txt /

Les deux fichiers texte d'entrée ont été copiés dans le répertoire racine HDFS.

Étape 6) Exécutez le programme en utilisant la commande ci-dessous-

$HADOOP_HOME/bin/hadoop jar MapReduceJoin.jar MapReduceJoin/JoinDriver/DeptStrength.txt /DeptName.txt /output_mapreducejoin

La commande est d'abord affichée, puis la tâche indique sa progression sur la console.

Lancement en ligne de commande du fichier JAR MapReduceJoin inclus

Sortie console tracsuivre l'avancement de la tâche de jointure MapReduce

Étape 7) Après exécution, le fichier de sortie (nommé « part-00000 ») sera stocké dans le répertoire /output_mapreducejoin sur HDFS.

Les résultats peuvent être vus à l'aide de l'interface de ligne de commande

$HADOOP_HOME/bin/hdfs dfs -cat /output_mapreducejoin/part-00000

Enregistrements du département fusionné imprimés depuis HDFS par la commande cat

Les résultats peuvent également être consultés via une interface Web comme-

Page d'accueil de l'interface web Hadoop utilisée pour accéder à l'explorateur de fichiers

Sélectionnez maintenant « Parcourir le système de fichiers » et naviguez jusqu'à /output_mapreducejoin

Navigation dans la vue du système de fichiers HDFS jusqu'au répertoire output_mapreducejoin

Ouvrir la pièce-r-00000

Sélection du fichier de sortie part-r-00000 dans la vue du navigateur

Les résultats sont affichés

Les lignes « nom du département » et « effectif du département » sont affichées dans le navigateur.

NOTE: Veuillez noter qu'avant d'exécuter ce programme la prochaine fois, vous devrez supprimer le répertoire de sortie /output_mapreducejoin

$HADOOP_HOME/bin/hdfs dfs -rm -r /output_mapreducejoin

L'alternative consiste à utiliser un nom différent pour le répertoire de sortie.

Les jointures vous indiquent la structure des données. Les compteurs, que nous aborderons plus loin, vous indiquent le comportement de la tâche qui les a produites.

Qu’est-ce que le compteur dans MapReduce ?

Dans MapReduce, un compteur est un mécanisme permettant de collecter et de mesurer des informations statistiques sur les tâches et les événements MapReduce. Les compteurs conservent… tracLe système utilise des compteurs pour enregistrer diverses statistiques sur les tâches MapReduce, comme le nombre d'opérations effectuées et leur progression. Ces compteurs servent également au diagnostic des problèmes dans MapReduce.

Les compteurs Hadoop sont similaires à l'insertion d'un message de journal dans le code d'une carte ou d'une réduction. Ces informations peuvent être utiles pour diagnostiquer un problème dans le traitement des tâches MapReduce.

En général, ces compteurs Hadoop sont définis dans un programme (map ou reduce) et sont incrémentés lors de l'exécution lorsqu'un événement ou une condition particulière (spécifique à ce compteur) se produit. Une application très utile des compteurs Hadoop est de… track enregistrements valides et invalides à partir d'un ensemble de données d'entrée.

Types de compteurs MapReduce

Il existe fondamentalement 2 types de compteurs MapReduce.

  1. Compteurs intégrés à Hadoop : Il existe des compteurs Hadoop intégrés par tâche. Vous trouverez ci-dessous les groupes de compteurs intégrés.
    • Compteurs de tâches MapReduce — Collecte des informations spécifiques à la tâche (par exemple, le nombre d'enregistrements d'entrée) pendant son exécution.
    • Compteurs du système de fichiers — Recueille des informations telles que le nombre d'octets lus ou écrits par une tâche.
    • Compteurs FileInputFormat — Recueille les informations d'un certain nombre d'octets lus via FileInputFormat.
    • Compteurs FileOutputFormat — Collecte les informations d'un certain nombre d'octets écrits via FileOutputFormat.
    • Compteurs d'emplois — Ces compteurs enregistrent des statistiques globales sur un emploi, telles que le nombre de tâches lancées pour un emploi.
  2. Compteurs définis par l'utilisateur : Outre les compteurs intégrés, un utilisateur peut définir ses propres compteurs en utilisant des fonctionnalités similaires offertes par les langages de programmation. Par exemple, dans Java, une « énumération » est utilisée pour définir des compteurs définis par l'utilisateur.

💡 Note de version : Les compteurs d'emplois étaient tenus par le service des emplois.TracSous MRv1, ce rôle appartient à l'ApplicationMaster de MapReduce. Les noms des compteurs subsistent donc, mais le composant qui les signale a changé.

Un travail ne peut pas déclarer un nombre illimité de compteurs. mapreduce.job.counters.max Ce paramètre limite par défaut le total par tâche à 120, et une tâche qui déclare davantage d'éléments échoue avec une erreur. LimitExceededExceptionLes compteurs sont donc conçus pour un petit nombre de signaux agrégés plutôt que pour des décomptes par clé.

Exemple de compteurs

Exemple de MapClass avec des compteurs pour compter le nombre de valeurs manquantes et invalides. Fichier de données d'entrée utilisé dans ce tutoriel : notre jeu de données d'entrée est un fichier CSV, SalesJan2009.csv

public static class MapClass
            extends MapReduceBase
            implements Mapper<LongWritable, Text, Text, Text>
{
    static enum SalesCounters { MISSING, INVALID };
    public void map ( LongWritable key, Text value,
                 OutputCollector<Text, Text> output,
                 Reporter reporter) throws IOException
    {
        
        //Input string is split using ',' and stored in 'fields' array
        String fields[] = value.toString().split(",", -20);
        //Value at 4th index is country. It is stored in 'country' variable
        String country = fields[4];
        
        //Value at 8th index is sales data. It is stored in 'sales' variable
        String sales = fields[8];
      
        if (country.length() == 0) {
            reporter.incrCounter(SalesCounters.MISSING, 1);
        } else if (sales.startsWith("\"")) {
            reporter.incrCounter(SalesCounters.INVALID, 1);
        } else {
            output.collect(new Text(country), new Text(sales + ",1"));
        }
    }
}

L'extrait de code ci-dessus illustre un exemple d'implémentation de compteurs dans Hadoop MapReduce.

Ici, Compteurs de ventes est un compteur défini à l'aide de 'enumIl sert à compter les enregistrements d'entrée MANQUANTS et INVALIDES.

Dans l'extrait de code, si 'PaysSi le champ a une longueur nulle, sa valeur est manquante et, par conséquent, le compteur correspondant SalesCounters.MISSING est incrémenté.

Ensuite, si 'venteSi le champ commence par un « », l’enregistrement est considéré comme INVALIDE. Ceci est indiqué par l’incrémentation du compteur SalesCounters.INVALID.

💡 Note concernant l'API : L'extrait ci-dessus utilise l'original org.apache.hadoop.mapred API, où MapReduceBase, le Mapper interface, OutputCollector et Reporter apparaissent séparément. Le code actuel est écrit pour org.apache.hadoop.mapreduce, où un seul Context remplace le collecteur et le rapporteur, et un compteur est incrémenté avec context.getCounter(SalesCounters.MISSING).increment(1)Le principe du compteur est identique dans les deux cas.

FAQ

Choisissez la variante mapper lorsqu'un côté est suffisamment petit pour tenir en mémoire sur chaque nœud, car elle évite complètement le brassage. Choisissez la variante reducer lorsque les deux côtés sont volumineux ou non triés, et acceptez le coût réseau supplémentaire.

Les modèles s'appuient sur l'historique des tâches pour prédire leur durée d'exécution, recommander la taille des partitions et le nombre de réducteurs, et détecter les anomalies dans les valeurs des compteurs. Ils signalent également les tâches dont les compteurs d'enregistrements débordés ou de tâches ayant échoué s'écartent des valeurs normales pour ce pipeline.

Copilot génère des squelettes de mapper et de reducer plausibles, mais mélange sans discernement l'ancien package mapred avec le plus récent package mapreduce dans une même classe, ce qui ne compilera pas. Corrigez les importations et les signatures des méthodes avant de vous fier à la logique.

Il s'agit du mécanisme qui distribue le fichier plus petit à chaque nœud avant le démarrage des tâches. Chaque mappeur charge ensuite cette copie dans une table de hachage et recherche les correspondances localement, ce qui rend possible une jointure côté mappeur.

Elles sont imprimées dans le résumé de la console une fois la tâche terminée, affichées dans l'historique des tâches et les pages Web du gestionnaire de ressources, et lisibles par programmation à partir de l'objet tâche, de sorte qu'un pilote peut les vérifier et signaler une exécution défectueuse.

Un seul objet Context. Il centralise le travail que OutputCollector et Reporter répartissaient auparavant entre eux ; ainsi, la sortie est écrite et les compteurs sont incrémentés via le même handle passé à la méthode map.

Pour la plupart des reportages, non. Jointure HiveQL La compilation aboutit en quelques lignes au même schéma de brassage et de fusion. Le développement manuel est judicieux lorsque la logique de fusion ne peut être intégrée à une clause SQL.

Hadoop refuse d'écrire dans un répertoire de sortie existant, ce qui empêche l'écrasement des résultats obtenus. Supprimez d'abord le répertoire de manière récursive, ou spécifiez un autre chemin de sortie lors de la prochaine exécution.

Résumez cet article avec :