பிக்டேட்டா: ஹடூப்

4.1 ஹடூப் பற்றிய பொதுவான தகவல்கள்

MapReduce முன்னுதாரணம் 2004 இல் Google ஆல் அதன் MapReduce: Simplified Data Processing on Large Clusters என்ற கட்டுரையில் முன்மொழியப்பட்டது . முன்மொழியப்பட்ட கட்டுரையில் முன்னுதாரணத்தின் விளக்கம் இருப்பதால், ஆனால் செயல்படுத்தல் இல்லை, Yahoo வில் இருந்து பல புரோகிராமர்கள் நட்ச் வெப் க்ராலர் வேலையின் ஒரு பகுதியாக அவற்றை செயல்படுத்த முன்மொழிந்தனர். ஹடூப்பின் வரலாறு : ஹடூப்பின் வரலாறு: 4 முனைகளில் இருந்து தரவின் எதிர்காலம் வரை நீங்கள் ஹடூப்பின் வரலாற்றைப் பற்றி மேலும் படிக்கலாம் .

ஆரம்பத்தில், ஹடூப் முதன்மையாக தரவைச் சேமிப்பதற்கும் MapReduce பணிகளை இயக்குவதற்கும் ஒரு கருவியாக இருந்தது, ஆனால் இப்போது Hadoop என்பது பெரிய தரவைச் செயலாக்குவதற்கு (MapReduce உடன் மட்டும் அல்ல) ஏதோ ஒரு வகையில் தொடர்புடைய தொழில்நுட்பங்களின் ஒரு பெரிய தொகுப்பாகும்.

ஹடூப்பின் முக்கிய (முக்கிய) கூறுகள்:

• ஹடூப் விநியோகிக்கப்பட்ட கோப்பு முறைமை (HDFS) என்பது விநியோகிக்கப்பட்ட கோப்பு முறைமையாகும், இது கிட்டத்தட்ட வரம்பற்ற அளவிலான தகவல்களைச் சேமிக்க உங்களை அனுமதிக்கிறது.
• Hadoop YARN என்பது MapReduce கட்டமைப்பு உட்பட கிளஸ்டர் வள மேலாண்மை மற்றும் பணி மேலாண்மைக்கான ஒரு கட்டமைப்பாகும்.
• ஹடூப் பொதுவானது

ஹடூப்புடன் நேரடியாக தொடர்புடைய ஏராளமான திட்டங்கள் உள்ளன, ஆனால் ஹடூப் மையத்தில் சேர்க்கப்படவில்லை:

• ஹைவ் - பெரிய தரவுகள் மீது SQL போன்ற வினவல்களுக்கான ஒரு கருவி (SQL வினவல்களை MapReduce பணிகளின் வரிசையாக மாற்றுகிறது);
• பன்றி என்பது உயர்நிலை தரவு பகுப்பாய்வுக்கான ஒரு நிரலாக்க மொழியாகும். இந்த மொழியில் உள்ள ஒரு வரி குறியீடு MapReduce பணிகளின் வரிசையாக மாறும்;
• Hbase என்பது பிக்டேபிள் முன்னுதாரணத்தை செயல்படுத்தும் ஒரு நெடுவரிசை தரவுத்தளமாகும்;
• கசாண்ட்ரா ஒரு உயர் செயல்திறன் விநியோகிக்கப்பட்ட முக்கிய மதிப்பு தரவுத்தளமாகும்;
• ZooKeeper என்பது விநியோகிக்கப்பட்ட உள்ளமைவு சேமிப்பு மற்றும் உள்ளமைவு மாற்றங்களை ஒத்திசைப்பதற்கான ஒரு சேவையாகும்;
• மஹவுட் ஒரு பெரிய தரவு இயந்திர கற்றல் நூலகம் மற்றும் இயந்திரம்.

