Comment Hadoop effectue-t-il le fractionnement des entrées?
C'est une question conceptuelle impliquant Hadoop/HDFS. Disons que vous avez un fichier contenant 1 milliard de lignes. Et par souci de simplicité, considérons que chaque ligne est de la forme <k,v> où k est le décalage de la ligne depuis le début et la valeur est le contenu de la ligne.
Maintenant, lorsque nous disons que nous voulons exécuter N tâches de mappage, la structure divise-t-elle le fichier d'entrée en N divisions et exécute-t-elle chaque tâche de carte sur cette division? ou devons-nous écrire une fonction de partitionnement qui effectue les fractionnements N et exécuter chaque tâche de mappage sur le fractionnement généré?
Tout ce que je veux savoir, c'est si les scissions sont effectuées en interne ou si nous devons scinder les données manuellement?
Plus précisément, chaque fois que la fonction map () est appelée, quels sont ses paramètres Key key and Value val?
Merci, Deepak
La InputFormat est chargée de fournir les scissions.
En général, si vous avez n nœuds, le système HDFS distribuera le fichier sur tous ces n nœuds. Si vous commencez un travail, il y aura n mappeurs par défaut. Grâce à Hadoop, le mappeur sur une machine traitera la partie des données stockée sur ce nœud. Je pense que cela s'appelle Rack awareness.
Donc, pour faire une histoire courte: Téléchargez les données dans le HDFS et démarrez un travail MR. Hadoop se chargera de l'exécution optimisée.
Les fichiers sont divisés en blocs HDFS et les blocs sont répliqués. Hadoop assigne un nœud pour une scission basée sur le principe de localité de données. Hadoop essaiera d'exécuter le mappeur sur les nœuds où réside le bloc. En raison de la réplication, plusieurs nœuds de ce type hébergent le même bloc.
Si les nœuds ne sont pas disponibles, Hadoop essaiera de choisir un nœud le plus proche du nœud hébergeant le bloc de données. Il pourrait par exemple choisir un autre noeud dans le même rack. Un nœud peut ne pas être disponible pour diverses raisons; tous les emplacements de carte peuvent être utilisés ou le nœud peut simplement être en panne.
Heureusement tout sera pris en charge par cadre.
Le traitement des données MapReduce est basé sur ce concept de fractionnements d'entrée. Le nombre de divisions d’entrée calculées pour une application spécifique détermine le nombre de tâches du mappeur.
Le nombre de cartes est généralement déterminé par le nombre de blocs DFS dans les fichiers d'entrée.
Chacune de ces tâches de mappeur est affectée, si possible, à un nœud esclave où le fractionnement d'entrée est stocké. Resource Manager (ou JobTracker, si vous êtes dans Hadoop 1) fait de son mieux pour s'assurer que les groupes d'entrées sont traités localement.
Si localité de données} _ ne peut pas être obtenu à cause des divisions d'entrées franchissant les limites des nœuds de données, certaines données seront transférées d'un nœud de données à un autre.
Supposons qu'il y a un bloc de 128 Mo et que le dernier enregistrement ne rentre pas dans bloc a et se propage dans bloc b, puis les données dans bloc b seront copiées dans le noeud ayant Bloc a
Regardez ce diagramme.
Jetez un coup d'œil aux questions connexes
À propos du fractionnement de fichiers HDFS/Hadoop
Comment le processus Hadoop enregistre-t-il les fractionnements?
Pour mieux comprendre le fonctionnement de InputSplits dans hadoop, je vous recommanderais de lire le article écrit par Hadoop pour les nuls . C'est vraiment utile.
Je pense que ce que Deepak demandait concernait davantage la manière dont l'entrée pour chaque appel de la fonction map était déterminée, plutôt que les données présentes sur chaque map noeud. Je le dis en me basant sur la deuxième partie de la question: Plus précisément, chaque fois que la fonction map () est appelée, quels sont ses paramètres Key key et Value val?
En fait, la même question m’a amené ici, et si j’avais été un développeur hadoop expérimenté, je l’aurais peut-être interprété comme les réponses ci-dessus.
Pour répondre à la question,
le fichier sur un nœud de carte donné est divisé en fonction de la valeur définie pour InputFormat. (Cela se fait en Java en utilisant setInputFormat () !)
Un exemple:
conf.setInputFormat (TextInputFormat.class); Ici, en transmettant TextInputFormat à la fonction setInputFormat, nous indiquons à hadoop de traiter chaque line du fichier d'entrée du nœud de carte comme entrée de la fonction de carte. Un saut de ligne ou un retour chariot est utilisé pour signaler la fin de ligne . Plus d'infos sur TextInputFormat !
Dans cet exemple: Les clés sont la position dans le fichier et les valeurs sont la ligne de texte.
J'espère que cela t'aides.
Lorsqu'un travail Hadoop est exécuté, il divise les fichiers d'entrée en fragments et attribue chaque segment à un mappeur à traiter. c'est ce qu'on appelle InputSplit.
FileInputFormat est la classe abstraite qui définit la manière dont les fichiers d'entrée sont lus et décomposés . FileInputFormat fournit les fonctionnalités suivantes: 1. sélectionnez les fichiers/objets à utiliser comme entrée 2. Définit les inputplits qui divisent un fichier en tâche.
Selon les fonctionnalités de base de hadoopp, s'il y a n divisions, il y aura n mappeur.
Différence entre la taille de bloc et la taille de fractionnement en entrée.
Le fractionnement en entrée est un fractionnement logique de vos données, essentiellement utilisé lors du traitement de données dans le programme MapReduce ou d'autres techniques de traitement. La taille de fractionnement en entrée est une valeur définie par l'utilisateur et Hadoop Developer peut choisir une taille de fractionnement en fonction de la taille des données (quantité de données que vous traitez).
Le fractionnement en entrée est généralement utilisé pour contrôler le nombre de mappeurs dans le programme MapReduce. Si vous n'avez pas défini la taille du fractionnement d'entrée dans le programme MapReduce, le fractionnement de bloc HDFS par défaut sera considéré comme un fractionnement d'entrée lors du traitement des données.
Exemple:
Supposons que vous avez un fichier de 100 Mo et que la configuration de bloc HDFS par défaut est de 64 Mo, puis il sera découpé en deux et occupera deux blocs HDFS. Vous disposez maintenant d'un programme MapReduce pour traiter ces données, mais vous n'avez pas spécifié de fractionnement d'entrée. En fonction du nombre de blocs (2 blocs), le fractionnement d'entrée est alors considéré pour le traitement MapReduce et deux mappeurs sont affectés à ce travail. Mais supposons que vous ayez spécifié la taille du partage (disons 100 Mo) dans votre programme MapReduce, les deux blocs (2 blocs) seront considérés comme un seul partage pour le traitement MapReduce et un mappeur sera affecté à ce travail.
Supposons maintenant que vous avez spécifié la taille de la division (disons 25 Mo) dans votre programme MapReduce, puis il y aura 4 divisions en entrée pour le programme MapReduce et 4 mappeurs seront affectés au travail.
Conclusion:
- Le fractionnement en entrée est une division logique des données en entrée, tandis que le bloc HDFS est une division physique des données.
- La taille de bloc par défaut de HDFS est une taille de division par défaut si la division en entrée n'est pas spécifiée par le code.
- La division est définie par l'utilisateur et l'utilisateur peut contrôler la taille de la division dans son programme MapReduce.
- Une division peut être mappée à plusieurs blocs et il peut y avoir plusieurs divisions d'un bloc.
- Le nombre de tâches de mappage (mappeur) est égal au nombre de fractionnements en entrée.
Source: https://hadoopjournal.wordpress.com/2015/06/30/mapreduce-input-split-versus-hdfs-blocks/
La réponse courte est que InputFormat s'occupe de la division du fichier.
J'aborde cette question en examinant sa classe TextInputFormat par défaut:
Toutes les classes InputFormat sont une sous-classe de FileInputFormat, qui s’occupe de la division.
Plus précisément, la fonction getSplit de FileInputFormat génère une liste de InputSplit, à partir de la liste de fichiers définie dans JobContext. La division est basée sur la taille des octets, dont Min et Max pourraient être définis de manière arbitraire dans le fichier XML du projet.
Il existe un travail de réduction de carte séparé qui divise les fichiers en blocs. Utilisez FileInputFormat pour les gros fichiers et le format CombineFileInput pour les plus petits. Vous pouvez également vérifier si l’entrée peut être divisée en blocs selon la méthode issplittable. Chaque bloc est ensuite acheminé vers un nœud de données où une carte permet de réduire les travaux pour une analyse ultérieure. la taille d'un bloc dépend de la taille mentionnée dans le paramètre mapred.max.split.size.
FileInputFormat.addInputPath (travail, nouveau chemin (args [0])); ou
conf.setInputFormat (TextInputFormat.class);
class FileInputFormat funcation addInputPath , setInputFormat prend soin de inputplit, ce code définit également le nombre de mappeurs créés. nous pouvons dire que inputplit et le nombre de mappeurs sont directement proportionnels au nombre de blocs utilisés pour stocker le fichier d'entrée sur HDFS.
Ex. si nous avons un fichier d’entrée de 74 Mo, ce fichier est stocké sur HDFS en deux blocs (64 Mo et 10 Mo). donc inputplit pour ce fichier est deux et deux instances de mappeur sont créées pour lire ce fichier d'entrée.