如何成爲一名大數據工程師

時間 2019-11-30

標籤如何成爲一名數據工程師简体版

原文原文鏈接

如何成爲一名大數據工程師

一. 前言

自從2012年開始,互聯網技術日新月異,到現在2018年,已經產生了抖音,滴滴打車,ofo,王者榮耀等巨大互聯網產品。html

在這些產品的歷史軌跡中,我暫且將IT互聯網行業分爲三個產業ABC,人工智能/大數據/雲計算,雖然有失偏頗。java

首先互聯網產品訪問的人數居多,併發量巨高,而TCP鏈接通信在一臺再怎麼牛的單機上,也會很快出現CPU,內存或硬盤資源不夠的狀況,這時須要有種手段,能讓你自動解決資源分配,這就是C,Cloud,雲計算,須要解決分佈式負載訪問,容災備份等問題。程序員須要經過設計各類中間件來進行壓力分流,儘量人工對業務進行細粒度拆分,而後可彈性資源使用。目前微服務和容器運維是一個常見方案。好比,網站訪問,能夠用Nginx來負載均衡分流到十臺機器,而十臺機器可能須要訪問到緩存redis,能夠再根據主鍵Hash分流....(注意：事實上不少狀況都是程序員本身根據業務來設計分佈式負載,若是量翻倍還需改進,但事實上翻倍通常意味着投資人更多,能吸取更多人才來改進)。node

中間件支撐了不少業務的落地,可是數據愈來愈多,愈來愈雜。如何更快的存儲數據,如何存海量大致積數據,如何存海量小體積數據,如何更快地拿數據,因而出現了不少的分佈式數據庫中間件。因爲數據的存儲和數據的計算更多的和業務有關,出現了數據倉庫,數據清洗,數據建模等,這部分爲B,BigData,大數據,目前最流行的有Hadoop生態圈,分兩塊：分佈式存儲,分佈式計算。（注：底層技術仍能夠說是雲計算）python

數據不少,咱們也清洗了不少數據,可是數據有什麼用,早期由數據挖掘建模,用傳統模型來進行業務決策,現在神經網絡,深度學習,監督學習,統稱機器學習LM,大統了該領域,稱A,Artifical,人工智能。mysql

如今不少人都想要去作算法,如AI,好比我本科畢業了,就想進大公司作AI。可是,你根本競爭不過碩士博士。而目前大公司不少AI實際上是調參工程師。而云計算開發又須要很多經從來磨練,通常沒兩三年經驗沒人要,而事實上,你最缺的就是經驗。雲計算要摩擦摩擦,就如我通常。因此,大數據開發是相對容易入門的崗位。你只需具有基本的計算機常識,掌握一兩門語言,研究一下Hadoop生態圈並簡單使用便可。git

除此ABC以外,還有傳統的Web先後端開發,移動客戶端開發,遊戲引擎開發等,路還有不少哈。程序員

二. 大數據工程師崗位介紹

其實目前大數據工程師有兩個方向,一種是專門作業務的,負責將Hadoop底層的數據倒來倒去,或者不一樣源的數據進行轉換,作下簡單數據清洗或者統計後給到算法或開發端,這個不在咱們的考慮範圍。github

另一種是偏開發的,巨雜無比,根據公司業務有所不一樣,可是若是你熟悉Hadoop生態圈,什麼業務場景均可以很快熟悉的。redis

學習如下的知識,很快你就能夠進入大數據的世界了。下面的一些軟件都是以比較簡單的方式搭建, 由於在生產環境下,大部分都是以多機部署的方式.然而, 因爲初學, 咱們第一個目的就是知道這是什麼,而後知道怎麼使用.算法

三. 前期準備

工欲善其事必先利其器.

(1)編程語言

請掌握Java或Python語言基本語法。因此,學習大數據以前也要必定的計算機基礎,學習這兩門語言也是一個漫長的過程,可是不努力哪裏會有獲得好結果的喜悅呢？你說不努力獲得好結果,那你不會很心虛嗎。坑慢慢填,遲早要填的。學習編程語言,第一步就是找一些教材或視頻,而後裝下環境,邊學習邊敲代碼實踐。

(2)常識和挑戰

數據愈來愈多,而數據類型分：

結構化數據：關係數據。
半結構化數據：XML數據。
非結構化數據：Word, PDF, 文本,媒體日誌。

數據的挑戰：

採集數據
存儲數據
搜索數據
傳輸數據
分析數據

數據從哪裏來,採集數據很重要。

數據如何存儲,存在哪裏。

數據太大存不下怎麼辦。

數據搜索,在海量數據怎麼找到我想要的數據。

我如何將大批數據傳輸到另外的地方。

我想要統計海量數據中某城市的男女比例。這些都是巨大的問題。

(3)Hadoop3.1.1搭一下

初學的時候,咱們不求甚解,先搭建起來Hadoop服務玩一下再探究深層。官方文檔在此Hadoop 3.1.1

Hadoop有分佈式文件系統HDFS的功能,也有MapReduce（分而治之）的計算模式提供,生態圈也很完善,市面上招人都須要會這個！

搭了這個後,能夠將文件存上去,並且丟多少上去都不要緊,只要你的集羣機器夠多！

個人實驗操做系統是ubuntu16.04, ip addr知道局域網IP爲192.168.0.21。

1.軟件包下載

從我國比較快的鏡像站下載,爲方便,建一個全部用戶都能訪問的/app/hadoop目錄：

sudo mkdir /app
sudo chmod 777 /app
mkdir /app/hadoop
cd /app/hadoop
wget https://mirrors.tuna.tsinghua.edu.cn/apache/hadoop/common/hadoop-3.1.1/hadoop-3.1.1.tar.gz

其中,文件將下載在/app/hadoop,請注意這個路徑！

解壓：

cd /app/hadoop
tar zxvf hadoop-3.1.1.tar.gz
cd hadoop-3.1.1/

Hadoop有三種部署模式,單機部署,僞分佈式部署,真分佈式部署。

由於Hadoop變化很快,因此最新的安裝方式請參考官網。這裏使用僞分佈式搭建,保證能夠跑起來便可,生產級別的有專門的運維崗位處理,這也屬於之後的進階技能,就是你須要會運維Hadoop!

咱們使用僞分佈式部安裝Hadoop。

2.SSH受權

先授下權,保證能夠ssh訪問。

