Database
 sql >> Base de données >  >> RDS >> Database

Présentation des types et formats MapReduce

Hadoop utilise le modèle de programmation MapReduce pour le traitement des données d'entrée et de sortie de la carte et pour réduire les fonctions représentées sous forme de paires clé-valeur. Ils sont soumis à l'exécution parallèle d'ensembles de données situés dans un large éventail de machines dans une architecture distribuée. Le paradigme de la programmation est essentiellement de nature fonctionnelle en combinant tout en utilisant la technique de cartographie et de réduction. Cet article présente le modèle MapReduce, et en particulier, comment les données dans différents formats, du simple texte aux objets binaires structurés, sont utilisées.

Types MapReduce

Cartographie est la technique de base du traitement d'une liste d'éléments de données qui se présentent sous la forme de paires de clés et de valeurs. La fonction map s'applique aux éléments individuels définis comme des paires clé-valeur d'une liste et produit une nouvelle liste. L'idée générale de la fonction map et reduce de Hadoop peut être illustrée comme suit :

map: (K1, V1) -> list (K2, V2)
reduce: (K2, list(V2)) -> list (K3, V3)

Les paramètres d'entrée de la paire clé et valeur, représentés respectivement par K1 et V1, sont différents du type de paire de sortie :K2 et V2. La fonction de réduction accepte le même format de sortie par la carte, mais le type de sortie de l'opération de réduction est à nouveau différent :K3 et V3. L'API Java pour cela est la suivante :

public interface Mapper<K1, V1, K2, V2> extends JobConfigurable,
      Closeable {
   void map(K1 key, V1 value, OutputCollector<K2, V2> output,
      Reporter reporter) throws IOException;
}

public interface Reducer<K2, V2, K3, V3> extends JobConfigurable,
      Closeable {
   void reduce(K2 key, Iterator<V2> values,
      OutputCollector<K3, V3> output, Reporter reporter)throws
         IOException;
}

Le OutputCollector est l'interface généralisée du framework Map-Reduce pour faciliter la collecte de données en sortie soit par le Mapper ou le Réducteur . Ces sorties ne sont que des sorties intermédiaires du travail. Par conséquent, ils doivent être paramétrés avec leurs types. Le journaliste facilite l'application Map-Reduce pour signaler la progression et mettre à jour les compteurs et les informations d'état. Si, toutefois, la fonction de combinaison est utilisée, elle a la même forme que la fonction de réduction et la sortie est envoyée à la fonction de réduction. Cela peut être illustré comme suit :

map: (K1, V1) -> list (K2, V2)
combine: (K2, list(V2)) -> list (K2, V2)
reduce: (K2, list(V2)) -> list (K3, V3)

Notez que les fonctions combiner et réduire utilisent le même type, sauf dans les noms de variables où K3 est K2 et V3 est V2.

La fonction de partition opère sur les types clé-valeur intermédiaires. Il contrôle le partitionnement des clés des sorties intermédiaires de la carte. La clé dérive la partition à l'aide d'une fonction de hachage typique. Le nombre total de partitions est identique au nombre de tâches de réduction pour le travail. La partition est déterminée uniquement par la clé en ignorant la valeur.

public interface Partitioner<K2, V2> extends JobConfigurable {
   int getPartition(K2 key, V2 value, int numberOfPartition);
}

C'est l'essence même des types MapReduce en bref.

Formats d'entrée

Hadoop doit accepter et traiter une variété de formats, des fichiers texte aux bases de données. Un morceau d'entrée, appelé division d'entrée , est traité par une seule carte. Chaque division est ensuite divisée en enregistrements logiques donnés à la carte pour être traités dans une paire clé-valeur. Dans le contexte d'une base de données, la séparation signifie la lecture d'une plage de tuples à partir d'une table SQL, comme le fait le DBInputFormat et produire des LongWritables contenant des numéros d'enregistrement comme clés et DBWritables comme valeurs. L'API Java pour les fractionnements d'entrée est la suivante :

public interface InputSplit extends Writable {
   long getLength() throws IOException;
   String[] getLocations() throws IOException;
}

Le InputSplit représente les données à traiter par un Mappeur . Il renvoie la longueur en octets et a une référence aux données d'entrée. Il présente une vue orientée octet sur l'entrée et relève de la responsabilité du RecordReader du travail pour traiter cela et présenter une vue orientée enregistrement. Dans la plupart des cas, nous ne traitons pas avec InputSplit directement car ils sont créés par un InputFormat . C'est sous la responsabilité de InputFormat pour créer les fractionnements d'entrée et les diviser en enregistrements.

public interface InputFormat<K, V> {
   InputSplit[] getSplits(JobConf job, int numSplits) throws
      IOException;

   RecordReader<K, V> getRecordReader(InputSplit split,
      JobConf job, throws IOException;
}

Le JobClient invoque le getSplits() méthode avec le nombre approprié d'arguments fractionnés. Le nombre donné est un indice car le nombre réel de fractionnements peut être différent du nombre donné. Une fois la répartition calculée, elle est envoyée au jobtracker. Le jobtracker planifie les tâches de mappage pour les tasktrackers à l'aide de l'emplacement de stockage. Le suivi des tâches passe ensuite le fractionnement en appelant getRecordReader() méthode sur InputFormat pour obtenir RecordReader pour la scission.

Le FileInputFormat est la classe de base pour la source de données du fichier. Il a la responsabilité d'identifier les fichiers qui doivent être inclus comme entrée de travail et la définition pour générer la division.

Hadoop inclut également le traitement de données non structurées qui se présentent souvent sous forme textuelle. Le TextInputFormat est le InputFormat par défaut pour ces données.

Le SequenceInputFormat prend des entrées binaires et stocke des séquences de paires clé-valeur binaires.

De même, DBInputFormat offre la possibilité de lire des données à partir d'une base de données relationnelle à l'aide de JDBC.

Formats de sortie

Les classes de format de sortie sont similaires à leurs classes de format d'entrée correspondantes et fonctionnent dans le sens inverse.

Par exemple, le TextOutputFormat est le format de sortie par défaut qui écrit les enregistrements sous forme de fichiers texte brut, alors que les valeurs-clés peuvent être de n'importe quel type, et les transforme en une chaîne en appelant le toString() méthode. Le caractère clé-valeur est séparé par le caractère de tabulation, bien que cela puisse être personnalisé en manipulant la propriété séparateur du format de sortie du texte.

Pour la sortie binaire, il y a SequenceFileOutputFormat pour écrire une séquence de sortie binaire dans un fichier. Les sorties binaires sont particulièrement utiles si la sortie devient l'entrée d'une autre tâche MapReduce.

Les formats de sortie pour les bases de données relationnelles et vers HBase sont gérés par DBOutputFormat . Il envoie la sortie réduite à une table SQL. Par exemple, le TableOutputFormat de HBase permet au programme MapReduce de travailler sur les données stockées dans la table HBase et de les utiliser pour écrire des sorties dans la table HBase.

Conclusion

C'est, en bref, le nœud des types et des formats MapReduce. Reportez-vous à la liste dans la référence ci-dessous pour obtenir plus de détails à leur sujet. Il existe de nombreux détails complexes sur les fonctions des API Java qui ne deviennent plus clairs que lorsque l'on plonge dans la programmation. Reportez-vous à la documentation de l'API Java Apache Hadoop pour plus de détails et commencez à coder certaines pratiques.

Références

  • Tom White, Hadoop Le guide définitif , O'Reilly
  • Documents sur l'API Java Apache Hadoop