Spark 教程（一）—— 基礎解析（超詳細）

1. Spark 概述

1.1 Spark 介紹

1.1.1 Spark 是什麼

  Spark 是一種基於內存的快速、通用、可擴展的大數據分析引擎。

1.1.2 Spark 的由來

1. Hadoop 的歷史

   2003,2004 Google 2 篇論文

   （1）2011 年發佈 1.0 版本
   （2）2012 年發佈穩定版
   
   ·MR 的缺點：

     mr 基於數據集的計算，所以面向數據。

    ① 基本運算規則：從存儲介質中獲取（採集）數據，然後進行計算，最後將結果存儲到介質中，所以主要應用於一次性計算，不適合數據挖掘和機器學習這樣迭代計算和圖形挖掘計算。
    ② MR 基於文件存儲介質的操作，所以性能非常的慢。
    ③ MR 和 hadoop 緊密耦合一起，無法動態替換。

   （3）2013 年 10月發佈 2.X 版本（Yarn）

2. Spark 歷史

   2009 年誕生於加州大學伯克利分校 AMPLab，項目採用 Scala 編寫。
   2010 年開源;
   2013 年 6 月成爲 Apache 孵化項目
   2014 年 2 月成爲 Apache 頂級項目。

   Spark 基於 hadoop1.X 架構思想，採用自己的方式改善 Hadoop1.X 中的問題。
   Spark 計算基於內存（多任務） ，並且基於 Scala 語言開發，所以天生適合迭代計算。
   

1.2 Spark 內置模塊

1. Spark Core

   實現了 Spark 的基本功能，包括任務調度、內存管理、錯誤恢復、與存儲系統交互等模塊。Spark Core 中還包括對彈性分佈數據集（Resilent Distributed DataSet，簡稱 RDD）的 API 定義。

2. Spark SQL

   是 Spark 用來操作結構化數據的程序包。通過 Spark SQL，我們可以使用 SQL 或者 Apache Hive 版本的 SQL 方言（HQL）來查詢數據。Spark SQL 支持多種數據源，比如 Hive 表、Parquet 以及 JSON 等。

3. Spark Streaming

   是 Spark 提供的對實時數據進行流式計算的組件。提供了用來操作數據流的 API，並且與 Spark Core 中的 RDD API 高度對應。

4. Spark Mlib

   提供常見的機器學習（ML）功能的程序庫。包括分類、迴歸、聚類、協同過濾等，還提供了模型評估、數據導入等額外支持功能。

5. 集羣管理器

   Spark 設計可以高效地在一個計算節點到數千個計算節點之間伸縮計算。爲了實現這樣的要求，同時獲得最大靈活性，Spark 支持在各種集羣管理器（Cluster Manager）上運行，包括 Hadoop YARN、Apache Mesos，以及 Spark 自帶的一個簡易調度器，叫作獨立調度器。

1.3 Spark 特點

1. 速度快

   與 Hadoop 的 MapReduce 相比，Spark 基於內存的運算要快 100 倍以上，基於硬盤的運算也要快 10 倍以上。Spark 實現了高效的 DAG 執行引擎，可以通過基於內存來高效處理數據流。計算的中間結果是存在於內存中的。

2. 易用

   Spark 支持 Java、Python 和 Scala 的 API，還支持超過 80 種高級算法，使用戶可以快速構建不同的應用。而且 Spark 支持交互式的 Python 和 Scala 的 Shell，可以方便地在這些 Shell 中使用 Spark 集羣來驗證解決問題的方法。

3. 通用

   Spark 提供了統一的解決方案。Spark 可以用於批處理、交互式查詢（Spark SQL）、實時流處理（Spark Streaming）、機器學習（Spark Mlib）和圖計算（GraphX）。這些不同類型的處理都可以在同一應用中無縫使用。減少了開發和維護的人力成本和部署平臺的物力成本。

4. 兼容性

   Spark 可以非常方便地與其他的開源產品進行融合。比如，Spark 可以使用 Hadoop YARN 和 Apache Mesos 作爲它的資源管理和調度器，並且可以處理所有 Hadoop 支持的數據，包括 HDFS、HBase 等。這對於已經部署 Hadoop 集羣的用戶特別重要，因爲不需要做任何數據遷移就可以使用 Spark 的強大處理能力。

1.4 Spark 的重要角色

1.4.1 Driver（驅動器）

   Spark 的驅動器是執行開發程序中 main 方法的進程。它負責開發人員編寫的用來創建 SparkContent、創建 RDD，以及進行 RDD 的轉化操作和行動操作代碼的執行。當啓動 Spark shell 的時候，系統後臺自啓動了一個 Spark 驅動程序，就是在 Spark shell 中預加載了一個叫作 sc 的 SparkContent 對象。如果驅動器程序終止，那麼 Spark 應用也結束了。

