Hadoop

GNU/Linux Magazine HS n° 078 | mai 2015 | Sébastien Chazallet
  • Actuellement 0 sur 5 étoiles
  • 1
  • 2
  • 3
  • 4
  • 5
Hadoop est un framework permettant la création d'applications distribuées (potentiellement sur des grappes de plusieurs milliers de serveurs) et pouvant supporter de grosses montées en charge afin de traiter des volumes de données de l'ordre du petaoctet.
Il est structuré autour de plusieurs composants que nous présenterons.

L'origine du projet remonte à 2004 lorsque Google publie un article présentant le MapReduce et son système de fichiers en cluster, le GoogleFS. Le concept est repris par Doug Cutting et Yahoo pour réaliser un outil libre et gratuit, qui sera utilisé par Yahoo pour son moteur de recherche avant que ce dernier ne décide de basculer vers Bing. Aujourd'hui, Hadoop est utilisé par tous les grands acteurs devant gérer de grandes quantités de données (Facebook en étant l'exemple le plus important avec 40 Ti de données compressées ajoutées chaque jour, mais on peut citer Twitter, LinkedIn, eBay, Oracle, Microsoft ou encore Amazon).

1. Présentation succincte de Hadoop

Hadoop vous permet de traiter des données peu ou pas du tout structurées. Ce n'est pas un remplacement à des solutions actuelles fonctionnant au-dessus de serveurs de bases de données relationnelles.

C'est un outil dédié exclusivement au big data. Utiliser Hadoop pour traiter moins de 20 Ti de données n'est pas optimal, d'autres solutions sont certainement mieux adaptées au traitement de « small » big data. Hadoop trouve son intérêt lorsqu'au moins 5 nœuds sont présents dans le cluster.

D'autre part, Hadoop n'est pas non plus conçu pour gérer des problématiques temps réel. Il ne peut pas répondre dans des temps courts à des requêtes portant sur de gros volumes, ce n'est pas ce pour quoi il a été conçu. Il existe un projet nommé Impala qui pourrait faire évoluer la donne, mais il est encore à un stade trop expérimental pour être intégré à un système d'information.

La technologie Hadoop représente un changement total de paradigme par rapport aux technologies habituellement utilisées dans les systèmes d'information. Les premiers pas avec Hadoop sont d'autant plus délicats et les premiers projets difficiles à appréhender.

Il assure la disponibilité et la durabilité des données par réplication, ce qui est exactement l'inverse de ce que l'on fait usuellement en utilisant les technologies RAID ou SAN qui permettent de minimiser l'espace de stockage utilisé tout en assurant la non-perte de données.

Il est scalable à la fois au niveau de sa capacité de stockage par ajout de disques supplémentaires ou au niveau de sa capacité de calcul par ajout de nouvelles machines. Le stockage comme le calcul sont distribués et co-localisés.

2. Architecture matérielle

Hadoop est conçu pour tourner sur plusieurs serveurs (au moins 5) : les nœuds du cluster. Chaque nœud est une machine hautement performante (au moins 4 CPU, 64Gb de RAM, plusieurs disques de plusieurs Ti). Hadoop exige également une configuration particulière du réseau : plusieurs interfaces réseau pour chaque machine et une configuration des switchs et des racks optimale.

Le dimensionnement du cluster est l'élément déterminant pour tout projet Hadoop. Afin de faire les meilleurs choix au niveau du matériel, vous devrez déterminer les besoins en capacités entrée/sortie, en mémoire, en CPU et en espace de stockage. Il est toujours assez facile de se procurer l'espace stockage suffisant. Il est moins évident de savoir parmi l'I/O, la RAM ou le CPU lequel sera limitant pour les traitements et devra être optimisé.

L'installation de la machine comme de Hadoop et de ses composants sur chaque serveur doit impérativement être testée d'une manière méthodique et reproductible et chaque serveur doit faire l'objet d'un benchmark à la recherche d'éventuels problèmes de comportement avant toute mise en production. Le cluster lui-même peut ensuite être testé à la recherche de contre-performances.

Il est également impératif d'ajouter un outil de supervision pour anticiper toute défaillance pendant le fonctionnement régulier du cluster. Sur cette problématique, on peut citer Nagios, Argus, Ganglia ou Zenoss.

3. Composants – écosystème

Cette section va nous permettre d'avoir un large aperçu des principaux composants de Hadoop, mais également de son écosystème. Chacun sera décrit succinctement de manière à être capable de percevoir son rôle et son positionnement par rapport aux autres composants, mais on ne fera ici qu'effleurer ce dont ces composants sont réellement capables.

Le tout devrait vous donner un ordre d'idée du potentiel de Hadoop et des composants qui pourraient vous donner envie d'aller plus loin.

Il faut savoir qu'il existe beaucoup de composants et qu'afin de s'y retrouver, il existe des distributions, c'est-à-dire des configurations toutes prêtes associant un choix de composants qui sont bien intégrés. Parmi ces distributions, on peut citer CDH, HDP, BigTop ou encore Cloudera.

3.1 HDFS

Le sigle HDFS signifie Hadoop distributed File System et, comme son nom l'indique, il s'agit d'un système de fichiers distribué sur lequel se base Hadoop et ses composants. Il a été développé en Java à partir du GoogleFS dans le but de permettre de gérer de très gros volumes de données en utilisant les différents disques d'une architecture physique de stockage comme un seul disque dur. Pour ce faire, il est construit au-dessus de la couche TCP/IP.

Il est constitué de deux composants principaux qui sont NameNode et DataNode. Le DataNode est l'exécutant : il permet de lire et écrire des blocs de données. Il communique régulièrement au NameNode (qui a un rôle de gestionnaire) la liste des blocs qu'il contient. Ce dernier permet de localiser des blocs de données répartis à travers l'ensemble de l'architecture physique, et de dupliquer les blocs qu'il estime trop peu répliqués (ils doivent l'être en moyenne 3 fois). Il s'assure également de la gestion de l'arborescence du système de fichiers et des métadonnées des fichiers et répertoires. Il est pensé avec comme objectif, le fait de favoriser la fiabilité et la rapidité des calculs.

