Hadoop – பகுதி 2

ஒரே ஒரு கணினியில் hadoop-ஐ நிறுவினால் அது single node cluster-எனவும், பல்வேறு server-களை இணைத்து நிறுவினால் அது multi-node cluster எனவும் அழைக்கப்படும். இங்கு Ubuntu 16.04 எனும் கணினியில் நிறுவுவது பற்றி பார்க்கலாம்.

1. Hadoop எனும் கட்டமைப்பு Java-ல் எழுதப்பட்டிருப்பதால், முதலில் நமது கணினியில் Java நிறுவப்பட்டுள்ளதா என்பதை $ java -versionஎனக் கொடுத்து சோதிக்கவும். இது பின்வருமாறு ஒரு வெளியீட்டைக் கொடுத்தால் java நிறுவப்பட்டுள்ளது என்று அர்த்தம். இல்லையெனில் பின்வருமாறு கொடுத்து அதனை நிறுவவும்.

$ sudo apt-get install default-jdk

2. பின்னர் hadoop-க்கான முகவரியிலிருந்து அதனை பதிவிறக்கம் செய்யவும். அதனைப் பிரித்து தரவிறக்கப்பட்ட இடத்திலிருந்து நமக்கு வேண்டிய இடத்திற்கு மாற்றிக் கொள்ளவும். மாற்றப்பட்ட directory-க்கான முழு அனுமதிகளையும் பயனருக்கு வழங்க வேண்டும்.

$ wget redrockdigimark.com/apachemirror/hadoop/common/hadoop-3.0.0/hadoop-3.0.0.tar.gz
$ tar -xzvf hadoop-3.0.0.tar.gz
$ sudo mv ~/hadoop-3.0.0 /usr/local/hadoop
$ sudo chown -R nithya:nithya /usr/local/hadoop


3. Hadoop என்பது கணினிகளுடன் பேசுவதற்கு Secured Shell (SSH) -ஐப் பயன்படுத்துகிறது. அப்போது நாம் ஒவ்வொருமுறையும் சரியான கடவுச்சொல்லை அளித்தால் மட்டுமே அதனுடன் பேச முடியும். இதனைத் தவிர்க்க SSH-ன் சான்றிதழை எடுத்து அதனை அங்கீகரிக்கப்பட்ட திறவுகோல்களின் பட்டியலில் இணைத்தால் போதுமானது. ஒவ்வொரு கணினியும் கடவுச்சொல் இல்லாமலேயே தங்களுடன் ஒன்றோடொன்று பேசிக்கொள்ள முடியும்.

$ ssh-keygen
$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

கோப்பின் பெயர் மற்றும் passphrase ஆகியவற்றைக் கேட்டு இக்கட்டளை நிற்கும் போதெல்லாம் ஒன்றும் அளிக்காமல் enter-ஐ மட்டும் கொடுக்கவும்.

இது நமது home directory-ல் .rsa எனும் folder-ஐ உருவாக்கி, அதற்குள் பின்வருமாறு கோப்புகளை உருவாக்கும்.
• id_rsa (தனிப்பட்ட திறவுகோல்)
• id_rsa.pub (பொதுவான திறவுகோல்)
• authorised_keys (அங்கீகரிக்கப்பட்ட திறவுகோல்கள்)
இதில் id_rsa.pubஎன்பதுதான் SSH-க்கான சான்றிதழ். இதனை நாம் authorised_keys என்பதற்குள் போட வேண்டும். இதேபோல் ஒன்றோடொன்று இணைக்கப்பட்டுள்ள ஒவ்வொரு கணினியிலிருந்தும் அதனதன் id_rsa.pubகோப்பினை SCP செய்து அவற்றையும் இந்த authorised_keys-க்குள் போட வேண்டும். இவ்வாறு செய்தால் ஒவ்வொரு கணினியும் கடவுச்சொல் இல்லாமலேயே தங்களுடன் பேசிக் கொள்ள முடியும்.

4. அடுத்ததாக நமது home directory-ல் உள்ள .bashrc எனும் கோப்பிற்குள் கடைசியில் சென்று பின்வரும் விவரங்களை இணைக்க வேண்டும். ஒருசில மதிப்புகள் தெரியவில்லையெனில் echo $Variablename எனக் கொடுத்து அதன் மதிப்பினைப் பெறலாம். உதாரணத்துக்கு echo $JAVA_HOME எனும் கட்டளை நமது கணினியில் java நிறுவப்பட்டுள்ள இடத்தின் பாதையைக் காட்டும். அதை எடுத்து இங்கு பயன்படுத்தலாம்.