தனித்தனியாக, Apache Spark திட்டத்தை நான் கவனிக்க விரும்புகிறேன் , இது விநியோகிக்கப்பட்ட தரவு செயலாக்கத்திற்கான இயந்திரமாகும். Apache Spark பொதுவாக அதன் வேலைக்காக HDFS மற்றும் YARN போன்ற ஹடூப் கூறுகளைப் பயன்படுத்துகிறது, அதே சமயம் அது சமீபத்தில் ஹடூப்பை விட மிகவும் பிரபலமாகிவிட்டது:

இவற்றில் சில கூறுகள் இந்தத் தொடரின் தனித்தனி கட்டுரைகளில் விவாதிக்கப்படும், ஆனால் இப்போதைக்கு, நீங்கள் ஹடூப்புடன் எவ்வாறு பணிபுரியத் தொடங்கி அதை நடைமுறைக்குக் கொண்டுவரலாம் என்பதைப் பார்ப்போம்.

4.2 ஹடூப்பில் MapReduce நிரல்களை இயக்குதல்

இப்போது ஹடூப்பில் MapReduce பணியை எப்படி இயக்குவது என்று பார்க்கலாம். ஒரு பணியாக, முந்தைய பாடத்தில் விவாதிக்கப்பட்ட கிளாசிக் WordCount உதாரணத்தைப் பயன்படுத்துவோம் .

சிக்கலை உருவாக்குவதை நான் உங்களுக்கு நினைவூட்டுகிறேன்: ஆவணங்களின் தொகுப்பு உள்ளது. ஆவணங்களின் தொகுப்பில் நிகழும் ஒவ்வொரு வார்த்தையும் தொகுப்பில் எத்தனை முறை வருகிறது என்பதைக் கணக்கிடுவது அவசியம்.

தீர்வு:

வரைபடம் ஆவணத்தை வார்த்தைகளாகப் பிரித்து ஜோடிகளின் தொகுப்பை வழங்குகிறது (வார்த்தை, 1).

ஒவ்வொரு வார்த்தையின் நிகழ்வுகளையும் சுருக்கவும்:

def map(doc):  
for word in doc.split():  
	yield word, 1 

def reduce(word, values):  
	yield word, sum(values)

இப்போது இந்த தீர்வை ஹடூப்பில் செயல்படுத்தி இயக்கக்கூடிய குறியீடு வடிவில் நிரல் செய்வதே பணி.

4.3 முறை எண் 1. ஹடூப் ஸ்ட்ரீமிங்

Hadoop இல் MapReduce நிரலை இயக்குவதற்கான எளிதான வழி, Hadoop ஸ்ட்ரீமிங் இடைமுகத்தைப் பயன்படுத்துவதாகும். ஸ்ட்ரீமிங் இடைமுகம் வரைபடம் மற்றும் குறைப்பு ஆகியவை stdin மற்றும் வெளியீட்டிலிருந்து stdout க்கு தரவை எடுக்கும் நிரல்களாக செயல்படுத்தப்படுகின்றன என்று கருதுகிறது .

வரைபட செயல்பாட்டை செயல்படுத்தும் நிரல் மேப்பர் என்று அழைக்கப்படுகிறது. குறைப்பை இயக்கும் நிரல் முறையே குறைப்பான் என்று அழைக்கப்படுகிறது .

ஸ்ட்ரீமிங் இடைமுகம் ஒரு மேப்பர் அல்லது ரிட்யூசரில் உள்ள ஒரு உள்வரும் வரியானது வரைபடத்திற்கான உள்வரும் உள்ளீட்டிற்கு ஒத்திருக்கும் என்று முன்னிருப்பாகக் கருதுகிறது .

மேப்பரின் வெளியீடு ஜோடிகளின் வடிவத்தில் குறைப்பான் உள்ளீட்டைப் பெறுகிறது (விசை, மதிப்பு), அதே நேரத்தில் அனைத்து ஜோடிகளும் ஒரே விசையுடன் தொடர்புடையவை:

• ரிட்யூசரின் ஒற்றை ஏவினால் செயலாக்கப்படும் என்று உத்தரவாதம்;
• ஒரு வரிசையில் உள்ளீட்டில் சமர்ப்பிக்கப்படும் (அதாவது, ஒரு குறைப்பான் பல்வேறு விசைகளை செயலாக்கினால், உள்ளீடு விசையால் தொகுக்கப்படும்).

எனவே பைத்தானில் மேப்பர் மற்றும் குறைப்பானை செயல்படுத்துவோம்:

#mapper.py  
import sys  
  
def do_map(doc):  
for word in doc.split():  
	yield word.lower(), 1  
  
for line in sys.stdin:  
	for key, value in do_map(line):  
    	print(key + "\t" + str(value))  
 
#reducer.py  
import sys  
  
def do_reduce(word, values):  
	return word, sum(values)  
  
prev_key = None  
values = []  
  
for line in sys.stdin:  
	key, value = line.split("\t")  
	if key != prev_key and prev_key is not None:  
    	result_key, result_value = do_reduce(prev_key, values)  
    	print(result_key + "\t" + str(result_value))  
    	values = []  
	prev_key = key  
	values.append(int(value))  
  
if prev_key is not None:  
	result_key, result_value = do_reduce(prev_key, values)  
	print(result_key + "\t" + str(result_value))

ஹடூப் செயலாக்கும் தரவு HDFS இல் சேமிக்கப்பட வேண்டும். எங்கள் கட்டுரைகளைப் பதிவேற்றி அவற்றை HDFS இல் வைப்போம். இதைச் செய்ய, hadoop fs கட்டளையைப் பயன்படுத்தவும் :

wget https://www.dropbox.com/s/opp5psid1x3jt41/lenta_articles.tar.gz  
tar xzvf lenta_articles.tar.gz  
hadoop fs -put lenta_articles 

ஹடூப் எஃப்எஸ் பயன்பாடு கோப்பு முறைமையைக் கையாளும் பல முறைகளை ஆதரிக்கிறது, அவற்றில் பல நிலையான லினக்ஸ் பயன்பாடுகளுக்கு ஒத்ததாக இருக்கும்.

இப்போது ஸ்ட்ரீமிங் பணியைத் தொடங்குவோம்:

yarn jar /usr/lib/hadoop-mapreduce/hadoop-streaming.jar\  
 -input lenta_articles\  
 -output lenta_wordcount\  
 -file mapper.py\  
 -file reducer.py\  
 -mapper "python mapper.py"\  
 -reducer "python reducer.py" 

ஒரு கிளஸ்டரில் பல்வேறு பயன்பாடுகளை (வரைபடம்-குறைத்தல் உட்பட) தொடங்க மற்றும் நிர்வகிக்க நூல் பயன்பாடு பயன்படுத்தப்படுகிறது. Hadoop-streaming.jar அத்தகைய நூல் பயன்பாட்டிற்கு ஒரு எடுத்துக்காட்டு.

அடுத்த வெளியீட்டு விருப்பங்கள்:

• உள்ளீடு - hdfs இல் மூல தரவு கொண்ட கோப்புறை;
• வெளியீடு - நீங்கள் முடிவை வைக்க விரும்பும் hdfs இல் கோப்புறை;
• கோப்பு - வரைபடத்தை குறைக்கும் பணியின் செயல்பாட்டின் போது தேவைப்படும் கோப்புகள்;
• மேப்பர் என்பது கன்சோல் கட்டளையாகும், இது வரைபட நிலைக்கு பயன்படுத்தப்படும்;
• குறைக்க என்பது குறைப்பு நிலைக்குப் பயன்படுத்தப்படும் கன்சோல் கட்டளை.

துவக்கிய பிறகு, பணியின் முன்னேற்றத்தை கன்சோலில் காணலாம் மற்றும் பணி பற்றிய விரிவான தகவல்களைப் பார்ப்பதற்கான URL ஐப் பார்க்கலாம்.

இந்த URL இல் கிடைக்கும் இடைமுகத்தில், நீங்கள் இன்னும் விரிவான பணி நிறைவேற்றும் நிலையைக் கண்டறியலாம், ஒவ்வொரு மேப்பர் மற்றும் குறைப்பான் பதிவுகளையும் பார்க்கலாம் (இது தோல்வியுற்ற பணிகளுக்கு மிகவும் பயனுள்ளதாக இருக்கும்).

வெற்றிகரமான செயல்பாட்டிற்குப் பிறகு வேலையின் முடிவு, வெளியீட்டு புலத்தில் நாங்கள் குறிப்பிட்ட கோப்புறையில் HDFS இல் சேர்க்கப்படும். "hadoop fs -ls lenta_wordcount" கட்டளையைப் பயன்படுத்தி அதன் உள்ளடக்கங்களை நீங்கள் பார்க்கலாம்.

முடிவை பின்வருமாறு பெறலாம்:

hadoop fs -text lenta_wordcount/* | sort -n -k2,2 | tail -n5  
from
41  
this
43  
on
82  
and
111  
into
194 

"hadoop fs -text" கட்டளை கோப்புறையின் உள்ளடக்கங்களை உரை வடிவத்தில் காட்டுகிறது. சொற்களின் நிகழ்வுகளின் எண்ணிக்கையால் முடிவை வரிசைப்படுத்தினேன். எதிர்பார்த்தபடி, மொழியில் மிகவும் பொதுவான சொற்கள் முன்மொழிவுகள்.

4.4 முறை எண் 2: ஜாவாவைப் பயன்படுத்தவும்

ஹடூப் ஜாவாவில் எழுதப்பட்டுள்ளது, மேலும் ஹடூப்பின் சொந்த இடைமுகமும் ஜாவா அடிப்படையிலானது. வேர்ட்கவுண்டிற்கான சொந்த ஜாவா பயன்பாடு எப்படி இருக்கும் என்பதைக் காண்பிப்போம்:

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCount {

	public static class TokenizerMapper
        	extends Mapper<Object, Text, Text, IntWritable>{

    	private final static IntWritable one = new IntWritable(1);
    	private Text word = new Text();

    	public void map(Object key, Text value, Context context
    	) throws IOException, InterruptedException {
        	StringTokenizer itr = new StringTokenizer(value.toString());
        	while (itr.hasMoreTokens()) {
            	word.set(itr.nextToken());
            	context.write(word, one);
        	}
    	}
	}

	public static class IntSumReducer
        	extends Reducer<Text,IntWritable,Text,IntWritable> {
    	private IntWritable result = new IntWritable();

    	public void reduce(Text key, Iterable values,
                       	Context context
    	) throws IOException, InterruptedException {
        	int sum = 0;
        	for (IntWritable val : values) {
            	sum += val.get();
        	}
        	result.set(sum);
        	context.write(key, result);
    	}
	}

	public static void main(String[] args) throws Exception {
    	Configuration conf = new Configuration();
    	Job job = Job.getInstance(conf, "word count");
    	job.setJarByClass(WordCount.class);
    	job.setMapperClass(TokenizerMapper.class);
    	job.setReducerClass(IntSumReducer.class);
    	job.setOutputKeyClass(Text.class);
    	job.setOutputValueClass(IntWritable.class);
    	FileInputFormat.addInputPath(job, new Path("hdfs://localhost/user/cloudera/lenta_articles"));
    	FileOutputFormat.setOutputPath(job, new Path("hdfs://localhost/user/cloudera/lenta_wordcount"));
    	System.exit(job.waitForCompletion(true) ? 0 : 1);
	}
}

இந்த வகுப்பு எங்கள் பைதான் உதாரணத்தைப் போலவே செய்கிறது. நாங்கள் டோக்கனைசர் மேப்பர் மற்றும் இன்ட்சம்ரெட்யூசர் வகுப்புகளை முறையே மேப்பர் மற்றும் ரெட்யூசர் வகுப்புகளில் இருந்து பெறுகிறோம். டெம்ப்ளேட் அளவுருக்களாக அனுப்பப்பட்ட வகுப்புகள் உள்ளீடு மற்றும் வெளியீட்டு மதிப்புகளின் வகைகளைக் குறிப்பிடுகின்றன. நேட்டிவ் API ஆனது வரைபடச் செயல்பாட்டிற்கு ஒரு முக்கிய மதிப்பு ஜோடி உள்ளீடாக கொடுக்கப்பட்டதாகக் கருதுகிறது. எங்கள் விஷயத்தில் விசை காலியாக இருப்பதால், பொருளை விசை வகையாக வரையறுக்கிறோம்.

பிரதான முறையில், நாங்கள் வரைபடப் பணியைத் தொடங்கி அதன் அளவுருக்களை வரையறுக்கிறோம் - பெயர், மேப்பர் மற்றும் குறைப்பான், HDFS இல் உள்ள பாதை, உள்ளீட்டு தரவு அமைந்துள்ள இடம் மற்றும் முடிவை எங்கு வைக்க வேண்டும். தொகுக்க, எங்களுக்கு ஹடூப் நூலகங்கள் தேவை. நான் உருவாக்க மேவனைப் பயன்படுத்துகிறேன், அதற்காக கிளவுடரா ஒரு களஞ்சியத்தைக் கொண்டுள்ளது. அதை அமைப்பதற்கான வழிமுறைகளை இங்கே காணலாம். இதன் விளைவாக, pom.xmp கோப்பு (திட்டத்தின் அசெம்பிளியை விவரிக்க மேவனால் பயன்படுத்தப்படுகிறது) நான் பின்வருவனவற்றைப் பெற்றேன்:

<?xml version="1.0" encoding="UTF-8"?>  
<project xmlns="http://maven.apache.org/POM/4.0.0"  
     	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
     	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
	<modelVersion>4.0.0</modelVersion>  
  
	<repositories>  
    	<repository>  
        	<id>cloudera</id>  
        	<url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>  
    	</repository>  
	</repositories>  
  
	<dependencies>  
    	<dependency>  
        	<groupId>org.apache.hadoop</groupId>  
        	<artifactId>hadoop-common</artifactId>  
        	<version>2.6.0-cdh5.4.2</version>  
    	</dependency>  
  
    	<dependency>  
        	<groupId>org.apache.hadoop</groupId>  
        	<artifactId>hadoop-auth</artifactId>  
        	<version>2.6.0-cdh5.4.2</version>  
    	</dependency>  
  
    	<dependency>  
        	<groupId>org.apache.hadoop</groupId>  
        	<artifactId>hadoop-hdfs</artifactId>  
        	<version>2.6.0-cdh5.4.2</version>  
    	</dependency>  
  
    	<dependency>  
        	<groupId>org.apache.hadoop</groupId>  
        	<artifactId>hadoop-mapreduce-client-app</artifactId>  
        	<version>2.6.0-cdh5.4.2</version>  
    	</dependency>  
  
	</dependencies>  
  
	<groupId>org.dca.examples</groupId>  
	<artifactId>wordcount</artifactId>  
	<version>1.0-SNAPSHOT</version>  
 
</project>

திட்டத்தை ஒரு ஜாடி தொகுப்பாக தொகுக்கலாம்:

mvn clean package

திட்டத்தை ஒரு ஜார் கோப்பாக உருவாக்கிய பிறகு, ஸ்ட்ரீமிங் இடைமுகத்தைப் போலவே வெளியீடும் நிகழ்கிறது:

yarn jar wordcount-1.0-SNAPSHOT.jar  WordCount 

செயல்பாட்டிற்காக நாங்கள் காத்திருந்து முடிவைச் சரிபார்க்கிறோம்:

hadoop fs -text lenta_wordcount/* | sort -n -k2,2 | tail -n5  
from
41
this
43
on
82
and
111
into
194

நீங்கள் யூகித்தபடி, எங்கள் சொந்த பயன்பாட்டை இயக்குவதன் முடிவு, முந்தைய வழியில் நாங்கள் அறிமுகப்படுத்திய ஸ்ட்ரீமிங் பயன்பாட்டின் விளைவாகும்.