Il existe des alternatives à HDFS, telles que QFS (Quantcast File System), écrit en C++, permettant d'offrir de meilleures performances et une meilleure efficacité avec l'augmentation de la taille du cluster. Ce projet est lui-même issu de KFS (Kosmos File System).

3.2 MapReduce

MapReduce de Hadoop est une plateforme de programmation implémentant le patron d'architecture éponyme. Ce dernier décrit une méthode permettant de réaliser des calculs sur de très larges quantités de données (au-delà du Ti), réparties sur plusieurs nœuds d'un cluster, le tout en utilisant des traitements parallèles et distribués.

Le nom vient de la concaténation du nom de deux fonctions emblématiques du paradigme de programmation fonctionnelle que sont map et reduce (il en existe bien d'autres parmi lesquelles filter, lambda, one ou all).

Le patron d'architecture MapReduce connaît un regain d'intérêt particulier depuis l'essor du Big Data étant donné qu'il en est l'élément central (avec le stockage), puisque c'est lui qui va gérer l'exécution de toutes les tâches (tous les autres outils de l'écosystème l'utilisent directement ou indirectement).

Par contre, il est un fait accompli que l'algorithme MapReduce de Hadoop doit encore être optimisé et ceci est un des gros enjeux du moment pour toutes les grandes sociétés devant manipuler des quantités de données significatives.

3.3 HCatalog

HCatalog est la couche permettant la gestion de l'index et du stockage. Cette couche se situe entre les données (HDFS), et les outils de haut niveau (Pig, Hive, MapReduce ou encore Streaming) pour lesquels elle dispose d'interfaces spécialisées (HCatLoader et HCatStorer pour Pig, HCatInputFormat et HCatOutputFormat pour MapReduce).

Elle est donc un composant vital et central. Elle permet d'abstraire le format de stockage des données et d'obtenir une vue relationnelle des données stockées.

Elle dispose également d'une API REST (WebHCat) qui peut se révéler particulièrement utile.

3.4 Pig

Pig est un outil de haut niveau permettant de créer des programmes map/reduce à utiliser avec Hadoop. Il utilise un langage nommé Pig Latin qui permet de s'abstraire du langage Java utilisé normalement pour écrire de telles tâches et pour se rapprocher de la notation SQL. Il est à noter que l'on peut étendre le langage par la création de fonctions, écrites en Java, Python, ou encore JavaScript, entre autres.

3.5 Hive

Hive (qui signifie ruche) est un système d'entrepôt de données (data warehouse) construit au-dessus de Hadoop dont la principale fonction consiste à fournir des méthodes permettant de structurer, requêter et analyser des données. En effet, Hive permet de fournir une structure à des données non ou peu structurées par l'utilisation du paradigme scheme-on-read.

C'est au moment de la lecture d'une donnée que Hive décide comment associer les composants de cette donnée aux colonnes existantes, mais aussi s'il doit modifier sa vision de la donnée par la modification des colonnes existantes et de leurs définitions, sachant que les données peuvent ne pas avoir le même nombre de colonnes. Tout ce qui ne peut pas être interprété est alors positionné à NULL.

Vu de l'extérieur, Hive permet de lisser la complexité inhérente aux données brutes Hadoop en permettant de faire des requêtes sur ces dernières avec une syntaxe proche du SQL, le HiveQL. Ces requêtes sont en réalité converties en tâches map/reduce, par exemple.

Hive dispose de fonctionnalités avancées d'indexation des données, de stockage de métadonnées, permet d'agir sur des données compressées et de manipuler différents types de données aisément, tels que les dates. Il contient aussi des outils de data mining.

3.6 HBase

HBase est une base de données non relationnelle, distribuée et orientée colonnes et écrite en Java, inspirée de BigTable de Google. Elle s'installe généralement sur un système de fichiers HDFS pour simplifier la distribution, mais ce n'est pas un prérequis. Elle est conçue pour gérer de très grandes quantités de données structurées.

Son orientation colonnes lui permet de sérialiser les données par colonnes et non par lignes comme le font les bases de données relationnelles classiques. Ceci permet de modifier les tables plus facilement (ajout, modification ou suppression de colonnes) et d'appliquer plus facilement des optimisations sur les colonnes (cibler les algorithmes de compressions par colonne, puisque la similarité des données permet d'utiliser le meilleur algorithme pour chaque colonne).