$ vim ~/.bashrc
#HADOOP VARIABLES START
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/jre/
export HADOOP_INSTALL=/usr/local/hadoop/hadoop-3.0.0
export PATH=$PATH:$HADOOP_INSTALL/bin
export PATH=$PATH:$HADOOP_INSTALL/sbin
export HADOOP_MAPRED_HOME=$HADOOP_INSTALL
export HADOOP_COMMON_HOME=$HADOOP_INSTALL
export HADOOP_HDFS_HOME=$HADOOP_INSTALL
export YARN_HOME=$HADOOP_INSTALL
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_INSTALL/lib/native
export HADOOP_OPTS=”-Djava.library.path=$HADOOP_INSTALL/lib”
#HADOOP VARIABLES END
$ source ~/.bashrc


5. பின்னர் hadoop folder-க்குள் உள்ள configuration files-ல் செய்ய வேண்டிய மாற்றங்களைப் பின்வருமாறு காணலாம். Hadoop ஒவ்வொரு முறை செயல்படத் துவங்கும்போதும் இதில் காணப்படுகின்ற மதிப்புகளை வைத்தே தனது செயல்பாட்டினைத் துவக்கும்.

5.1. hadoop-env.sh என்பதற்குள் பின்வருமாறு சேர்க்கவும் அல்லது ஏற்கனவே comment செய்யப்பட்டு இருப்பின் uncomment செய்துவிடவும்.

$ sudo vim /usr/local/hadoop/hadoop-3.0.0/etc/hadoop/hadoop-env.sh
JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/jre/

5.2. core-site.xml என்பதற்குள் config. tags-க்கிடையில் பின்வருமாறு சேர்க்கவும். பின்னர் இதில் குறிப்பிட்டுள்ளது போலவே ஒரு directory-ஐ உருவாக்கி அதற்கு முழு அனுமதிகளையும் வழங்க வேண்டும்.

$ sudo vim /usr/local/hadoop/hadoop-3.0.0/etc/hadoop/core-site.xml
<configuration>
<property>
<name>hadoop.tmp.dir</name>
<value>/app/hadoop/tmp</value>
<description>A base for other temporary directories.</description>
</property>

<property>
<name>fs.default.name</name>
<value>;
<description>The name of the default file system. A URI whose
scheme and authority determine the FileSystem implementation. The
uri’s scheme determines the config property (fs.SCHEME.impl) naming
the FileSystem implementation class. The uri’s authority is used to
determine the host, port, etc. for a filesystem.</description>
</property>
</configuration>

$ sudo mkdir -p /app/hadoop/tmp
$ sudo chown -R nithya:nithya /app


5.3. mapred-site.xml.template என்று இருந்தால் mapred-site.xml என பெயர்மாற்றம் செய்து விடவும். பின்னர் அதன் config. tags-க்கிடையில் பின்வருமாறு சேர்க்கவும்.
$ sudo mv /usr/local/hadoop/hadoop-3.0.0/etc/hadoop/mapred-site.xml.template /usr/local/hadoop/hadoop-3.0.0/etc/hadoop/mapred-site.xml
$ sudo vim /usr/local/hadoop/hadoop-3.0.0/etc/hadoop/mapred-site.xml
<configuration>
<property>
<name>mapred.job.tracker</name>
<value>localhost:54311</value>
<description>The host and port that the MapReduce job tracker runs
at. If “local”, then jobs are run in-process as a single map
and reduce task.
</description>
</property>
<configuration>

5.4. hdfs-site.xml என்பதற்குள் config. tags-க்கிடையில் பின்வருமாறு சேர்க்கவும். பின்னர் இதில் குறிப்பிட்டுள்ளது போலவே directories-களை உருவாக்கி அதற்கு முழு அனுமதிகளையும் வழங்கவும்.
$ sudo vim /usr/local/hadoop/hadoop-3.0.0/etc/hadoop/hdfs-site.xml
<configuration>
<property>
<name>dfs.replication</name>
<value>1</value>
<description>Default block replication.
The actual number of replications can be specified when the file is created.
The default is used if replication is not specified in create time.
</description>
</property>
<property>
<name>dfs.namenode.name.dir</name>
<value>file:/usr/local/hadoop_store/hdfs/namenode</value>
</property>
<property>
<name>dfs.datanode.data.dir</name>
<value>file:/usr/local/hadoop_store/hdfs/datanode</value>
</property>
<configuration>
$ sudo mkdir -p /usr/local/hadoop_store/hdfs/namenode
$ sudo mkdir -p /usr/local/hadoop_store/hdfs/datanode
$ sudo chown -R nithya:nithya /usr/local/hadoop_store