Driver 主要負責：

1. 把用戶程序轉爲作業（JOB）。
2. 跟蹤 Executor 的運行狀況。
3. 爲執行器節點調度任務。
4. UI 展示應用運行狀態。

1.4.2 Executor（執行器）

   Spark Executor 是一個工作進程，負責在 Spark 作業中運行任務，任務之間相互獨立。Spark 應用啓動時，Executor 節點被同時啓動，並且始終伴隨着整個 Spark 應用的生命週期而存在。如果有 Executor 節點發生了故障或崩潰，Spark 應用也可以繼續進行，因爲會將出錯節點上的任務調度到其他 Executor 節點上繼續運行。

Executor 主要負責：

1. 負責運行組成 Spark 應用的任務，並將結果返回個驅動器進程。
2. 通過自身的塊管理器（Block Manager）爲用戶程序中要求緩存的 RDD 提供內存式存儲。RDD 是直接緩存在 Executor 進程內的，因此任務可以在運行時充分利用緩存數據加速運算。

1.5 Spark 官網

  官網地址

2. Spark 運行模式

2.1 Local 模式

2.1.1 概述

  Local 模式就是運行在一臺計算機上的模式，通常就是用於在本機上練手和測試。

  它可以通過以下幾種方式設置 Master。

1. local

   所有計算都運行在一個線程當中，沒有任何並行計算，通常我們在本機執行一些測試代碼，或者練手，就用這種模式;

2. local[K]

   指定使用幾個線程來運行計算，比如 local[4 ]就是運行 4 個Worker線程。通常我們的 Cpu 有幾個 Core，就指定幾個線程，最大化利用 Cpu 的計算能力;

3. local[*]

   這種模式直接幫你按照 Cpu 最多 Cores 來設置線程數了。

2.1.2 安裝使用

1. 把 spark 的安裝包上傳到服務器上（spark-2.3.1-bin-hadoop2.7.tgz）
2. 解壓 spark 安裝包到指定目錄

tar -zxvf spark-2.3.1-bin-hadoop2.7.tgz -C /hadoop/

3. 重命名解壓後的目錄

mv spark-2.3.1-bin-hadoop2.7/ spark-2.3.1

4. 配置環境變量

vim /etc/profile

    在文件中添加以下內容：

#SPARK
export SPARK_HOME=/hadoop/spark-2.3.1
export PATH=$PATH:$SPARK_HOME/bin

    使配置文件生效：

source /etc/profile

2.1.3 官方求 PI 案例

1. 輸入命令

spark-submit \
--class org.apache.spark.examples.SparkPi \
--executor-memory 1G \
--total-executor-cores 2 \
/hadoop/spark-2.3.1/examples/jars/spark-examples_2.11-2.3.1.jar \
100

    ① 基本語法

spark-submit \
--class <main-class>
--master <master-url> \
--deploy-mode <deploy-mode> \
--conf <key>=<value> \
... # other options
<application-jar> \
[application-arguments]

    ② 參數說明：

參數	說明
class	你的應用的啓動類 (如 org.apache.spark.examples.SparkPi)
master	指定 Master 的地址，默認爲 Local
deploy-mode	是否發佈你的驅動到 worker 節點（cluster）或者作爲一個本地客戶端 (client) (default: client)*
conf	任意的 Spark 配置屬性， 格式 key=value. 如果值包含空格，可以加引號 “key=value”
application-jar	打包好的應用 jar，包含依賴，這個 URL 在集羣中全局可見。 比如 hdfs:// 共享存儲系統， 如果是 file:// path， 那麼所有的節點的 path 都包含同樣的 jar
application-arguments	傳給 main() 方法的參數
executor-memory 1G	指定每個 executor 可用內存爲 1 G
total-executor-cores 2	指定每個 executor 使用的 cup 核數爲 2 個

2. 結果展示
   

2.1.4 WordCount 案例

1. 在 spark 目錄下創建 input 目錄

mkdir input

2. 在 input 目錄下創建 2 個文件 1.txt 和 2.txt，並分別輸入以下內容

hello Word
hello Scala

Hello Spark

3. 啓動 spark-shell

spark-shell

4. 查看 spark 狀態

   ① 開啓另一個窗口

jps

    ② 瀏覽器輸入 master:4040 查看程序運行

5. 運行 WordCount 程序