3.7 Trafodion

Trafodion est un projet permettant de fournir une interface SQL à HBase. Il vise à permettre d'effectuer des transactions de larges quantités de données de manière performante.

Il s'agit d'un projet très jeune créé par HP en juin 2014 (open source dès la création) et dont la première version prête pour la production est parue fin janvier 2015.

3.8 ZooKeeeper

ZooKeeper est un logiciel de gestion de configuration centralisé pour systèmes distribués, inspiré de Chubby de Google. Il est une brique essentielle pour assurer le bon fonctionnement et l'optimisation des autres composants de Hadoop et gère la synchronisation entre les différents serveurs d'un cluster.

3.9 Hadoop Streaming

Hadoop Streaming est un utilitaire fourni avec Hadoop qui permet de créer et de faire tourner des tâches map/reduce. Il est utilisable en ligne de commandes et est un moyen privilégié pour le lancement de ces tâches.

Il est utilisé, par exemple, pour intégrer des données, en les transformant par l'application de fonctions de transformations map/reduce. Peu importe la quantité de données, celles-ci sont intégrées par petits lots, potentiellement de manière concurrente.

3.10 Oozie

Oozie est un gestionnaire de workflow/planificateur conçu comme une application Web Java qui est spécifiquement conçue pour simplifier la coordination et l'ordonnancement des différents traitements.

Cet outil permet de lancer les tâches map/reduce pour Hadoop ou des tâches Pig, toutes deux nommées actions. Il peut aussi lancer d'autres actions secondaires, comme l'envoi d'un courriel, ou encore l'exécution d'une requête HTTP, par exemple.

L'utilisateur peut ainsi définir ses actions et les dépendances entre elles et Oozie va alors les modéliser sous la forme d'un worflow de nœuds et de flux, un flux étant un ensemble d'actions pouvant être exécutées de manière concurrente et un nœud étant un point de regroupement permettant de gérer la fin des actions, intégrant des mécanismes de contrôles (entre autres) et se terminant par une prise de décision sur les prochains flux à initier.

3.11 Spark

Apache Spark est un framework de calcul utilisant massivement : des primitives, la RAM pour y stocker les données, et des requêtes répétées sur les mêmes données stockées en mémoire. Par rapport à l'utilisation de l'algorithme map/reduce sur des blocs de données, le gain en performance peut être très significatif.

Il est composé de plusieurs composants bien distincts, le premier d'entre eux étant son cœur, Spark Core, qui permet de distribuer et de planifier les diverses tâches et qui gère les fonctionnalités basiques d'entrée / sortie.

Le niveau fondamental d'abstraction est nommé Resilient Distributed Datasets (RDDs). Il s'agit d'ensembles de données distribués. Il dispose d'une API en Java, Python ou Scala.

Spark SQL est un composant positionné au-dessus de Spark Core et fournissant un moyen de manipuler les données via l'utilisation d'une syntaxe proche du SQL.

Spark Streaming est une alternative à Hadoop Streaming utilisant les particularités de Spark. Il insère des données par lot en y appliquant au besoin des séries de transformations.

Spark est également doté d'algorithmes d'apprentissage parmi lesquels des outils statistiques, de corrélation, test d'hypothèses ou génération de données aléatoires, classification, régression, filtrage collaboratif, etc. (alternative à Mahout).

Graphx est un framework de génération de graphes à partir des données (alternative à Giraph).

C'est un projet qui peut être utilisé au sein de l'écosystème Hadoop ou en dehors ; il supporte de nombreux formats de stockage de données dont HDFS, ou Cassandra. C'est, à l'heure actuelle, le projet le plus actif de l'écosystème big data ainsi que de la fondation Apache (source openHub).

3.12 Impala

Cloudera Impala est un moteur de requêtage SQL massivement parallèle construit au-dessus de Hadoop. Il est écrit en C++, supporte le HDFS et HBase, utilise ODBC et la syntaxe SQL de Hive. Il est disponible pour utilisation en production depuis presque deux ans (Mai 2013).

3.13 Solr

Il s'agit d'un moteur de recherche bien connu dans d'autres contextes, initié par le projet Lucene. Il permet la recherche full-text et la recherche à facette, il est parfaitement adapté à un environnement cluster, il peut indexer en temps réel, supporte les bases de données relationnelles et les bases de données NoSQL au sens large. Il s'agit du moteur de recherche le plus populaire dans les SI des entreprises.

Il trouve donc naturellement sa place dans l'écosystème Hadoop.

3.14 Sqoop

Squoop est une interface en ligne de commandes permettant de transférer des données entre des bases de données relationnelles et Hadoop, et ceci de manière incrémentale.

Les importations sont les opérations depuis des bases de données relationnelles vers Hadoop et elles sont réalisées via des tâches qui sont capables d'insérer les données nouvelles depuis la dernière importation.

Les exports permettent le transfert de données depuis Hadoop vers une base de données relationnelle.

Il est à noter que Squoop permet aussi de communiquer avec d'autres types de bases de données, comme CouchBase, une base de données orientée document distribuée.

3.15 Flume

Apache Flume est une application distribuée permettant de collecter, agréger et déplacer de larges quantités de données. Elle utilise une architecture minimaliste basée sur des flux de données, elle est robuste, tolérante aux pannes et dispose de mécanismes de gestion d'erreurs et de reprise de service.

3.16 Mahout

Apache Mahout est un projet fournissant des services d'auto-apprentissage distribués. Pour l'instant, le projet gère entre autres le partitionnement de données, le filtrage collaboratif et la classification automatique, mais il est encore en phase de développement actif. Mahout dispose également de quelques bibliothèques mathématiques (algèbre linéaire et statistiques) et apporte de nouveaux objets de type Collection à Java.

3.17 DeepLearning4j

DeepLearning4j est une bibliothèque de calcul et d'apprentissage contenant des implémentations de divers algorithmes d'intelligence artificielle pouvant fonctionner de manière distribuée. Il s'agit d'un projet indépendant pouvant être ajouté à l'écosystème Hadoop ou Spark.