6. பின்னர் hosts கோப்பிற்குள் அனைத்துக் கணினிகளின் IP முகவரி மற்றும் hostname-ஐச் சேர்க்க வேண்டும்.
$ sudo vim /etc/hosts
192.168.1.2 nithya-Lenovo-ideapad

7. கடைசியாக hfs-ஐ ஒருமுறை format செய்து பயன்படுத்தத் தொடங்கவும். துவங்கிய பின் இடையில் எப்போதும் இக்கட்டளையை அளிக்கக் கூடாது. அவ்வாறு செய்தால் hfs-ல் சேமிக்கப்பட்டுள்ள அனைத்துத் தகவல்களும் அழிக்கப்பட்டு datanode-ல் பிரச்சனை ஏற்பட்டுவிடும்.
$ hadoop namenode -format

8. sbin எனுமிடத்தில் ஒவ்வொரு services-ஐயும் தனித்தனியாகத் துவக்குவதற்குத் தேவையான shell scripts அனைத்தும் காணப்படும். start-dfs.sh எனும் கட்டளை namenode, datanode, secondary namenode ஆகியவற்றையும், start-yarn.sh எனும் கட்டளை resourcemanager,nodemanagers ஆகியவற்றையும் துவக்கும்.
தனித்தனியாகத் துவக்குவதற்குப் பதிலாக start-all.sh எனக் கொடுத்து அனைத்தையும் ஒரே நேரத்தில் துவக்கலாம். jps எனக் கொடுத்து services வெளிப்படுகின்றனவா என உறுதி செய்து கொள்ளவும். அவ்வாறே stop-all.sh என்பது நிறுத்த உதவும்.
$ /usr/local/hadoop/hadoop-3.0.0/sbin/start-all.sh
$ jps
$ stop-all.sh