# 若是未裝此軟件請安裝
# sudo apt-get install openssh-server
# sudo service ssh start

ssh-keygen -t rsa 
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
chmod 0600 ~/.ssh/authorized_keys

ssh username@127.0.0.1

其中username爲操做系統的用戶名。

3.安裝Java並配置環境變量

裝下Java,畢竟生態圈大部分用Java寫的：

到此下載：JDK8

將其解壓到/app/hadoop同個目錄。

sudo vim /etc/profile.d/hadoop.sh,添加:

# 這是Java的配置
export JAVA_HOME=/app/hadoop/jdk1.8.0_191
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=.:$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH

# 這是Hadoop的配置
export HADOOP_HOME=/app/hadoop/hadoop-3.1.1
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 PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin 
export HADOOP_INSTALL=$HADOOP_HOME

環境變量生效請source /etc/profile.d/hadoop.sh,而後:

java --version

4.hadoop配置

重置hadoop的一些配置:

(1).編輯hadoop-env.sh

vim  /app/hadoop/hadoop-3.1.1/etc/hadoop/hadoop-env.sh

添加:

export JAVA_HOME=/app/hadoop/jdk1.8.0_191
export HADOOP_OPTS="-Djava.library.path=${HADOOP_HOME}/lib/native"

(2).編輯core-site.xml

vim  /app/hadoop/hadoop-3.1.1/etc/hadoop/core-site.xml

添加:

<configuration>
   <property>
      <name>fs.default.name </name>
      <value>hdfs://localhost:9000</value> 
   </property>
</configuration>

(3).編輯yarn-site.xml

vim  /app/hadoop/hadoop-3.1.1/etc/hadoop/yarn-site.xml

添加

<!-- 指定nodemanager啓動時加載server的方式爲shuffle server -->
<property>
    <name>yarn.nodemanager.aux-services</name>
    <value>mapreduce_shuffle</value>
</property>

(4).編輯mapred-site.xml

vim  /app/hadoop/hadoop-3.1.1/etc/hadoop/mapred-site.xml

添加：

<configuration>
   <property> 
      <name>mapreduce.framework.name</name>
      <value>yarn</value>
   </property>
</configuration>

(5).編輯hdfs-site.xml

vim  /app/hadoop/hadoop-3.1.1/etc/hadoop/hdfs-site.xml

添加:

<configuration>
   <property>
      <name>dfs.replication</name>
      <value>1</value>
   </property>
   <property>
      <name>dfs.name.dir</name>
      <value>file:///app/hadoop/hdfs/namenode</value>
   </property>
   <property>
      <name>dfs.data.dir</name> 
      <value>file:///app/hadoop/hdfs/datanode</value> 
   </property>
   <property>
       <name>dfs.permissions</name>
       <value>false</value>
   </property>
</configuration>

其中/app/hadoop/hdfs是存儲的位置,請:

mkdir /app/hadoop/hdfs
mkdir /app/hadoop/hdfs/namenode
mkdir /app/hadoop/hdfs/datanode

5.初始化並啓動

執行初始化HDFS文件系統：

hdfs namenode -format

啓動HDFS：

start-dfs.sh

啓動yarn守護進程：

start-yarn.sh

輸入：

jps

能夠看到服務（稍後會介紹）：

31472 NameNode
31842 SecondaryNameNode
31638 DataNode
32810 Jps
32076 ResourceManager
32223 NodeManager

6.驗證

打開http://127.0.0.1:9870能夠看到Hadoop Web界面,你也能夠在127.0.0.1:8042訪問集羣中的全部應用程序。注意：和老版本的端口是不同的。

在HDFS上建立一個文件夾,而且賦予權限：

# 建立文件夾
hadoop fs -mkdir /user

# 受權
hadoop fs -chmod 777 /user

你也能夠在這裏http://127.0.0.1:9870/explorer.html建立。

(4)HDFS概念

如下節選自某網站：

HDFS遵循主從架構,它具備如下元素：

名稱節點 - Namenode,一臺機器的一個進程。管理文件系統命名空間。規範客戶端對文件的訪問。它也執行文件系統操做,如重命名,關閉和打開的文件和目錄。

數據節點 - Datanode,一臺機器的一個進程。數據節點上的文件系統執行的讀寫操做,根據客戶的請求。還根據名稱節點的指令執行操做,如塊的建立,刪除和複製。

塊,通常用戶數據存儲在HDFS文件。在一個文件系統中的文件將被劃分爲一個或多個段和/或存儲在我的數據的節點。這些文件段被稱爲塊。換句話說,數據的HDFS能夠讀取或寫入的最小量被稱爲一個塊。缺省的塊大小爲64MB,但它能夠增長按須要在HDFS配置來改變。

HDFS的目標：

故障檢測和恢復：因爲HDFS包括大量的普通硬件,部件故障頻繁。所以HDFS應該具備快速和自動故障檢測和恢復機制。
巨大的數據集：HDFS有數百個集羣節點來管理其龐大的數據集的應用程序。
數據硬件：請求的任務,當計算髮生不久的數據能夠高效地完成。涉及巨大的數據集特別是它減小了網絡通訊量,並增長了吞吐量。

(5)HDFS使用

使用該命令能夠查看命令行操做：

hadoop fs -help

加載服務器信息後,使用'ls' 能夠找出文件列表中的目錄,文件狀態。下面給出的是ls,能夠傳遞一個目錄或文件名做爲參數的語法。

hadoop fs -ls <args>
hadoop fs -mkdir /user/input

將本地/home/file.txt文件上傳：

hadoop fs -put /home/file.txt /user/input

以使用ls命令驗證文件：

hadoop fs -ls /user/input

從HDFS中檢索數據：

hadoop fs -cat /user/input/file.txt

從HDFS獲得文件使用get命令在本地文件系統:

hadoop fs -get /user/input/file.txt  /home/file-get.txt

可使用下面的命令關閉HDFS:

stop-dfs.sh

(6)Hadoop MapReduce

參考：https://www.cnblogs.com/RzCong/p/7362352.html

MapReduce是一種編程模型。Hadoop MapReduce採用Master/slave結構。只要按照其編程規範,只須要編寫少許的業務邏輯代碼便可實現一個強大的海量數據併發處理程序。核心思想是：分而治之。Mapper負責分,把一個複雜的業務,任務分紅若干個簡單的任務分發到網絡上的每一個節點並行執行,最後把Map階段的結果由Reduce進行彙總,輸出到HDFS中,大大縮短了數據處理的時間開銷。MapReduce就是以這樣一種可靠且容錯的方式進行大規模集羣海量數據進行數據處理,數據挖掘,機器學習等方面的操做。

MapReduce分佈式計算框架體系結構:

首先理解幾個概念：

Master：是整個集羣的惟一的全局管理者,負責做業管理.狀態監控和任務調度等,即MapReduce中的JobTracker
Slave：負責任務的執行和任務狀態回報,即MapReduce中的TaskTracker
Job&Task：在hadoop mapreduce中,一個Job它是一個任務,主業務。一個Job能夠拆分紅多個Task,map Task與reduce Task。

JobTracker是一個後臺服務進程,啓動以後,會一直監聽並接收來自各個TaskTracker發送的心跳信息,包括資源使用狀況和任務運行狀況等信息

JobTracker的主要功能：

做業控制：在hadoop中每一個應用程序被表示成一個做業,每一個做業又被分紅多個任務,JobTracker的做業控制模塊則負責做業的分解和狀態監控。
最重要的狀態監控：主要包括TaskTracker狀態監控.做業監控和任務狀態監控。主要做用：容錯和爲任務調度提供決策依據。
資源管理。

TaskTracker是JobTracker和Task之間的橋樑：一方面,從JobTracker接收並執行各類命令：運行任務.殺死任務等；另外一方面講本地節點上各個任務狀態經過心跳週期性彙報給JobTracker。TaskTracker與JobTracker和Task之間採用了RPC協議進行通訊。功能：

彙報心跳：Tracker週期性講全部節點上各類信息經過心跳機制彙報給JobTracker。這些信息包括兩部分:
    *機器級別信息：節點健康狀況,資源使用狀況等。
    *任務級別信息：任務執行進度.任務運行狀態等。
執行命令：JobTracker會給TaskTracker下達各類命令,主要包括：
    啓動任務（LaunchTaskAction）.提交任務（CommunitTaskAction）,
    殺死任務（KillJobAction）和從新初始化（TaskTrackerReinitAction）。

MapReduce體系結構裏有兩類節點,第一個是JobTracker,它是一個master管理節點,另外一個是TaskTracker。客戶端（Client）提交一個任務（Job）,JobTracker把他提交到候選列隊裏,將Job拆分紅map任務（Task）和reduce任務（Task）,把map任務和reduce任務分給TaskTracker執行。在mapreduce編程模型裏,Task通常起在和DataNode所在的同一臺物理機上。如上圖。

MapReduce分佈式工做流程：

1.分佈式的運算程序每每須要分紅至少2個階段：

MapReduce的第一階段是Map,運行的實例叫Map Task,第二階段是Reduce,運行的實例叫Reduce Task。每一個Task只須要完成後把文件輸出到本身的工做目錄便可。

2.第一階段的Task併發實例各司其職,各自爲政,互不相干,徹底並行

3.第二階段的Task併發實例互不相干,可是他們的數據以來於上一階段的全部Task併發實例的輸出

4.MapReduce編程模型,只能包含一個Map階段和一個Reduce階段,若是用戶的業務邏輯很是複雜,那就只能來多個mapreduce程序,串行運行

MapReduce容錯機制：

MapReduce的第一階段是Map,運行的實例叫Map Task,第二階段是Reduce,運行的實例叫Reduce Task。第二階段Reduce要等第一階段Map上的Map Task完成以後才能開始。若是Map Task運行失敗,如何處理？

這時候就要啓動mapreduce的容錯機制了,它容許整個執行過程當中TaskTracker中間出現宕機,發生故障,JVM發生重啓等等這些狀況,容許它出錯。處理的方式：

1.重複執行
　　有多是job自己問題,硬件問題,數據的問題都有可能,默認會從新執行,若是從新執行4次都失敗就放棄執行。

2.推測執行
　　因爲要Map端全部任務執行完纔會執行reduce任務,可能存在某個節點完成的特別慢,JobTracker發現它很慢的時候,說明它出現了問題,另外找一臺TaskTrack執行同一任務,哪一個先完成就取該結果,結束另外一個TaskTracker。

如下是一個例子

單詞計數（wordcount）主要步驟：

1.讀數據
2.按行處理
3.按空格切分行內單詞
4.HashMap（單詞,value+1）
等分給本身的數據片所有讀取完以後
5.將HashMap按照首字母範圍分爲3個HashMap
6.將3個hashMap分別傳給3個ReduceTask

主要流程以下圖：

代碼實現：

理解了原理,那麼就從一個Job開始,從分Map任務和Reduce任務開始。用戶編寫的程序分爲三個部分：Mapper,Reducer,Driver。

Mapper的輸入數據和輸出數據是KV對的形式（KV的類型可自定義）,Mapper的業務邏輯是寫在map（）方法中,map（）方法（maptask進程）對每個<k,v>調用一次

Reducer的輸入數據類型對應Mapper的輸出數據類型,也是KV。Reducer的業務邏輯寫在reduce（）方法中,Reduce（）方法對每一組相同的<k,v>組調用一次。

用戶的Mapper和Reduce都要繼承各自的父類。

整個程序須要一個Driver來進行提交,提交的是一個描述了各類必要信息的job對象。　

1.設定Map任務：

WordCountMapper.java

package test;
 
 
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
 
import java.io.IOException;
 
/**
 * Created by Rz_Lee on 2017/8/14.
 * KEYIN:默認狀況下是mr框架所讀到的一行文本的偏移量,Long
 * 可是在hadoop中有本身的更精簡的序列化接口,因此不直接用Long,而用LongWritable
 *
 * VALUE:默認狀況下是mr框架所讀到的一行文本內容,String,同上用Text
 *
 *KEYOUT:是用戶自定義邏輯處理寫成以後輸出數據中的key,在此是單詞,String,同上,用Text
 *VALUEOUT:是用戶自定義邏輯處理寫成以後輸出數據中的value,在此處是單詞總次數,Integer,同上,用IntWritale
 *
 */
public class WordCountMapper extends Mapper<LongWritable,Text,Text,IntWritable> {
    /**
     * map階段的業務邏輯就寫在自定義的map()方法中
     * maptask會對每一行輸入數據調用一次咱們自定義的map()方法
     * @param key
     * @param value
     * @param context 輸出內容
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //將maptask傳給咱們的文本內容先轉換成String
        String line = value.toString();
        //根據空格將一行切分紅單詞
        String[] words = line.split(" ");
 
        //將單詞輸出爲<單詞,1>
        for(String word:words)
        {
            //將單詞做爲key,將次數1做爲value,以便於後續的數據分發,能夠根據單詞分發經便於相同單詞會到相同的reduce task
            context.write(new Text(word),new IntWritable(1));
        }
    }
}

2.設定Reduce任務：

WordCountReducer.java

package test;
 
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
 
import java.io.IOException;
 
/**KEYIN,VALUEIN 對應mapper輸出的KEYOUT,VALUEOUT類型對應
 *
 * KYEOUT,VALUEOUT 是自定義reduce邏輯處理結果的輸出數據類型
 * KYEOUT是單詞
 * VALUE是總次數
 * Created by Rz_Lee on 2017/8/14.
 */
public class WordCountReducer extends Reducer<Text,IntWritable,Text,IntWritable>{
    /**
     *
     * @param key 是一組相同單詞KV對的key,如<hi,1>,<hi,1>
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int count=0;
        for (IntWritable value:values)
        {
            count+=value.get();
        }
        context.write(key,new IntWritable(count));
    }
}

3.wordcount程序的操做類,提交運行mr程序的yarn客戶端：

WordCountDriver.java

package test;
 
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.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 
 
/**至關於一個yarn集羣的客戶端
 * 須要在此封裝咱們的mr程序相關運行參數,指定jar包
 * 最後提交給yarn
 * Created by Rz_Lee on 2017/8/14.
 */
public class WordCountDriver {
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        /*conf.set("mapreduce.framework.name","yarn");
        conf.set("yarn.resourcemanager.hostname","srv01");*/
 
        /*job.setJar("/usr/hadoop/wc.jar");*/
        //指定本程序的jar包所在的本地路徑
        job.setJarByClass(WordCountDriver.class);
 
 
        //指定本業務job使用的mapper/reducer業務類
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);
 
        //指定mapper輸出數據的KV類型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
 
        //指定最終輸出的數據的KV類型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
 
        //指定job的輸入原始文件所在目錄
        FileInputFormat.setInputPaths(job,new Path(args[1]));
        //指定job的輸出結果所在目錄
        FileOutputFormat.setOutputPath(job, new Path(args[2]));
 
        //將job中配置的相關參數,以及job所用的java類所在的jar包,提交給yarn去運行
        /*job.submit();*/
        boolean res = job.waitForCompletion(true);
        System.exit(res?0:1);
    }
}

4.把wordcount項目導成jar包,上傳到HDFS,如何打包：

新建test文件夾, 在裏面新建上述三個java文件：

cd test
javac -d . WordCountMapper.java WordCountReducer.java WordCountDriver.java

mkdir foo
mv ./test foo/

vim MANIFEST.MF
# 添加,最後一行空行
Mainfest-Version: 1.0
Main-Class: test.WordCountDriver

jar cvfm test.jar MANIFEST.MF -C foo/ .

建立文件夾：

hadoop fs -mkdir /input
hadoop fs -ls /

用命令行或者打開http://127.0.0.1:9870/explorer.html新建input文件夾,丟入幾個txt文件。

而後：

vim /etc/profile.d/hadoop.sh

export CLASSPATH=.:$HADOOP_HOME/share/hadoop/common/hadoop-common-3.1.1.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.1.1.jar:$HADOOP_HOME/share/hadoop/common/lib/commons-cli-1.2.jar:$CLASSPATH


source /etc/profile.d/hadoop.sh

終端運行：

yarn jar test.jar test.WordCountDriver /input /output

打開瀏覽器輸入127.0.0.1:8042再點擊RM Home,在網頁上能夠看見整個Job的運行狀況。

若是發現任務卡住了,緣由是內存或硬盤不足了。。。。這該死的窮人都跑不起hadoop了。。。

很重要！若是嫌打包麻煩,請直接用官方包測試：

hadoop jar /app/hadoop/hadoop-3.1.1/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.1.jar wordcount /input /output

運行過程出現錯誤: 找不到或沒法加載主類 org.apache.hadoop.mapreduce.v2.app.MRAppMaster

在命令行下輸入以下命令,並將返回的地址複製。

hadoop classpath

編輯yarn-site.xml

vim /app/hadoop/hadoop-3.1.1/etc/hadoop/yarn-site.xml

添加以下內容:

<property>
        <name>yarn.application.classpath</name>
        <value>/app/hadoop/hadoop-3.1.1/etc/hadoop:/app/hadoop/hadoop-3.1.1/share/hadoop/common/lib/*:/app/hadoop/hadoop-3.1.1/share/hadoop/common/*:/app/hadoop/hadoop-3.1.1/share/hadoop/hdfs:/app/hadoop/hadoop-3.1.1/share/hadoop/hdfs/lib/*:/app/hadoop/hadoop-3.1.1/share/hadoop/hdfs/*:/app/hadoop/hadoop-3.1.1/share/hadoop/mapreduce/lib/*:/app/hadoop/hadoop-3.1.1/share/hadoop/mapreduce/*:/app/hadoop/hadoop-3.1.1/share/hadoop/yarn:/app/hadoop/hadoop-3.1.1/share/hadoop/yarn/lib/*:/app/hadoop/hadoop-3.1.1/share/hadoop/yarn/*</value>
    </property>

重啓：

stop-dfs.sh
stop-yarn.sh

start-dfs.sh
start-yarn.sh

能夠跑了,那麼等待結果:

hadoop jar /app/hadoop/hadoop-3.1.1/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.1.jar wordcount /input /output 

hadoop job -list

2018-12-04 12:21:27,940 INFO mapreduce.Job:  map 0% reduce 0%
2018-12-04 12:21:31,982 INFO mapreduce.Job:  map 100% reduce 0%
2018-12-04 12:21:37,027 INFO mapreduce.Job:  map 100% reduce 100%
2018-12-04 12:21:37,048 INFO mapreduce.Job: Job job_1543897117281_0002 completed successfully

去HDFS看看ouput文件夾的結果便可。

(7) 其餘工具

Sqoop：將其餘數據源導入HDFS

flume：海量日誌採集.聚合和傳輸的系統, 可將數據寫入文本或者HDFS

HBase：做爲面向列的數據庫運行在HDFS之上

Pig/Hive: 查詢語言,MapReduce的高級封裝

storm: 分佈式計算框架,獨立於Hadoop

spark：一個針對超大數據集合的低延遲的集羣分佈式計算系統,Spark兼容Hadoop的APi,可以讀寫Hadoop的HDFS HBASE順序文件等。

四. Hive實驗

(1)前言

以前,咱們已經搭了Hadoop了,並且也跑了MapReduce。

Hive是基於Hadoop的一個數據倉庫工具,能夠將結構化的數據文件映射爲一張數據庫表,並提供簡單的sql查詢功能,能夠將sql語句轉換爲MapReduce任務進行運行。其優勢是學習成本低,能夠經過類SQL語句快速實現簡單的MapReduce統計,沒必要開發專門的MapReduce應用,十分適合數據倉庫的統計分析。

優勢：

　　1.可擴展性,橫向擴展,Hive 能夠自由的擴展集羣的規模,通常狀況下不須要重啓服務 橫向擴展：經過分擔壓力的方式擴展集羣的規模 縱向擴展：一臺服務器cpu i7-6700k 4核心8線程,8核心16線程,內存64G => 128G

　　2.延展性,Hive 支持自定義函數,用戶能夠根據本身的需求來實現本身的函數

　　3.良好的容錯性,能夠保障即便有節點出現問題,SQL 語句仍可完成執行

缺點：

　　1.Hive 不支持記錄級別的增刪改操做,可是用戶能夠經過查詢生成新表或者將查詢結 果導入到文件中（當前選擇的 hive-2.3.2 的版本支持記錄級別的插入操做）

　　2.Hive 的查詢延時很嚴重,由於 MapReduce Job 的啓動過程消耗很長時間,因此不能 用在交互查詢系統中。

　　3.Hive 不支持事務（由於不沒有增刪改,因此主要用來作 OLAP（聯機分析處理）,而 不是 OLTP（聯機事務處理）,這就是數據處理的兩大級別）。

(2)安裝Hive

咱們的Hadoop是3.1.1, 因此安裝Hive3.1.1

/app/hadoop
wget http://mirrors.hust.edu.cn/apache/hive/hive-3.1.1/apache-hive-3.1.1-bin.tar.gz
tar xvf apache-hive-3.1.1-bin.tar.gz

編輯環境變量:

sudo vim /etc/profile.d/hadoop.sh

配置:

# 這是Java的配置
export JAVA_HOME=/app/hadoop/jdk1.8.0_191
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=.:$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH

# 這是Hadoop的配置
export HADOOP_HOME=/app/hadoop/hadoop-3.1.1
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 PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin 
export HADOOP_INSTALL=$HADOOP_HOME
export CLASSPATH=.:$HADOOP_HOME/share/hadoop/common/hadoop-common-3.1.1.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.1.1.jar:$HADOOP_HOME/share/hadoop/common/lib/commons-cli-1.2.jar:$CLASSPATH

# 這是Hive的配置
export HIVE_HOME=/app/hadoop/apache-hive-3.1.1-bin
export PATH=$PATH:$HIVE_HOME/bin

生效環境變量:

source /etc/profile.d/hadoop.sh

增長Hive配置:

cd /app/hadoop/apache-hive-3.1.1-bin/conf
cp hive-env.sh.template hive-env.sh
cp hive-default.xml.template hive-site.xml
cp hive-log4j2.properties.template hive-log4j2.properties

編輯 hive-env.sh:

export JAVA_HOME=/app/hadoop/jdk1.8.0_191
export HADOOP_HOME=/app/hadoop/hadoop-3.1.1
export HIVE_HOME=//app/hadoop/apache-hive-3.1.1-bin
export HIVE_CONF_DIR=$HIVE_HOME/conf
export HIVE_AUX_JARS_PATH=$HIVE_HOME/lib/*

按照Docker安裝MYSQL, 如今:

sudo docker exec -it  GoSpider-mysqldb mysql -uroot -p123456789

MYSQL帳戶:root, 密碼:123456789, 而後下載JDBC驅動到目錄下:

wget https://dev.mysql.com/get/archives/mysql-connector-java-8.0/mysql-connector-java-8.0.11.zip
unzip mysql-connector-java-8.0.11.zip

cp /app/hadoop/mysql-connector-java-8.0.11/mysql-connector-java-8.0.11.jar /app/hadoop/apache-hive-3.1.1-bin/lib/

編輯 hive-site.xml, 將裏面東西全刪掉, 換成:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<property>
    <name>system:java.io.tmpdir</name>
    <value>/app/hadoop/apache-hive-3.1.1-bin/tmp</value>
</property>
<property>
    <name>system:user.name</name>
    <value>${user.name}</value>
</property>
<property>
    <name>javax.jdo.option.ConnectionUserName</name>
    <value>root</value>
    <description>Username to use against metastore database</description>
</property>
<property>
    <name>javax.jdo.option.ConnectionPassword</name>
    <value>123456789</value>
    <description>password to use against metastore database</description>
</property>
<property>
    <name>javax.jdo.option.ConnectionURL</name>
    <value>jdbc:mysql://192.168.0.21:3306/hive?createDatabaseIfNotExist=true&amp;characterEncoding=UTF-8&amp;useSSL=false</value>
    <description>
        JDBC connect string for a JDBC metastore.
        To use SSL to encrypt/authenticate the connection, provide database-specific SSL flag in the connection URL.
        For example, jdbc:postgresql://myhost/db?ssl=true for postgres database.
    </description>
</property>
<property>
    <name>javax.jdo.option.ConnectionDriverName</name>
    <value>com.mysql.cj.jdbc.Driver</value>
    <description>Driver class name for a JDBC metastore</description>
</property>
<property>
    <name>hive.metastore.schema.verification</name>
    <value>false</value>
    <description>
        Enforce metastore schema version consistency.
        True: Verify that version information stored in is compatible with one from Hive jars.  Also disable automatic
        schema migration attempt. Users are required to manually migrate schema after Hive upgrade which ensures
        proper metastore schema migration. (Default)
        False: Warn if the version information stored in metastore doesn't match with one from in Hive jars.
    </description>
</property>
</configuration>

編輯hive-log4j2.properties:

property.hive.log.dir = ${sys:java.io.tmpdir}/${sys:user.name}
# 更改成
property.hive.log.dir = /app/hadoop/apache-hive-3.1.1-bin/logs

啓動Hive前, 咱們先建立MYSQL表Hive:

source /etc/profile.d/hadoop.sh
schematool -dbType mysql -initSchema

等待完成後, 咱們就可使用了.

(3)驗證Hive

啓動交互:

hive

hive> show databases;
OK
default
Time taken: 0.789 seconds, Fetched: 1 row(s)
hive>

建個庫bigdata試試:

show databases;                                                     //查看數據庫
create database bigdata;                                            //新建數據庫 
use bigdata;                                                        //使用數據庫

創建表:

create table t1 (id int, name string)  row format delimited fields terminated by '\t';              //建表
show tables;                                                                                        //查看數據表
show tables in bigdata;                                                                             //查看數據庫下的表
show create table t1;                                                                               //查看建表語句


create table stu(
id int,
name string,
gender string,
age int,
master string
)
row format delimited
fields terminated by ','
stored as textfile;

這樣生成了一個數據倉庫在: hdfs://localhost:9000/user/hive/warehouse/bigdata.db

咱們來表裏插些數據, 新建一個students.txt:

cd /app/hadoop
vim students.txt

95001,李勇,男,20,CS
95002,劉晨,女,19,IS
95003,王敏,女,22,MA
95004,張立,男,19,IS
95005,劉剛,男,18,MA
95006,孫慶,男,23,CS
95007,易思玲,女,19,MA
95008,李娜,女,18,CS
95009,夢圓圓,女,18,MA
95010,孔小濤,男,19,CS
95011,包小柏,男,18,MA
95012,孫花,女,20,CS
95013,馮偉,男,21,CS
95014,王小麗,女,19,CS
95015,王君,男,18,MA
95016,錢國,男,21,MA
95017,王風娟,女,18,IS
95018,王一,女,19,IS
95019,邢小麗,女,19,IS
95020,趙錢,男,21,IS
95021,週二,男,17,MA
95022,鄭明,男,20,MA

加載數據進stu:

load data local inpath '/app/hadoop/students.txt' overwrite into table stu;                 //加載本地數據到表中

導完數據就能夠操做表了, 只不過hive會將sql語句翻譯成mr程序來執行。

查看數據:

select * from stu;
describe stu;
select * from stu where master=CS;
drop table bigdata;                                             //刪除表

內部表刪除時,會同時刪除存儲在hdfs上的真實數據和在mysql中的元數據, 好比上述.

外部表刪除時,僅刪除在mysql中的元數據,並不會刪除在hdfs上創建的表（數據倉庫）。

建外部表:

create external table stu_external(
id int,
name string,
gender string,
age int,
master string
)
row format delimited
fields terminated by ','
stored as textfile
location '/user/hive_external_table';


show create table stu_external;
load data local inpath '/app/hadoop/students.txt' overwrite into table stu_external;                    //加載本地數據到表中
# load data inpath '/user/hive_external_table/students.txt' into table stu_external;                    //你也能夠從hdfs中追加數據到hive表

倉庫數據將在: hdfs://user/hive_external_table/students.txt, 即便drop table stu_external; 數據也還在.

(4) 高級驗證: 分區表

分區表, 有2份表, 分別是1/2班的學生名單:

vim /app/hadoop/students1.txt
1.jimmy,20
2,tim,22
3,jerry,19
 
 
vim /app/hadoop/students2.txt
1,tom,23
2,angela,19
3,cat,20

建立分區表：

create table stu_partition(
id int,
name string,
age int
)
partitioned by(classId int)
row format delimited
fields terminated by ','
stored as textfile;

將這2張表的數據分別導入hive表中:

load data local inpath '/app/hadoop/students1.txt' into table stu_partition partition(classId=1);
load data local inpath '/app/hadoop/students2.txt' into table stu_partition partition(classId=2);

hive表中就能將本來的兩張表當作一張表來操做,好比: select * from stu_partition; 就展現出2張表中的所有數據:

沒有分區的表在hdfs上位置就是在以表名爲文件夾名的目錄下,而分區表在表名目錄下還有分區目錄,各hive表存在各自的目錄下。

用來分區的字段就變成了僞字段,在操做的時候能夠拿來當已知字段使用:

describe stu_partition;
OK
id                      int                                         
name                    string                                      
age                     int                                         
classid                 int                                         
                 
# Partition Information          
# col_name              data_type               comment             
classid                 int

(5) 高級驗證:分桶表

分桶表

有數據以下：

vim /app/hadoop/tong.txt
1,jimmy
2,henry
3,tom
4,jerry
5,angela
6,lucy
7,lili
8,lilei
9,hanmeimei
10,timmy
11,jenef
12,alice
13,anna
14,donna
15,ella
16,fiona
17,grace
18,hebe
19,jean
20,joy
21,kelly
22,lydia
23,mary

創建分桶表

# 先開啓分桶
set hive.enforce.bucketing = true;

#建表
#先建一個普通表,導入數據
create table stu_list(
id int,
name string
)
row format delimited
fields terminated by ','
stored as textfile;

load data local inpath '/app/hadoop/tong.txt' into table stu_list;
select * from  stu_list;

#再建一個分桶表,將上一個表的查詢結果插入到分桶表中。
create table stu_buckets(
id int,
name string
)
clustered by(id) sorted by(id) into 3 buckets
row format delimited
fields terminated by ','
stored as textfile;

# 插入數據
insert overwrite table stu_buckets select * from stu_list;

select * from stu_buckets;

可看到查詢出的數據按id的hash值模除分桶數而後進到不一樣的桶。

在hdfs stu_buckets表目錄下,會出現3個文件：

000000_0
000001_0
000002_0

上述3個文件就是桶。

(6) 補充

1.Hive的存儲結構包括數據庫.表.視圖.分區和表數據等。數據庫,表,分區等等都對應HDFS上的一個目錄。表數據對應HDFS對應目錄下的文件。

2.Hive中全部的數據都存儲在HDFS中,沒有專門的數據存儲格式,由於Hive是讀模式（Schema On Read）,可支持 TextFile,SequenceFile,RCFile或者自定義格式等

3.只須要在建立表的時候告訴Hive數據中的列分隔符和行分隔符,Hive 就能夠解析數據

　　Hive 的默認列分隔符：控制符 Ctrl + A,\x01 Hive 的
　　Hive 的默認行分隔符：換行符 \n

4.Hive 中包含如下數據模型：

　　database：         在HDFS中表現爲${hive.metastore.warehouse.dir}目錄下一個文件夾
　　table：            在HDFS中表現所屬 database 目錄下一個文件夾
　　external table：   與table 相似,不過其數據存放位置能夠指定任意HDFS目錄路徑
　　partition：        在HDFS中表現爲 table 目錄下的子目錄
　　bucket：           在HDFS中表現爲同一個表目錄或者分區目錄下根據某個字段的值進行 hash 散 列以後的多個文件
　　view：             與傳統數據庫相似,只讀,基於基本表建立

5.Hive的元數據存儲在RDBMS 中,除元數據外的其它全部數據都基於HDFS存儲。默認狀況下,Hive 元數據保存在內嵌的 Derby 數據庫中,只能容許一個會話鏈接,只適合簡單的測試。實際生產環境中不適用,爲了支持多用戶會話,則須要一個獨立的元數據庫,使用 MySQL 做爲元數據庫,Hive 內部對 MySQL 提供了很好的支持。

6.Hive中的表分爲內部表.外部表.分區表和 Bucket 表.

內部表和外部表的區別：

　　刪除內部表,刪除表元數據和數據
　　刪除外部表,刪除元數據,不刪除數據

內部表和外部表的使用選擇：

　　大多數狀況,他們的區別不明顯,若是數據的全部處理都在 Hive 中進行,那麼傾向於 選擇內部表,可是若是 Hive 和其餘工具要針對相同的數據集進行處理,外部表更合適。
　　使用外部表訪問存儲在HDFS上的初始數據,而後經過 Hive 轉換數據並存到內部表中
　　使用外部表的場景是針對一個數據集有多個不一樣的 Schema
　　經過外部表和內部表的區別和使用選擇的對比能夠看出來,hive 其實僅僅只是對存儲在HDFS上的數據提供了一種新的抽象。而不是管理存儲在HDFS上的數據。因此無論建立內部 表仍是外部表,均可以對 hive 表的數據存儲目錄中的數據進行增刪操做。

分區表和分桶表的區別：

　　Hive 數據表能夠根據某些字段進行分區操做,細化數據管理,可讓部分查詢更快。同時表和分區也能夠進一步被劃分爲Buckets,分桶表的原理和MapReduce 編程中的HashPartitioner的原理相似。
　　分區和分桶都是細化數據管理,可是分區表是手動添加區分,因爲Hive是讀模式,因此對添加進分區的數據不作模式校驗,分桶表中的數據是按照某些分桶字段進行 hash 散列造成的多個文件,因此數據的準確性也高不少

五. Hbase實驗

(1) 前言

HBASE是一個高可靠性、高性能、面向列、可伸縮的分佈式存儲系統，利用HBASE技術可在廉價PC Server上搭建起大規模結構化存儲集羣。

HBASE的目標是存儲並處理大型的數據，更具體來講是僅需使用普通的硬件配置，就可以處理由成千上萬的行和列所組成的大型數據。

HBASE是Google Bigtable的開源實現，可是也有不少不一樣之處。好比：Google Bigtable使用GFS做爲其文件存儲系統，HBASE利用Hadoop HDFS做爲其文件存儲系統；Google運行MAPREDUCE來處理Bigtable中的海量數據，HBASE一樣利用Hadoop MapReduce來處理HBASE中的海量數據；Google Bigtable利用Chubby做爲協同服務，HBASE利用Zookeeper做爲協同服務.

一、傳統數據庫遇到的問題：

1）數據量很大的時候沒法存儲；
2）沒有很好的備份機制；
3）數據達到必定數量開始緩慢，很大的話基本沒法支撐；

二、HBASE優點：

1）線性擴展，隨着數據量增多能夠經過節點擴展進行支撐；
2）數據存儲在hdfs上，備份機制健全；
3）經過zookeeper協調查找數據，訪問速度快。

HBase集羣中的角色:

一、一個或者多個主節點，Hmaster；

二、多個從節點，HregionServer；

三、HBase依賴項，zookeeper；

(2) 安裝

下載Hbase, 咱們進行僞分佈式安裝:

cd /app/hadoop
wget http://mirror.bit.edu.cn/apache/hbase/2.1.2/hbase-2.1.2-bin.tar.gz
tar xvf hbase-2.1.2-bin.tar.gz

編輯配置hbase-env.sh:

cd /app/hadoop/hbase-2.1.2
vim conf/hbase-env.sh

# 增長
export JAVA_HOME=/app/hadoop/jdk1.8.0_191

重點配置:

mkdir /app/hadoop/hbase-2.1.2/data
cd /app/hadoop/hbase-2.1.2
vim conf/hbase-site.xml


<configuration>
  <property>
    <name>hbase.rootdir</name>
    <value>hdfs://localhost:9000/hbase</value>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/app/hadoop/hbase-2.1.2/data/zookeeper</value>
  </property>
  <property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
  </property>
<property>
<name>hbase.unsafe.stream.capability.enforce</name>
<value>false</value>
</property>
    <property> 
      <name> 
        hbase.wal.provider 
      </name> 
      <value>filesystem</value> 
  </property> 
    <property> 
      <name> 
        hbase.wal.meta_provider 
      </name> 
      <value>filesystem</value> 
  </property> 
</configuration>

請先:

cd /app/hadoop/hbase-2.1.2
cp lib/client-facing-thirdparty/htrace-core-3.1.0-incubating.jar lib/

啓動Hbase:

./bin/start-hbase.sh

查看:

jps

31281 NameNode
79520 HQuorumPeer
31426 DataNode
79830 HRegionServer
31959 ResourceManager
55351 Worker
42616 RunJar
31609 SecondaryNameNode
55129 Master
79672 HMaster
32095 NodeManager

H開頭的就是HBASE的進程.

打開http://localhost:16010查看控制檯UI

HBase是一個面向列的數據庫，在表中它由行排序。表模式定義只能列族，也就是鍵值對。一個表有多個列族以及每個列族能夠有任意數量的列。後續列的值連續存儲在磁盤上。表中的每一個單元格值都具備時間戳。總之，在一個HBase：

表是行的集合。
行是列族的集合。
列族是列的集合。
列是鍵值對的集合。

這裏的列式存儲或者說面向列，其實說的是列族存儲，HBase是根據列族來存儲數據的。列族下面能夠有很是多的列，列族在建立表的時候就必須指定。

使用:

./bin/hbase shell

# 查看hbase狀態
status

# create '表名','列族名1','列族名2','列族名N'
create 't1','f1';

# 使用list命令查看已建立的表
list "t1"

# 插入數據
put 't1', 'row1', 'f1:a', 'value1'
put 't1', 'row2', 'f1:b', 'value2'
put 't1', 'row3', 'f1:c', 'value3'

# 瀏覽表中數據
scan 't1'

# 使用get命令得到一行數據。
get 't1', 'row1'

能夠參考: https://blog.csdn.net/nosqlnotes/article/details/79647096

六. Spark實驗

(1) 前言

Spark是基於內存計算的大數據分佈式計算框架。Spark基於內存計算，提升了在大數據環境下數據處理的實時性，同時保證了高容錯性和高可伸縮性，容許用戶將Spark部署在大量廉價硬件之上，造成集羣。

提供分佈式計算功能，將分佈式存儲的數據讀入，同時將任務分發到各個節點進行計算；
基於內存計算，將磁盤數據讀入內存，將計算的中間結果保存在內存，這樣能夠很好的進行迭代運算；
支持高容錯；
提供多計算範式；

Spark與Hadoop關係:

Spark是一個計算框架。
Hadoop是包含計算框架MapReducehe分佈式文件系統HDFS。
Spark是MapReduce的替代方案，並且兼容HDFS、Hive等分佈式存儲系統，可融入Hadoop生態。

Spark與Scala關係:

Spark是用Scala開發的，由於計算數據，Scala它是函數式編程，它實現算法很是簡潔優雅。
Scala即有面向對象組織項目工程的能力，又有計算數據的功能。

Scala與Java的關係：

它們都是基於JVM的，但Scala能夠調用Java的任何功能，好比Spark運行在Hadoop上，它能夠調用Hadoop上的一切功能。
你能夠認爲Scala它是一個升級版的Java，由於Scala它自己是一門支持面向對象的語言，在Scala中，一切皆對象，它是一門純面向對象的語言，同時Scala也是面向對象以及函數式結合的語言。

數據的開發語言是Scala，緣由以下：

大數據的自己是計算數據，而Scala即有面向對象組織項目工程的能力，又有計算數據的功能。
如今大數據事實上的計算標準框架Spark，它是用Scala開發的，由於計算數據，Scala它是函數式編程，它實現算法很是簡潔優雅。
例：kafka，它是一個消息中間件，若是外部數據要流進大數據中心，咱們通常都要用kafka做適配器，那若是大數據中心的數據流到外部，也是用kafka（如Spark計算的數據要交給HBASE或MySql,期間咱們都會用kafka），不少的大數據組件都是用的Scala編寫的，SO，若是你想成爲一個頂級的大數據開發高手，你必定要掌握Scala。
--------------------- 
做者：sage_wang 
來源：CSDN 
原文：https://blog.csdn.net/sage_wang/article/details/79236051 
版權聲明：本文爲博主原創文章，轉載請附上博文連接！

(2) 安裝Spark

下載spark-2.4.0-bin-hadoop2.7

cd /app/hadoop
wget http://mirrors.hust.edu.cn/apache/spark/spark-2.4.0/
tar zxvf spark-2.4.0-bin-hadoop2.7.tgz

編輯:

cd /app/hadoop/spark-2.4.0-bin-hadoop2.7
cp ./conf/spark-env.sh.template ./conf/spark-env.sh

vim ./conf/spark-env.sh
# 末尾添加
export SPARK_DIST_CLASSPATH=$(/app/hadoop/hadoop-3.1.1/bin/hadoop classpath)

添加環境變量:

sudo vim /etc/profile.d/hadoop.sh 

# Spark 
export SPARK_HOME=/app/hadoop/spark-2.4.0-bin-hadoop2.7
export PATH=$PATH:$SPARK_HOME/bin

使生效並啓動spark:

/etc/profile.d/hadoop.sh

/app/hadoop/spark-2.4.0-bin-hadoop2.7
/sbin/start-all.sh

打開http://127.0.0.1:8080看看.

試試/app/hadoop/spark-2.4.0-bin-hadoop2.7/examples/src/main例子:

/app/hadoop/spark-2.4.0-bin-hadoop2.7/bin/run-example  SparkPi 2>&1 | grep "Pi is roughly"

/app/hadoop/spark-2.4.0-bin-hadoop2.7/bin/spark-submit /app/hadoop/spark-2.4.0-bin-hadoop2.7/examples/src/main/python/pi.py | grep "Pi is roughly"

Scala 是 Spark 的主要編程語言，若是僅僅是寫 Spark 應用，並不是必定要用 Scala，用 Java、Python 都是能夠的。使用 Scala 的優點是開發效率更高，代碼更精簡，而且能夠經過 Spark Shell 進行交互式實時查詢，方便排查問題。

新建兩個py:

# Python program: test.py
vim /app/hadoop/test.py

#!/usr/bin/python

import sys

for line in sys.stdin:
    print "hello " + line


# Python program: test2.py
vim /app/hadoop/test2.py

#!/usr/bin/python

def fun2(str):
    str2 = str + " zaza"
    return str2

啓動pyspark終端:

cd /app/hadoop
chmod 777 *.py
pyspark

>>> data = ["john","paul","george","ringo"]
>>> data
['john', 'paul', 'george', 'ringo']
>>> rdd = sc.parallelize(data)
>>> rdd.collect()
['john', 'paul', 'george', 'ringo']
>>> test = "/app/hadoop/test.py"
>>> test2 = "/app/hadoop/test2.py"
>>> import test
>>> import test2


>>> pipeRDD =  rdd.pipe(test)
>>> pipeRDD.collect()
[u'hello john', u'', u'hello paul', u'', u'hello george', u'', u'hello ringo', u'']


>>> rdd.collect()
['john', 'paul', 'george', 'ringo']


>>> rdd2 = rdd.map(lambda x : test2.fun2(x))
>>> rdd2.collect()
['john zaza', 'paul zaza', 'george zaza', 'ringo zaza']
>>>