3.18 GoeMesa

GeoMesa est une application distribuée fournissant des possibilités de calcul au niveau spatio-temporel, en utilisant la bibliothèque Geohash. Cette application peut gérer, indexer et requêter des millions de paramètres géométriques (2D ou 3D) et temporels.

3.19 Hue

Hue est une application Web permettant de gérer l'ensemble des outils de l'écosystème Hadoop. Son but principal consiste d'une part à réunir en un seul endroit la gestion de plusieurs applications, mais aussi à simplifier drastiquement l'expérience utilisateur, en particulier des utilisateurs qui ont des besoins limités.

On peut distinguer plusieurs sections :

- navigateur de fichiers pour HDFS ;

- gestionnaire de tâches pour map/reduce ;

- navigateur pour HBase ;

- éditeur de requêtes pour Hive, Pig ou Impala ;

- éditeur pour Sqoop ;

- éditeur et tableau de bord pour Oozie ;

- créateur de tableau de bord pour Solr ;

- navigateur pour ZooKeeper ;

- éditeur Spark ;

- éditeur SQL pour bases de données relationnelles traditionnelles.

3.20 Hama

Apache Hama est un framework de calcul distribué permettant le calcul scientifique (calcul matriciel), de graphes et de réseaux. Le nom Hama est simplement le diminutif de HAdoop MAtrix. Il est également inspiré de Pregel.

Il se différencie par l'utilisation du parallélisme Bulk (une technique de parallélisme différente de celles utilisées usuellement), utilise trois composants essentiels qui sont ZooKeeper, GroomServer (réalise les tâches) et BSPMaster (rôle de supervision, contrôle, planification et donneur d'ordre aux GroomServers).

3.21 Giraph

Apache Giraph est un projet permettant de générer des graphes à partir de larges volumes de données. C'est également un projet inspiré par un projet Google nommé Pregel.

3.22 Jumbune

Jumbune est une application modulaire permettant de surveiller l'état de fonctionnement du cluster et ses paramètres, d'analyser les tâches et visualiser leur état, leur consommation en ressources, les grappes utilisées ou donner quelques pistes sur les marges d'optimisation.

Elle permet également la détection d'erreurs sur les données HDFS d'une manière efficace et sert à l'aide au débogage.

4. Installation de Hadoop en local

Hadoop est certes fait pour être installé sur un cluster de serveurs, mais lorsque l'on souhaite juste tester la solution ou faire du développement, il est nécessaire de l'installer en local sur son poste de travail.

Ceci ne permettra absolument pas d'avoir la moindre idée de la performance finale de nos travaux en conditions réelles, mais c'est un prérequis pour commencer à travailler avec la solution.

4.1 Préparation de l'installation

Comme on l'a vu, Hadoop est écrit en Java. Il faut donc s'assurer d'avoir Java installé sur sa machine (ce qui est, la plupart du temps, déjà le cas. On peut le vérifier ainsi :

$ java -version

java version "1.7.0_75"

OpenJDK Runtime Environment (IcedTea 2.5.4) (7u75-2.5.4-1~deb7u1)

OpenJDK 64-Bit Server VM (build 24.75-b04, mixed mode)

La version 1.5 est obligatoire, la version 1.6 est recommandée. Par contre, l'OpenJDK est largement suffisant.

Dans le cas où l'on ne dispose pas de la bonne version, il faut procéder ainsi pour l'installation :

$ sudo aptitude install openjdk-7-jre

L'autre point important consiste à utiliser un utilisateur dédié :

$ sudo addgroup hadoop

$ sudo adduser --ingroup hadoop hadoop