இதில் Namenode வெளிப்படவில்லை. எனவே namenode, datanode ஆகியவற்றில் உள்ள கோப்புகளை எல்லாம் நீக்கிவிட்டு மீண்டும் ஒருமுறை format செய்து துவக்கவும்.
$ sudo rm -rf /usr/local/hadoop_store/hdfs/namenode/*
$ sudo rm -rf /usr/local/hadoop_store/hdfs/datanode/*
$ hadoop namenode -format

இப்போது NameNode வெளிப்படுவதைக் காணலாம்.
9. பின்வரும் கட்டளை hadoop-ன் இயக்கத்தை உறுதி செய்யும்.
$ /usr/local/hadoop/hadoop-3.0.0/bin/hadoop

10. hdfs-க்குள் தகவல்களைக் கையாள்வதற்கு உதவும் கட்டளைகளைப் பற்றிப் பார்க்கலாம். இது பெரும்பாலும் linux கட்டளைகளை ஒத்திருக்கும். linux கட்டளைகளுக்கு முன்னர் hadoop fs – என்பது இடம் பெற்றிருக்கும்.
$ hdfs fs -ls / (hdfs-ன் root directory-ல் உள்ளவற்றைப் பட்டியலிடும்)
$ hadoop fs -mkdir /input (root-ல் input எனும் folder-ஐ உருவாக்கும்)
$ hadoop fs -put ~/Kanchi.txt /input (இது ஓரிடத்திலுள்ள கோப்பினை hdfs-க்குள் செலுத்தும் i.e upload)
$ hadoop fs -copyFromLocal ~/Kanchi.txt /input (இதுவும் put போன்றதே. ஆனால் நமது கணினியில் இருந்து மட்டும்தான் பிரதி செய்யும்)
$ hadoop fs -get /input/Kanchi.txt ~/ (இது hdfs-ல் உள்ள கோப்பினை ஓரிடத்தில் செலுத்தும் i.e download)
$ hadoop fs – copyToLocal /input/Kanchi.txt ~/ (இதுவும் get போன்றதே. ஆனால் hdfs-ல் உள்ள கோப்பினை நமது கணினியில் மட்டும்தான் செலுத்தும்)
$ hadoop fs -cat /input/Kanchi.txt (கோப்பிலுள்ள தகவல்களை வெளிக்காட்டும்)
$ hadoop fs -tail /input/Kanchi.txt (கோப்பிலிருந்து கடைசி ஒருசில வரிகளை வெளிப்படுத்தும்)
$ hadoop fs -du /input/Kanchi.txt (கோப்பின் நீளத்தை காண உதவும்)
$ hadoop fs -mv /input/Kanchi.txt /input/place/Kanchi.txt (கோப்பினை இடமாற்றம் செய்யும்)
$ hadoop fs -rm /input/place/Kanchi.txt (கோப்பினை நீக்கும்)
$ hadoop fs -rmr /input (கோப்புகளுடன் சேர்த்து directory-ஐ நீக்கும்)




11. ஏற்கனவே உள்ள mapreducer program-ஐ வைத்து ஒரு கோப்பிற்குள் ஒரு குறிப்பிட்ட வார்த்தை எத்தனை முறை இடம்பெற்றுள்ளது என்பதைக் கண்டுபிடிக்கலாம். இதற்கான கட்டளை பின்வருமாறு.

$ /usr/local/hadoop/hadoop-3.0.0/bin/hadoop jar /usr/local/hadoop/hadoop-3.0.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.0.0.jar grep /input /output ‘is[.]*’

இதற்கான விளக்கம்:

• முதலில் நமது கணினியில் உள்ள கோப்பினை hdfs-ன் ரூட் (/) க்குள் செலுத்த வேண்டும்.
$ hadoop fs -put ~/Kanchi.txt /input
• அடுத்து hdfs-ல் சேமிக்கப்பட்டுள்ள கோப்பினை உள்ளீடாக எடுத்துக்கொண்டு அதிலுள்ள ஒவ்வொரு வார்த்தையும் எத்தனை முறை திரும்பத் திரும்ப வந்துள்ளது என்பதற்கான mapreducer program ஒரு jar file-ஆக ஏற்கனவே எழுதப்பட்டுள்ளது ( hadoop-mapreduce-examples-3.0.0.jar) . இதனை hadoop directory-க்குள் share/hadoop/mapreduce எனுமிடத்தில் காணலாம். இக்கட்டளை grep மூலம் /input எனுமிடத்தில் உள்ள கோப்பினை உள்ளீடாக எடுத்துக்கொண்டு, அதில் is என்பது எத்தனை முறை இடம்பெற்றுள்ளது என்பதைக் கண்டறிந்து /output எனுமிடத்தில் வெளிப்படுத்தியுள்ளது.
/usr/local/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.0.0.jar grep /input /output ‘is[.]*’
• கடைசியாக /usr/local/hadoop/bin/hadoop மூலம் இக்கட்டளை இயக்கப்படுகிறது. இது jar எனும் parameter-ஐப் பயன்படுத்தி இந்த jar program-ஐ இயக்குகிறது. கடைசியாக /output எனுமிடத்தில் சென்று பார்த்தால் இதன் வெளியீடாக _SUCCESS , part-r-00000 எனுமிரண்டு கோப்புகள் இடம் பெற்றிருக்கும்.
• part-r-00000 எனும் கோப்பினைத் திறந்து பார்த்தால் is எனும் வார்த்தை 28 முறை இடம்பெற்றுள்ளது எனும் விவரம் காணப்படும்.

$ hadoop fs -ls /output
$ hadoop fs -cat /output/part-r-00000

12. அடுத்ததாக பைதான் மொழியில் mapreducer program-ஐ நாமே உருவாக்கி, நமது கோப்பிற்குள் உள்ள ஒவ்வொரு வார்த்தையும் எத்தனை முறை இடம்பெற்றுள்ளது என்பதைக் கண்டுபிடிக்கலாம்.

Mapper – முதலில் நமது கோப்பில் உள்ள ஒவ்வொரு வார்த்தையின் பக்கத்திலும் 1 எனும் எண்ணைச் சேர்ப்போம். இதற்கான நிரல்கள் எழுதப்பட்டுள்ள கோப்பினை mapper.py எனும் பெயரில் சேமிப்போம். ஒரே வார்த்தை திரும்பத் திரும்ப வந்தாலும் அவ்வார்த்தையின் பக்கத்தில் 1 என இடுவோம்.

Reducer – ஒரே வார்த்தை திரும்பத் திரும்ப வந்தால் (mapper-ன் வெளியீட்டில்) அதன் பக்கத்தில் உள்ள எண்ணிக்கையை அடுத்தடுத்து அதிகரிப்பதற்கான நிரல் எழுதப்பட்டுள்ளது. இதற்காக ஒரு காலி dictionary உருவாக்கப்பட்டு இடப்புறத்தில் வார்த்தைகளும் வலப்புறத்தில் அவ்வார்த்தைகளின் எண்ணிக்கையும் சேமிக்கப்படுகிறது. பின்னர் அந்த dictionary-ன் மதிப்புகளை for loop-வைத்து வெளிப்படுத்துவதன் மூலம் ஒவ்வொரு வார்த்தையும் எத்தனை முறை இடம்பெற்றுள்ளது என்பதைக் கண்டறியலாம்.

அதாவது mapper என்பது கொடுக்கப்பட்டுள்ள தகவல்களை key, value pairs-ஆக மாற்றுகிறது. Reducer என்பது இத்தகைய இணைகளை உள்ளீடாக எடுத்துக்கொண்டு வேலைகளைச் செய்கிறது. இதற்கான கட்டளை அமைப்பு பின்வருமாறு அமையும். -file எனும் parameter நாம் எழுதியுள்ள நிரல்களை hadoop-streaming வுடன் இணைக்கிறது. அவ்வாறே -input, -output ஆகிய parameters மூலம் உள்ளீட்டினை எங்கிருந்து எடுக்க வேண்டும், வெளியீட்டினை எங்கு போட வேண்டும் ஆகிய விவரங்களை அளிக்கிறது.

$ /usr/local/hadoop/hadoop-3.0.0/bin/hadoop jar
/usr/local/hadoop/hadoop-3.0.0/share/hadoop/tools/lib/hadoop-streaming-3.0.0.jar
-file ./mapper.py -mapper mapper.py
-file ./reducer.py -reducer reducer.py
-input /input/Kanchi.txt
-output /Kanchi_output

இது இயங்கி முடித்த பின்னர் வெளியீட்டுக்கான இடத்தில் _SUCCESS , part-00000 ஆகிய இரு கோப்புகள் செலுத்தப்பட்டிருப்பதைக் காணலாம். இதில் இரண்டாவது கோப்பில் ஒவ்வொரு வார்த்தையும் எத்தனை முறை இடம்பெற்றுள்ளது என்பது காணப்படுகிறது.

$ hadoop fs -ls /Kanchi_output
$ hadoop fs -cat /Kanchi_output/part-00000

Mapper மற்றும் Reducer இரண்டையும் ஒரே program-ல் எழுதி விடலாமே என்று நீங்கள் கேட்கலாம். இது இரண்டுக்குமான வித்தியாசத்தைப் பற்றிக் கூற வேண்டுமானால், நாம் சிறு வயதில் பல வண்ண நிறங்களில் சீரக மிட்டாய் வாங்கி இருப்போம் அல்லவா! அப்போது அதை உண்பதற்கு முன்னர் ஒவ்வொரு நிறத்திலும் எத்தனை சீரக மிட்டாய் உள்ளது என்பதை ஒரு விளையாட்டாகக் கணக்கெடுப்போம். அதற்கு என்ன செய்வோம் என்று நினைத்துப் பாருங்கள். முதலில் ஒரே நிறத்தில் உள்ள மிட்டாய்களை எல்லாம் ஒன்றாகச் சேர்த்து அவற்றைத் தனித்தனிக் குழுக்களாகப் பிரித்து வைப்போம். பின்னர் ஒவ்வொரு நிறக் குழுவிலும் சென்று எத்தனை மிட்டாய் உள்ளது என்பதை சுலபமாகக் கணக்கெடுப்போம். இதையே தற்போது Mapreducer செய்கிறது. தகவல்களை அடையாளம் கண்டு பிரித்து வைக்கும் வேலையை mapper-ம் அதனடிப்படையில் கணக்கெடுக்கும் வேலையை reducer-ம் செய்கிறது.

Leave a Reply

%d bloggers like this: