⑴ 有沒有關於maprece編程的書籍推薦
maprece編程書籍推薦一：《MapRece設計模式》
將各種有價值的MapRece設計模式匯集在一起，形成一本獨特的合集，可以幫讀者節省大量的時間和精力，無論讀者身處哪個領域，使用哪種編程語言，使用什麼開發框架。
書中對每一種模式都會詳細解釋其使用的上下文、可能存在的陷阱及使用的注意事項，以幫助讀者在對大數據問題架構建模時避免常見的設計錯誤。本書還提供了MapRece的一個完整綜述，解釋其起源和實現，並說明設計模式如此重要的原因。書中的所有示例代碼都是基於Hadoop平台編寫的。
maprece編程書籍推薦二：《Hadoop MapRece實戰手冊》
⑵ MapRece是什麼有什麼作用
MapRece是一種編程模型，用於大規模數據集（大於1TB）的並行運算。概念"Map（映射）"和"Rece（歸約）"，和它們的主要思想，都是從函數式編程語言里借來的，還有從矢量編程語言里借來的特性。它極大地方便了編程人員在不會分布式並行編程的情況下，將自己的程序運行在分布式系統上。 當前的軟體實現是指定一個Map（映射）函數，用來把一組鍵值對映射成一組新的鍵值對，指定並發的Rece（歸約）函數，用來保證所有映射的鍵值對中的每一個共享相同的鍵組。
瑭錦TANJURD總結在Google，MapRece用在非常廣泛的應用程序中，包括「分布grep，分布排序，web連接圖反轉，每台機器的詞矢量，web訪問日誌分析，反向索引構建，文檔聚類，機器學習，基於統計的機器翻譯...」值得注意的是，MapRece實現以後，它被用來重新生成Google的整個索引，並取代老的ad hoc程序去更新索引。
⑶ 如何調試MapRece程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define BUF_SIZE 2048
int my_map(char *buffer,char (*mapbuffer)[100]); //函數參數 一個char*指針 和 一個 mapbuffer指針指向一個一位字元數組 就是一個一維數組和二維數組
int my_rece(char (*mapbuffer)[100],char (*recebuffer)[100],int *count,int num);
int main(int argc,char *argv[]) //多了一個d
{
char buffer[BUF_SIZE];
char mapbuffer[BUF_SIZE][100];
char recebuffer[BUF_SIZE][100];
int count[BUF_SIZE]=; //記錄位全部置0 顯示字元子串個數
int num;
int i;
int countnum;
fgets(buffer,BUF_SIZE-1,stdin); //從 buffer 中讀入 BUD_SIZE-1個數據 讀完後清除緩沖區內容，輸入數組buffer 功能
buffer[strlen(buffer)-1]='\0'; // 輸入完畢後 說明字元串結束
num=my_map(buffer,mapbuffer); //接收返回值
printf("num:%d\n",num);
printf("this is map results:\n");
for(i=0;i<num;i++)
{
printf("<%s\t1>\n",mapbuffer[i]); //輸出二維數組對應的一維數組 即每一個輸出 [i][0]-[i][100]
}
countnum=my_rece(mapbuffer,recebuffer,count,num); //接收返回值
printf("countnum:%d\n",countnum);
printf("this is rece results:\n");
for(i=0;i<countnum;i++) //
{
printf("<%s\t%d>\n",recebuffer[i],count[i]); //漏了一個右括弧 輸出 二維數組對應的一維數組 和一維數組
}
return 0; //沒有返回一個 0 對應int main()
}
int my_map(char *buffer, char(*mapbuffer)[100]) //這個函數作用是分割你在主函數輸入的字元以空格為分割標准 返回分割後字元串個數
{
char *p;
int num=0;
if(p=strtok(buffer, " ")) //漏了一個右括弧 strok 為分解字元串 碰上空格就分解字元串將一個字元串以空格為界分成兩個
{
strcpy(mapbuffer[num],p); //用一個二維數組接收 分解好第一個字元串的首地址
num++; //自加移動到二維數組 的下一列 記錄分解次數 分割字元串個數
}
else
return num; //如果字元串到了尾部 返回NULL 就直接返回 分解次數 分割字元串個數
while(p=strtok(NULL," ")) //碰到下一個空格繼續進行分割 知道 沒有空格為止
{
strcpy(mapbuffer[num],p);
num++;
}
return num; //返回 分割字元串個數
//將 buffer 的字元 分割後送給了二維數組 mapbuffer
}
int my_rece(char (*mapbuffer)[100], char(*recebuffer)[100],int *count,int num) //這個函數主要作用計算分割字元子串的相同個數
{
//mapbuffer 是分割的字元串
int i,j;
int flag[BUF_SIZE]=; //定義一個記錄數組 表示已存在的字元子串
char tmp[100];
int countnum=0;
for(i=0;i<num;i++) //收索到分割的字元子串結束
{
if(flag[i]==0)
{
strcpy(tmp,mapbuffer[i]); //將二維數組對應的[i][0]~[i][100]送給一維臨時數組
flag[i]=1; //第一個標志位置1
strcpy(recebuffer[countnum],mapbuffer[i]); //將mapbuffer二維數組對應的一維數組給二維數組recebuffer對應的一維數組 對應的 ruce
count[countnum]=1; //漏了一個t 傳入的一位數組記錄1
for(j=0;j<num;j++)
{
if(memcmp(tmp,mapbuffer[j],strlen(tmp))==0 && (strlen(tmp)==strlen(mapbuffer[j]))&& (flag[j]==0)) //漏了一個右括弧
{//比較 tmp數組和mapbuffer對應一維數組前tmp字元長度位的長度 tmp數組長度與mapbuffer對應一維數組長度如果相等 且 記錄位是0
count[countnum]++; //傳入數組對應的 countnum 自加1 對應標志位顯示 字元串存在的個數
flag[j]=1; //記錄為標志為1
}
}
countnum++; //記數自加1 下一個記錄位
}
}
return countnum; //返回記數
}
⑷ 什麼是MapRece
概念"Map（映射）"和"Rece（化簡）"，和他們的主要思想，都是從函數式編程語言里借來的，還有從矢量編程語言里借來的特性。他極大地方便了編程人員在不會分布式並行編程的情況下，將自己的程序運行在分布式系統上。 當前的軟體實現是指定一個Map（映射）函數，用來把一組鍵值對映射成一組新的鍵值對，指定並發的Rece（化簡）函數，用來保證所有映射的鍵值對中的每一個共享相同的鍵組。 映射和化簡 簡單說來，一個映射函數就是對一些獨立元素組成的概念上的列表（例如，一個測試成績的列表）的每一個元素進行指定的操作（比如前面的例子里，有人發現所有學生的成績都被高估了一分，他可以定義一個「減一」的映射函數，用來修正這個錯誤。）。 事實上，每個元素都是被獨立操作的，而原始列表沒有被更改，因為這里創建了一個新的列表來保存新的答案。這就是說，Map操作是可以高度並行的，這對高性能要求的應用以及並行計算領域的需求非常有用。 而化簡操作指的是對一個列表的元素進行適當的合並（繼續看前面的例子，如果有人想知道班級的平均分該怎麼做？他可以定義一個化簡函數，通過讓列表中的元素跟自己的相鄰的元素相加的方式把列表減半，如此遞歸運算直到列表只剩下一個元素，然後用這個元素除以人數，就得到了平均分。）。雖然他不如映射函數那麼並行，但是因為化簡總是有一個簡單的答案，大規模的運算相對獨立，所以化簡函數在高度並行環境下也很有用。編輯本段分布和可靠性 MapRece通過把對數據集的大規模操作分發給網路上的每個節點實現可靠性；每個節點會周期性的把完成的工作和狀態的更新報告回來。如果一個節點保持沉默超過一個預設的時間間隔，主節點（類同Google File System中的主伺服器）記錄下這個節點狀態為死亡，並把分配給這個節點的數據發到別的節點。每個操作使用命名文件的原子操作以確保不會發生並行線程間的沖突；當文件被改名的時候，系統可能會把他們復制到任務名以外的另一個名字上去。（避免副作用）。 化簡操作工作方式很類似，但是由於化簡操作在並行能力較差，主節點會盡量把化簡操作調度在一個節點上，或者離需要操作的數據盡可能近的節點上了；這個特性可以滿足Google的需求，因為他們有足夠的帶寬，他們的內部網路沒有那麼多的機器。 用途在Google，MapRece用在非常廣泛的應用程序中，包括「分布grep，分布排序，web連接圖反轉，每台機器的詞矢量，web訪問日誌分析，反向索引構建，文檔聚類，機器學習，基於統計的機器翻譯...」值得注意的是，MapRece實現以後，它被用來重新生成Google的整個索引，並取代老的ad hoc程序去更新索引。 MapRece會生成大量的臨時文件，為了提高效率，它利用Google文件系統來管理和訪問這些文件。
⑸ maprece運行過程
一個Map/Rece作業（job）通常會把輸入的數據（inputfile）切分為若干獨立的數據塊（splits），然後由map任務（task）以完全並行的方式處理它們。Map/Rece框架會對map的輸出做一個Shuffle操作，Shuffle操作的後的結果會輸入給rece任務。整個Map/Rece框架負責任務的調度和監控，以及重新執行已經失敗的任務。Map/Rece計算集群由一個單獨的JobTracker（master）和每個集群節點一個TaskTracker（slave）共同組成。JobTracker負責調度構成一個作業的所有任務，這些任務會被分派到不同的TaskTracker上去執行，JobTracker會監控它們的執行、重新執行已經失敗的任務。而TaskTracker僅負責執行由JobTracker指派的任務。提交作業的過程如下。map/rece程序通過runJob()方法新建一個JobClient實例;。向JobTracker請求一個新jobID，通過JobTracker的getNewJobId()獲取。檢查作業輸入輸出說明。如果沒有指定輸出目錄或者輸出目錄已經存在，作業將不會被提交，map/rece程序；輸入作業劃分split，如果劃分無法計算（如：輸入路徑不存在），作業將不會被提交，錯誤返回給map/rece程序。將運行作業所需要的資源（作業的jar文件、配置文件、計算所得的輸入劃分）復制到一個以作業ID命名的目錄中。通過調用JobTracker的submitJob()方法，告訴JobTracker作業准備提交。JobTracker將提交的作業放到一個內部隊列中，交由作業調度器進行調度，並對其進行初始化。創建Map任務、Rece任務：一個split對應一個map，有多少split就有多少map;Rece任務的數量由JobConf的mapred.rece.tasks屬性決定。TaskTracker執行一個簡單的循環，定期發送心跳（heartbeat）給JobTracker。
⑹ 如何快速地編寫和運行一個屬於自己的MapRece例子程序
大數據的時代， 到處張嘴閉嘴都是Hadoop, MapRece, 不跟上時代怎麼行？ 可是對一個hadoop的新手， 寫一個屬於自己的MapRece程序還是小有點難度的， 需要建立一個maven項目， 還要搞清楚各種庫的依賴， 再加上編譯運行， 基本上頭大兩圈了吧。 這也使得很多隻是想簡單了解一下MapRece的人望而卻步。
本文會教你如何用最快最簡單的方法編寫和運行一個屬於自己的MapRece程序， let's go!
首先有兩個前提：
1. 有一個已經可以運行的hadoop 集群（也可以是偽分布系統)， 上面的hdfs和maprece工作正常 （這個真的是最基本的了， 不再累述， 不會的請參考 http://hadoop.apache.org/docs/current/)
2. 集群上安裝了JDK (編譯運行時會用到）
正式開始
1. 首先登入hadoop 集群裡面的一個節點， 創建一個java源文件， 偷懶起見， 基本盜用官方的word count (因為本文的目的是教會你如何快編寫和運行一個MapRece程序， 而不是如何寫好一個功能齊全的MapRece程序）
內容如下：
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.maprece.Job;
import org.apache.hadoop.maprece.Mapper;
import org.apache.hadoop.maprece.Recer;
import org.apache.hadoop.maprece.lib.input.FileInputFormat;
import org.apache.hadoop.maprece.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
public class myword {
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 IntSumRecer
extends Recer<Text,IntWritable,Text,IntWritable> {
private IntWritable result = new IntWritable();
public void rece(Text key, Iterable<IntWritable> 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();
String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
if (otherArgs.length != 2) {
System.err.println('Usage: wordcount <in> <out>');
System.exit(2);
}
Job job = new Job(conf, 'word count');
job.setJarByClass(myword.class);
job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumRecer.class);
job.setRecerClass(IntSumRecer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
與官方版本相比， 主要做了兩處修改
1） 為了簡單起見，去掉了開頭的 package org.apache.hadoop.examples;
2） 將類名從 WordCount 改為 myword, 以體現是我們自己的工作成果 :)
2. 拿到hadoop 運行的class path, 主要為編譯所用
運行命令
hadoop classpath
保存打出的結果，本文用的hadoop 版本是Pivotal 公司的Pivotal hadoop, 例子：
/etc/gphd/hadoop/conf:/usr/lib/gphd/hadoop/lib/*:/usr/lib/gphd/hadoop/.//*:/usr/lib/gphd/hadoop-hdfs/./:/usr/lib/gphd/hadoop-hdfs/lib/*:/usr/lib/gphd/hadoop-hdfs/.//*:/usr/lib/gphd/hadoop-yarn/lib/*:/usr/lib/gphd/hadoop-yarn/.//*:/usr/lib/gphd/hadoop-maprece/lib/*:/usr/lib/gphd/hadoop-maprece/.//*::/etc/gphd/pxf/conf::/usr/lib/gphd/pxf/pxf-core.jar:/usr/lib/gphd/pxf/pxf-api.jar:/usr/lib/gphd/publicstage:/usr/lib/gphd/gfxd/lib/gemfirexd.jar::/usr/lib/gphd/zookeeper/zookeeper.jar:/usr/lib/gphd/hbase/lib/hbase-common.jar:/usr/lib/gphd/hbase/lib/hbase-protocol.jar:/usr/lib/gphd/hbase/lib/hbase-client.jar:/usr/lib/gphd/hbase/lib/hbase-thrift.jar:/usr/lib/gphd/hbase/lib/htrace-core-2.01.jar:/etc/gphd/hbase/conf::/usr/lib/gphd/hive/lib/hive-service.jar:/usr/lib/gphd/hive/lib/libthrift-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-metastore.jar:/usr/lib/gphd/hive/lib/libfb303-0.9.0.jar:/usr/lib/gphd/hive/lib/hive-common.jar:/usr/lib/gphd/hive/lib/hive-exec.jar:/usr/lib/gphd/hive/lib/postgresql-jdbc.jar:/etc/gphd/hive/conf::/usr/lib/gphd/sm-plugins/*:
3. 編譯
運行命令
javac -classpath xxx ./myword.java
xxx部分就是上一步裡面取到的class path
運行完此命令後， 當前目錄下會生成一些.class 文件， 例如：
myword.class myword$IntSumRecer.class myword$TokenizerMapper.class
4. 將class文件打包成.jar文件
運行命令
jar -cvf myword.jar ./*.class
至此, 目標jar 文件成功生成
5. 准備一些文本文件， 上傳到hdfs, 以做word count的input
例子：
隨意創建一些文本文件， 保存到mapred_test 文件夾
運行命令
hadoop fs -put ./mapred_test/
確保此文件夾成功上傳到hdfs 當前用戶根目錄下
6. 運行我們的程序
運行命令
hadoop jar ./myword.jar myword mapred_test output
順利的話， 此命令會正常進行， 一個MapRece job 會開始工作， 輸出的結果會保存在 hdfs 當前用戶根目錄下的output 文件夾裡面。
至此大功告成！
如果還需要更多的功能， 我們可以修改前面的源文件以達到一個真正有用的MapRece job。
但是原理大同小異， 練手的話， 基本夠了。
一個拋磚引玉的簡單例子， 歡迎板磚。
轉載
⑺ 什麼是Map/Rece-Maprece-about雲開發
什麼是Map/Rece，看下面的各種解釋：
(1)MapRece是hadoop的核心組件之一，hadoop要分布式包括兩部分，一是分布式文件系統hdfs,一部是分布式計算框，就是maprece,缺一不可，也就是說，可以通過maprece很容易在hadoop平台上進行分布式的計算編程。
(2)Maprece是一種編程模型，是一種編程方法，抽象理論。
(3)下面是一個關於一個程序員是如何個妻子講解什麼是MapRece？文章很長請耐心的看。
我問妻子：「你真的想要弄懂什麼是MapRece？」 她很堅定的回答說「是的」。 因此我問道：
我： 你是如何准備洋蔥辣椒醬的？（以下並非准確食譜，請勿在家嘗試）
妻子： 我會取一個洋蔥，把它切碎，然後拌入鹽和水，最後放進混合研磨機里研磨。這樣就能得到洋蔥辣椒醬了。
妻子： 但這和MapRece有什麼關系？
我： 你等一下。讓我來編一個完整的情節，這樣你肯定可以在15分鍾內弄懂MapRece.
妻子： 好吧。
我：現在，假設你想用薄荷、洋蔥、番茄、辣椒、大蒜弄一瓶混合辣椒醬。你會怎麼做呢？
妻子： 我會取薄荷葉一撮，洋蔥一個，番茄一個，辣椒一根，大蒜一根，切碎後加入適量的鹽和水，再放入混合研磨機里研磨，這樣你就可以得到一瓶混合辣椒醬了。
我： 沒錯，讓我們把MapRece的概念應用到食譜上。Map和Rece其實是兩種操作，我來給你詳細講解下。
Map（映射）: 把洋蔥、番茄、辣椒和大蒜切碎，是各自作用在這些物體上的一個Map操作。所以你給Map一個洋蔥，Map就會把洋蔥切碎。 同樣的，你把辣椒，大蒜和番茄一一地拿給Map，你也會得到各種碎塊。 所以，當你在切像洋蔥這樣的蔬菜時，你執行就是一個Map操作。 Map操作適用於每一種蔬菜，它會相應地生產出一種或多種碎塊，在我們的例子中生產的是蔬菜塊。在Map操作中可能會出現有個洋蔥壞掉了的情況，你只要把壞洋蔥丟了就行了。所以，如果出現壞洋蔥了，Map操作就會過濾掉壞洋蔥而不會生產出任何的壞洋蔥塊。
Rece（化簡）:在這一階段，你將各種蔬菜碎都放入研磨機里進行研磨，你就可以得到一瓶辣椒醬了。這意味要製成一瓶辣椒醬，你得研磨所有的原料。因此，研磨機通常將map操作的蔬菜碎聚集在了一起。
妻子： 所以，這就是MapRece?
我： 你可以說是，也可以說不是。 其實這只是MapRece的一部分，MapRece的強大在於分布式計算。
妻子： 分布式計算？ 那是什麼？請給我解釋下吧。
我： 沒問題。
我： 假設你參加了一個辣椒醬比賽並且你的食譜贏得了最佳辣椒醬獎。得獎之後，辣椒醬食譜大受歡迎，於是你想要開始出售自製品牌的辣椒醬。假設你每天需要生產10000瓶辣椒醬，你會怎麼辦呢？
妻子： 我會找一個能為我大量提供原料的供應商。
我：是的..就是那樣的。那你能否獨自完成製作呢？也就是說，獨自將原料都切碎？ 僅僅一部研磨機又是否能滿足需要？而且現在，我們還需要供應不同種類的辣椒醬，像洋蔥辣椒醬、青椒辣椒醬、番茄辣椒醬等等。
妻子： 當然不能了，我會僱傭更多的工人來切蔬菜。我還需要更多的研磨機，這樣我就可以更快地生產辣椒醬了。
我：沒錯，所以現在你就不得不分配工作了，你將需要幾個人一起切蔬菜。每個人都要處理滿滿一袋的蔬菜，而每一個人都相當於在執行一個簡單的Map操作。每一個人都將不斷的從袋子里拿出蔬菜來，並且每次只對一種蔬菜進行處理，也就是將它們切碎，直到袋子空了為止。
這樣，當所有的工人都切完以後，工作台（每個人工作的地方）上就有了洋蔥塊、番茄塊、和蒜蓉等等。
妻子：但是我怎麼會製造出不同種類的番茄醬呢？
我：現在你會看到MapRece遺漏的階段—攪拌階段。MapRece將所有輸出的蔬菜碎都攪拌在了一起，這些蔬菜碎都是在以key為基礎的 map操作下產生的。攪拌將自動完成，你可以假設key是一種原料的名字，就像洋蔥一樣。 所以全部的洋蔥keys都會攪拌在一起，並轉移到研磨洋蔥的研磨器里。這樣，你就能得到洋蔥辣椒醬了。同樣地，所有的番茄也會被轉移到標記著番茄的研磨器里，並製造出番茄辣椒醬。
（4）上面都是從理論上來說明什麼是MapRece，那麼咱們在MapRece產生的過程和代碼的角度來理解這個問題。
如果想統計下過去10年計算機論文出現最多的幾個單詞，看看大家都在研究些什麼，那收集好論文後，該怎麼辦呢？
方法一：
我可以寫一個小程序，把所有論文按順序遍歷一遍，統計每一個遇到的單詞的出現次數，最後就可以知道哪幾個單詞最熱門了。 這種方法在數據集比較小時，是非常有效的，而且實現最簡單，用來解決這個問題很合適。
方法二：
寫一個多線程程序，並發遍歷論文。
這個問題理論上是可以高度並發的，因為統計一個文件時不會影響統計另一個文件。當我們的機器是多核或者多處理器，方法二肯定比方法一高效。但是寫一個多線程程序要比方法一困難多了，我們必須自己同步共享數據，比如要防止兩個線程重復統計文件。
方法三：
把作業交給多個計算機去完成。
我們可以使用方法一的程序，部署到N台機器上去，然後把論文集分成N份，一台機器跑一個作業。這個方法跑得足夠快，但是部署起來很麻煩，我們要人工把程序到別的機器，要人工把論文集分開，最痛苦的是還要把N個運行結果進行整合（當然我們也可以再寫一個程序）。
⑻ 如何使用python為Hadoop編寫一個簡單的MapRece程序
在這個實例中，我將會向大家介紹如何使用Python 為 Hadoop編寫一個簡單的MapRece
程序。
盡管Hadoop 框架是使用Java編寫的但是我們仍然需要使用像C++、Python等語言來實現Hadoop程序。盡管Hadoop官方網站給的示常式序是使用Jython編寫並打包成Jar文件，這樣顯然造成了不便，其實，不一定非要這樣來實現，我們可以使用Python與Hadoop 關聯進行編程，看看位於/src/examples/python/WordCount.py 的例子，你將了解到我在說什麼。
我們想要做什麼？
我們將編寫一個簡單的 MapRece 程序，使用的是C-Python，而不是Jython編寫後打包成jar包的程序。
我們的這個例子將模仿 WordCount 並使用Python來實現，例子通過讀取文本文件來統計出單詞的出現次數。結果也以文本形式輸出，每一行包含一個單詞和單詞出現的次數，兩者中間使用製表符來想間隔。
先決條件
編寫這個程序之前，你學要架設好Hadoop 集群，這樣才能不會在後期工作抓瞎。如果你沒有架設好，那麼在後面有個簡明教程來教你在Ubuntu linux 上搭建（同樣適用於其他發行版linux、unix）
如何使用Hadoop Distributed File System (HDFS)在Ubuntu Linux 建立單節點的 Hadoop 集群
如何使用Hadoop Distributed File System (HDFS)在Ubuntu Linux 建立多節點的 Hadoop 集群
Python的MapRece代碼
使用Python編寫MapRece代碼的技巧就在於我們使用了 HadoopStreaming 來幫助我們在Map 和 Rece間傳遞數據通過STDIN (標准輸入)和STDOUT (標准輸出).我們僅僅使用Python的sys.stdin來輸入數據，使用sys.stdout輸出數據，這樣做是因為HadoopStreaming會幫我們辦好其他事。這是真的，別不相信！
Map: mapper.py
將下列的代碼保存在/home/hadoop/mapper.py中，他將從STDIN讀取數據並將單詞成行分隔開，生成一個列表映射單詞與發生次數的關系：
注意：要確保這個腳本有足夠許可權（chmod +x /home/hadoop/mapper.py）。
#!/usr/bin/env python
import sys
# input comes from STDIN (standard input)
for line in sys.stdin:
# remove leading and trailing whitespace
line = line.strip()
# split the line into words
words = line.split()
# increase counters
for word in words:
# write the results to STDOUT (standard output);
# what we output here will be the input for the
# Rece step, i.e. the input for recer.py
#
# tab-delimited; the trivial word count is 1
print '%s\\t%s' % (word, 1)在這個腳本中，並不計算出單詞出現的總數，它將輸出 "<word> 1" 迅速地，盡管<word>可能會在輸入中出現多次，計算是留給後來的Rece步驟（或叫做程序）來實現。當然你可以改變下編碼風格，完全尊重你的習慣。
Rece: recer.py
將代碼存儲在/home/hadoop/recer.py 中，這個腳本的作用是從mapper.py 的STDIN中讀取結果，然後計算每個單詞出現次數的總和，並輸出結果到STDOUT。
同樣，要注意腳本許可權：chmod +x /home/hadoop/recer.py
#!/usr/bin/env python
from operator import itemgetter
import sys
# maps words to their counts
word2count = {}
# input comes from STDIN
for line in sys.stdin:
# remove leading and trailing whitespace
line = line.strip()
# parse the input we got from mapper.py
word, count = line.split('\\t', 1)
# convert count (currently a string) to int
try:
count = int(count)
word2count[word] = word2count.get(word, 0) + count
except ValueError:
# count was not a number, so silently
# ignore/discard this line
pass
# sort the words lexigraphically;
#
# this step is NOT required, we just do it so that our
# final output will look more like the official Hadoop
# word count examples
sorted_word2count = sorted(word2count.items(), key=itemgetter(0))
# write the results to STDOUT (standard output)
for word, count in sorted_word2count:
print '%s\\t%s'% (word, count)
測試你的代碼（cat data | map | sort | rece）
我建議你在運行MapRece job測試前嘗試手工測試你的mapper.py 和 recer.py腳本，以免得不到任何返回結果
這里有一些建議，關於如何測試你的Map和Rece的功能：
——————————————————————————————————————————————
\r\n
# very basic test
hadoop@ubuntu:~$ echo "foo foo quux labs foo bar quux" | /home/hadoop/mapper.py
foo 1
foo 1
quux 1
labs 1
foo 1
bar 1
——————————————————————————————————————————————
hadoop@ubuntu:~$ echo "foo foo quux labs foo bar quux" | /home/hadoop/mapper.py | sort | /home/hadoop/recer.py
bar 1
foo 3
labs 1
——————————————————————————————————————————————
# using one of the ebooks as example input
# (see below on where to get the ebooks)
hadoop@ubuntu:~$ cat /tmp/gutenberg/20417-8.txt | /home/hadoop/mapper.py
The 1
Project 1
Gutenberg 1
EBook 1
of 1
[...]
(you get the idea)
quux 2
quux 1
——————————————————————————————————————————————
在Hadoop平台上運行Python腳本
為了這個例子，我們將需要三種電子書：
The Outline of Science, Vol. 1 (of 4) by J. Arthur Thomson\r\n
The Notebooks of Leonardo Da Vinci\r\n
Ulysses by James Joyce
下載他們，並使用us-ascii編碼存儲 解壓後的文件，保存在臨時目錄，比如/tmp/gutenberg.
hadoop@ubuntu:~$ ls -l /tmp/gutenberg/
total 3592
-rw-r--r-- 1 hadoop hadoop 674425 2007-01-22 12:56 20417-8.txt
-rw-r--r-- 1 hadoop hadoop 1423808 2006-08-03 16:36 7ldvc10.txt
-rw-r--r-- 1 hadoop hadoop 1561677 2004-11-26 09:48 ulyss12.txt
hadoop@ubuntu:~$
復制本地數據到HDFS
在我們運行MapRece job 前，我們需要將本地的文件復制到HDFS中：
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -FromLocal /tmp/gutenberg gutenberg
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -ls
Found 1 items
/user/hadoop/gutenberg <dir>
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -ls gutenberg
Found 3 items
/user/hadoop/gutenberg/20417-8.txt <r 1> 674425
/user/hadoop/gutenberg/7ldvc10.txt <r 1> 1423808
/user/hadoop/gutenberg/ulyss12.txt <r 1> 1561677
執行 MapRece job
現在，一切准備就緒，我們將在運行Python MapRece job 在Hadoop集群上。像我上面所說的，我們使用的是
HadoopStreaming 幫助我們傳遞數據在Map和Rece間並通過STDIN和STDOUT，進行標准化輸入輸出。
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop jar contrib/streaming/hadoop-0.19.1-streaming.jar
-mapper /home/hadoop/mapper.py -recer /home/hadoop/recer.py -input gutenberg/*
-output gutenberg-output
在運行中，如果你想更改Hadoop的一些設置，如增加Rece任務的數量，你可以使用「-jobconf」選項：
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop jar contrib/streaming/hadoop-0.19.1-streaming.jar
-jobconf mapred.rece.tasks=16 -mapper ...
一個重要的備忘是關於Hadoop does not honor mapred.map.tasks
這個任務將會讀取HDFS目錄下的gutenberg並處理他們，將結果存儲在獨立的結果文件中，並存儲在HDFS目錄下的
gutenberg-output目錄。
之前執行的結果如下：
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop jar contrib/streaming/hadoop-0.19.1-streaming.jar
-mapper /home/hadoop/mapper.py -recer /home/hadoop/recer.py -input gutenberg/*
-output gutenberg-output
additionalConfSpec_:null
null=@@@userJobConfProps_.get(stream.shipped.hadoopstreaming
packageJobJar: [/usr/local/hadoop-datastore/hadoop-hadoop/hadoop-unjar54543/]
[] /tmp/streamjob54544.jar tmpDir=null
[...] INFO mapred.FileInputFormat: Total input paths to process : 7
[...] INFO streaming.StreamJob: getLocalDirs(): [/usr/local/hadoop-datastore/hadoop-hadoop/mapred/local]
[...] INFO streaming.StreamJob: Running job: job_200803031615_0021
[...]
[...] INFO streaming.StreamJob: map 0% rece 0%
[...] INFO streaming.StreamJob: map 43% rece 0%
[...] INFO streaming.StreamJob: map 86% rece 0%
[...] INFO streaming.StreamJob: map 100% rece 0%
[...] INFO streaming.StreamJob: map 100% rece 33%
[...] INFO streaming.StreamJob: map 100% rece 70%
[...] INFO streaming.StreamJob: map 100% rece 77%
[...] INFO streaming.StreamJob: map 100% rece 100%
[...] INFO streaming.StreamJob: Job complete: job_200803031615_0021
[...] INFO streaming.StreamJob: Output: gutenberg-output hadoop@ubuntu:/usr/local/hadoop$
正如你所見到的上面的輸出結果，Hadoop 同時還提供了一個基本的WEB介面顯示統計結果和信息。
當Hadoop集群在執行時，你可以使用瀏覽器訪問 http://localhost:50030/ ，如圖：
檢查結果是否輸出並存儲在HDFS目錄下的gutenberg-output中：
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -ls gutenberg-output
Found 1 items
/user/hadoop/gutenberg-output/part-00000 <r 1> 903193 2007-09-21 13:00
hadoop@ubuntu:/usr/local/hadoop$
可以使用dfs -cat 命令檢查文件目錄
hadoop@ubuntu:/usr/local/hadoop$ bin/hadoop dfs -cat gutenberg-output/part-00000
"(Lo)cra" 1
"1490 1
"1498," 1
"35" 1
"40," 1
"A 2
"AS-IS". 2
"A_ 1
"Absoluti 1
[...]
hadoop@ubuntu:/usr/local/hadoop$
注意比輸出，上面結果的(")符號不是Hadoop插入的。
轉載僅供參考，版權屬於原作者。祝你愉快，滿意請採納哦
⑼ MapRece編寫
MapRece是一種用於大規模數據處理的編程模型，能夠充分地利用集群的優勢並行地處理海量數據。該模型非常簡單，主要分為map和 rece兩個階段，每個階段都有鍵值對作為輸入和輸出，並且鍵值對的類型由程序來指定，分配到指定的map和 rece兩個函數來進行處理。map 過程需要實現 org.apache.hadoop.mapred.Mapper 介面，並實現介面的map 方法。map方法中 value值存儲的是HDFS文件中的一行(以回車符作為結束的標記)，而key值為該行的首字元相對於文件首地址的偏移量。rece過程則需要實現 org.apache.hadoop.mapred.Recer介面，並且實現介面的rece方法。rece方法輸入的 key為 map中輸出的key值，而values則對應了map過程中該key輸出的value集合。
⑽ 大數據培訓一般都將些什麼內容
參加大數據培訓都學習些什麼，隨著互聯網在近幾年的飛速發展，大數據頁被越來越多的人所熟知，不管是行內的人還是行外的人都紛紛加入這個行業！於是許多的培訓機構也紛紛崛起，開設相關的培訓課程！作為一個未來的十分有前景的行業。成為大數據工程師無疑是迎接一個很有前景的職業生涯，那麼大數據工程師，要學習什麼內容呢。
大數據培訓的內容：
不同的培訓機構來說，根據注重的點不同大數據課程內容也有所差異，培訓周期也都不大相同。課程內容除開第一階段學習Java語言基礎之外，還要學習HTML、CSS、Java、JavaWeb和資料庫、Linux基礎、Hadoop生態體系、Spark生態體系等課程內容。
二、基礎內容學習
對於初學大數據的同學來說尤其是零基礎的，感覺大數據比較復雜比較難，很難記住。但是對於大數據學習者而言，對於學員的邏輯思維能力要求較高。
三、項目實戰訓練
參加大數據培訓學習還有一項內容是必須要注意的，那就是課程內容安排上必須要有大數據開發相關的項目，項目練習是學習的核心，在這個過程中可以讓我們更加了解項目製作流程，積累一定的經驗，在後邊的工作面授中也能應答自如。