Il faut maintenant, pour se faciliter la tâche, configurer l'accès SSH à localhost et permettre l'accès sans mot de passe (ce qui n'est pas à reproduire en production, bien entendu) :

$ su – hadoop

ssh-keygen -t rsa -P ""

$ cp .ssh/id_rsa.pub .ssh/authorized_keys

Attention, cette dernière commande ne fonctionne que parce que l'on vient de créer le compte.

Si tout se passe bien, on peut se connecter en SSH ainsi :

$ ssh localhost

$ exit

Enfin, pour pouvoir tester dans des conditions réelles Hadoop, il faut créer un répertoire destiné à accueillir les données :

$ mkdir ~/data

$ chmod 777 ~/data

On est maintenant prêt à réaliser l'installation de Hadoop.

4.2 Installation de Hadoop

La première chose à faire consiste à trouver un miroir pour télécharger Hadoop. La version que l'on télécharge ici est Hadoop 2.6.0. La liste des miroirs est celle-ci : http://www.apache.org/dyn/closer.cgi/hadoop/core.

On se place alors dans le répertoire souhaité pour réaliser l'installation (répertoire dont l'utilisateur et le groupe sont ceux que nous venons de définir), puis :

$ tar xzf hadoop-2.6.0.tar.gz

$ mv hadoop-2.6.0 hadoop

Il faut maintenant rajouter ces quelques lignes au fichier .bashrc de notre utilisateur (à adapter le cas échéant, par exemple pour le JAVA_HOME qui peut différer) :

export HADOOP_HOME=/home/hadoop/hadoop

export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64

 

unalias fs &> /dev/null

alias fs="hadoop fs"

unalias hls &> /dev/null

alias hls="fs -ls"

 

lzohead () {

hadoop fs -cat $1 | lzop -dc | head -1000 | less

}

 

export PATH=$PATH:$HADOOP_HOME/bin :$HADOOP_HOME/sbin

 

export HADOOP_MAPRED_HOME=$HADOOP_HOME

export HADOOP_COMMON_HOME=$HADOOP_HOME

export HADOOP_HDFS_HOME=$HADOOP_HOME

export YARN_HOME=$HADOOP_HOME

export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native

export HADOOP_OPTS="-Djava.library.path=$HADOOP_HOME/lib"

On peut ensuite relire le fichier et pratiquer quelques tests pour vérifier que tout va bien :

$ source .bashrc

$ echo $HADOOP_HOME

/home/hadoop/hadoop

$ ls `echo $HADOOP_HOME`

bin include libexec NOTICE.txt sbin

etc lib LICENSE.txt README.txt share

$ ls `echo $JAVA_HOME`

ASSEMBLY_EXCEPTION docs jre man THIRD_PARTY_README

bin include lib src.zip

$ echo $PATH

/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/home/hadoop/hadoop/bin

Dès que l'ensemble des tests est satisfaisant, il faut régler un dernier détail. En effet, malgré le fait que l'on ait mis la variable d'environnement JAVA_HOME en place, il faut la mettre également en direct dans le fichier hadoop/etc/hadoop/hadoop-env.sh en replaçant la ligne suivante :

export JAVA_HOME=${JAVA_HOME}

Par :

export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64

4.3 Configuration de Hadoop

Une fois Hadoop installé, on dispose d'une plateforme quasiment prête à partir. Il reste cependant nécessaire de remplir quelques fichiers de configuration qui sont tous centralisés dans le répertoire hadoop/etc/hadoop/.

Le premier d'entre eux est core-site.xml. Il contient juste la balise principale <configuration> vide. Il faut rajouter ceci :

<configuration>

<property>

<name>hadoop.tmp.dir</name>

<value>/home/hadoop/data</value>

<description>directory for hadoop data</description>

</property>

<property>

<name>fs.default.name</name>

<value>hdfs://localhost:9090</value>

<description>How to access HDFS</description>

</property>

</configuration>

La première propriété permet de déclarer que nous allons utiliser le répertoire précédemment créé en tant que racine du stockage de notre fichier de données. La seconde permet de déclarer le port qui sera utilisé (HDFS fonctionne au-dessus de TCP/IP, pour rappel).

Ensuite, il faut dupliquer le fichier suivant mapred-site.xml.template et aller modifier la copie nouvellement créée :

$ cp hadoop/etc/hadoop/mapred-site.xml.template hadoop/etc/hadoop/mapred-site.xml

$ vim hadoop/etc/hadoop/mapred-site.xml

<configuration>

<property>

<name>mapred.job.tracker</name>

<value>localhost:9091</value>

<description>Mapred job tracker</description>

</property>

Cette propriété permet de déclarer la manière de se connecter au service Map/Reduce.