sc.textFile("/hadoop/spark-2.3.1/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

6. 查看結果

   ① 控制檯
   
   ② web 頁面
   

7. WordCount 案例分析

   ① 提交任務分析：
   
   ② 數據流分析：

   sc.textFile("/hadoop/spark-2.3.1/input").flatMap(.split(" ")).map((,1)).reduceByKey(+).collect

   textFile("/hadoop/spark-2.3.1/input")：讀取本地 input 文件夾數據；
   flatMap(_.split(" "))：壓平操作，按照空格分割符將一行數據映射成一個個單詞；
   map((_,1))：對每一個元素操作，將單詞映射爲元組；
   reduceByKey(+)：按照key將值進行聚合，相加；
   collect：將數據收集到Driver端展示。
   

2.2 Standalone 模式

2.2.1 概述

  構建一個由 Master+Slave 構成的 Spark 集羣，Spark 運行在集羣中。

2.2.2 安裝使用

1. 修改 spark 的配置文件（/hadoop/spark-2.3.1/conf 目錄下）

   ① 修改配置文件名稱

mv slaves.template slaves

mv spark-env.sh.template spark-env.sh

    ② 配置 slave 文件，添加 work 節點

master
slave1
slave2

    ③ 修改 spark-env.sh 文件

SPARK_MASTER_HOST=master
SPARK_MASTER_PORT=7077

2. 修改 sbin 目錄下的 spark-config.sh

export JAVA_HOME=/usr/local/java/jdk1.8.0_151

3. 同步 spark 目錄給其他機器

xsync spark-2.3.1/

4. 同步配置文件，並分別使配置文件生效

xsync /etc/profile

source /etc/profile

5. 啓動 spark 集羣

sbin/start-all.sh

6. 查看

   ① 查看 jps
   
   ② 網頁查看：master:8080
   

2.2.3 官方求 PI 案例

1. 啓動 spark 集羣

sbin/start-all.sh

2. 輸入命令

spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://master:7077 \
--executor-memory 1G \
--total-executor-cores 2 \
/hadoop/spark-2.3.1/examples/jars/spark-examples_2.11-2.3.1.jar \
100

2.2.4 WordCount 案例

1. 啓動 spark shell

spark-shell \
--master spark://master:7077 \
--executor-memory 1g \
--total-executor-cores 2

  參數：–master spark://master:7077指定要連接的集羣的 master

2. 執行 WordCount 程序

sc.textFile("/hadoop/spark-2.3.1/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

3. 查看運行結果
   

2.2.5 配置歷史服務器

1. 修改 spark-default.conf.template 名稱

mv spark-defaults.conf.template spark-defaults.conf

2. 修改 spark-default.conf 文件，開啓 Log：

spark.eventLog.enabled           true
spark.eventLog.dir               hdfs://hadoop102:9000/directory

3. 在 HDFS 上創建 /directory 目錄

hadoop fs -mkdir /directory

4. 修改 spark-env.sh 文件，添加如下配置：

# - SPARK_HISTORY_OPTS, to set config properties only for the history server (e.g. "-Dx=y")
SPARK_HISTORY_OPTS="-Dspark.history.ui.port=18080 
-Dspark.history.retainedApplications=30 
-Dspark.history.fs.logDirectory=hdfs://master:9000/directory"

5. 同步配置文件

xsync spark-defaults.conf

xsync spark-env.sh

6. 啓動歷史服務

sbin/start-history-server.sh

7. 再次執行任務

spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://master:7077 \
--executor-memory 1G \
--total-executor-cores 2 \
/hadoop/spark-2.3.1/examples/jars/spark-examples_2.11-2.3.1.jar \
100

8. 查看歷史服務

   master：18080
   

2.2.6 HA 配置

1. 啓動 Zookeeper
2. 修改 spark-env.sh 文件添加如下配置：

#SPARK_MASTER_HOST=hadoop102
#SPARK_MASTER_PORT=7077

SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER 
-Dspark.deploy.zookeeper.url=master,slave1,slave2
-Dspark.deploy.zookeeper.dir=/spark"

3. 同步配置文件

xsync spark-env.sh

4. 在 master上啓動全部節點

sbin/start-all.sh

5. 在 slave1 單獨啓動 master 節點

sbin/start-master.sh

6. spark HA 集羣訪問

spark-shell \
--master spark://master:7077,slave1:7077 \
--executor-memory 2g \
--total-executor-cores 2

2.3 Yarn 模式

2.3.1 概述

1. Spark 客戶端直接連接 Yarn，不需要額外構建 Spark 集羣。有 yarn-client 和 yarn-cluster 兩種模式，主要區別在於：Driver 程序的運行節點。

   ① yarn-client

     Driver 程序運行在客戶端，適用於交互、調試，希望立即看到 app 的輸出。

   ② yarn-cluster

     Driver 程序運行在由 RM（ResourceManager）啓動的 AP（APPMaster）適用於生產環境。
   
   

2. YARN 運行模式介紹：

2.3.2 安裝使用

1. 修改 hadoop 配置文件 yarn-site.xml（/hadoop/hadoop-2.7.7/etc/hadoop/），添加如下內容：

<!--是否啓動一個線程檢查每個任務正使用的物理內存量，如果任務超出分配值，則直接將其殺掉，默認是true -->
<property>
   <name>yarn.nodemanager.pmem-check-enabled</name>
   <value>false</value>
</property>

<!--是否啓動一個線程檢查每個任務正使用的虛擬內存量，如果任務超出分配值，則直接將其殺掉，默認是true -->
<property>
  <name>yarn.nodemanager.vmem-check-enabled</name>
  <value>false</value>
</property>

2. 同步配置

xsync yarn-site.xml

3. 修改 spark-env.sh（/hadoop/hadoop-2.7.7/spark-2.3.1/conf/），添加如下配置：

# - YARN_CONF_DIR, to point Spark towards YARN configuration files when you use YARN
YARN_CONF_DIR=/hadoop/hadoop-2.7.7/etc/hadoop

4. 同步配置

xsync spark-env.sh 

2.3.3 官方求 PI 案例

1. 啓動 Hadoop 集羣（HDFS、YARN）
2. 輸入命令

spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
/hadoop/spark-2.3.1/examples/jars/spark-examples_2.11-2.3.1.jar \
100

2.3.4 WordCount 案例

1. 啓動 spark shell

spark-shell --master yarn

  參數：–master spark://master:7077指定要連接的集羣的 master

2. 執行 WordCount 程序

sc.textFile("/hadoop/spark-2.3.1/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

3. 查看運行結果
   

2.3.5 配置歷史服務器

1. 修改配置文件 spark-defaults.conf

   添加如下內容：

spark.yarn.historyServer.address=master:18080
spark.history.ui.port=18080

2. 重啓 spark 歷史服務

sbin/stop-history-server.sh 

sbin/start-history-server.sh 

3 提交任務到 Yarn 執行

spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
/hadoop/spark-2.3.1/examples/jars/spark-examples_2.11-2.3.1.jar \
100

6. Web 頁面查看日誌
   
   

2.4 三種模式比較

模式	Spark安裝機器數	需啓動的進程	所屬者
Local	1	無	Spark
Standalone	3	Master 及 Worker	Spark
Yarn	1	Yarn 及 HDFS	Hadoop

3. 案例實操

3.1 IDEA 編寫 WordCount 程序

1. 創建一個 Maven 項目，並導入以下依賴

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.11</artifactId>
        <version>2.3.1</version>
    </dependency>
</dependencies>

<build>
    <finalName>WordCount</finalName>
    <plugins>
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <version>3.2.2</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

2. 創建 scala 源碼目錄
   

3. 創建 input 文件夾，並創建 word.txt

hello Scala
hello Spark
hello World
hello Hadoop
hello Scala

4. 編寫代碼

package spark

import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
  def main(args: Array[String]): Unit = {

    //1.創建SparkConf
    val conf = new SparkConf().setMaster("local[*]").setAppName("WordCount")

    //2.創建SparkContext
    val sc = new SparkContext(conf)

    //3.使用sc創建RDD並執行相應的transformation和action
//    sc.textFile("input").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_).collect()

    // 讀取文件，將文件的內容一行一行的讀出來
    val lines = sc.textFile("spark/input")
    // 將一行一行的數據分解一個一個的單詞
    val words = lines.flatMap(_.split(" "))
    // 將單詞的數據進行結構的轉換
    val wordToOne = words.map((_, 1))
    // 對轉換結構後的數據進行分組聚合
    val wordToSum = wordToOne.reduceByKey(_ + _)
    // 將統計結果採集後打印到控制檯
    val result = wordToSum.collect()
    result.foreach(println)

    //4.關閉連接
    sc.stop()
  }
}

5. 運行結果
   
6. 在 pom.xml 中添加打包插件，將程序打包

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>3.0.0</version>
  <configuration>
      <archive>
          <manifest>
              <mainClass>WordCount</mainClass>
          </manifest>
      </archive>
      <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
  </configuration>
  <executions>
      <execution>
          <id>make-assembly</id>
          <phase>package</phase>
          <goals>
              <goal>single</goal>
          </goals>
      </execution>
  </executions>
</plugin>