Enfin, il est également nécessaire de modifier le fichier hdfs-site.xml :

<configuration>

<property>

<name>dfs.replication</name>

<value>1</value>

</property>

</configuration>

Cette propriété permet de préciser le nombre de réplications de chaque bloc par défaut (en local, on cherche à ne pas trop dépenser d'espace disque, le risque de perte de données n'est pas un souci).

Une fois ce travail effectué, il est nécessaire de créer le système de fichiers HDFS :

$ hdfs namenode -format

On peut alors lancer le système :

$ start-dfs.sh

$ start-yarn.sh

Tout devrait être maintenant opérationnel, ce qui peut se vérifier ainsi :

$ jps

13277 DataNode

13446 SecondaryNameNode

13701 NodeManager

13845 Jps

12664 ResourceManager

13181 NameNode

Cette commande permet en effet de voir la liste des processus reliés à Hadoop qui tournent sur la machine.

On peut chercher à vérifier que Hadoop utilise bien les ports qui lui ont été assignés :

$ sudo netstat -plten | grep 9090

$ sudo netstat -plten | grep 9091

On peut maintenant aller sur localhost:8088 et découvrir/jouer un peu avec l'interface.

5. Commandes à connaître

Il existe un certain nombre de commandes permettant de donner des ordres à Hadoop, elles sont similaires à celles de Bash :

$ hadoop fs -mkdir /path/to/create

$ hadoop fs -ls /path/to/list

$ hadoop fs -lsr /path/to/lsr

$ hadoop fs -touch /path/to/file/file.txt

$ hadoop fs -cat /path/to/file/file.txt

$ hadoop fs -stat /path/to/file/or/directory

$ hadoop fs -cp /path/to/source /path/to/destination

$ hadoop fs -mv /path/to/source /path/to/destination

$ hadoop fs -rm /path/to/file

$ hadoop fs -rmr /path/to/directory

$ hadoop fs -tail /path/to/file

$ hadoop fs -mkdir /path/to/create

$ hadoop fs -mkdir /path/to/create

$ hadoop fs -du /path/to/file # taille du fichier agrégé (aggregate lenght)

$ hadoop fs -dus /path/to/file # taille du fichier simple (summary lenght)

$ hadoop fs -chmod MODE [-R] /path/to/update

$ hadoop fs -chown USER [-R] /path/to/update

$ hadoop fs -chgrp GROUP [-R] /path/to/update

$ hadoop fs -chown USER:GROUP [-R] /path/to/update

Il existe aussi certaines commandes particulières (les explications sont données en commentaire) :

$ hadoop fs -put /path/to/local/source /path/to/destination # copie du local vers le distant

$ hadoop fs -get /path/to/source path/to/local/destination # copie du distant vers le local

$ hadoop fs -test -e /path/to/file/or/directory # teste l'existence

$ hadoop fs -test -z /path/to/file/ # teste la non-nullité de la taille du fichier

$ hadoop fs -test -d /path/to/file/or/directory # teste si le chemin correspond à un fichier ou un répertoire

$ hadoop fs -expung # vider la corbeille

$ hadoop fs -setrep /path/to/file # changer le facteur de réplication d'un fichier

$ hadoop fs -setrep -R /path/to/directory # changer le facteur de réplication d'un répertoire.

Conclusion

Hadoop est donc un univers à part entière. Y entrer nécessite du temps et des efforts, mais cela peut valoir le coup, ne serait-ce que parce que cette technologie est relativement jeune et a sans conteste un grand avenir devant elle, sans prétendre maîtriser l'art de la divination.

Une conséquence de cela est qu'il y a aujourd'hui peu de spécialistes du domaine et qu'il y a fort à parier que la demande en compétences sur ce sujet va probablement sérieusement augmenter dans les années à venir.

On peut encore relativiser cela en disant qu'à cette heure, peu d'entreprises ont réellement besoin d'une telle architecture, mais si elle se développe, devient facile à mettre en œuvre, coûte de moins en moins cher, il n'est pas impossible que le besoin se crée, simplement parce que beaucoup plus d'entreprises se mettront à collecter des données et se créeront ainsi le besoin d'une architecture telle que Hadoop.