Spark是什么

a)?是一種通用的大數據計算框架

b)?Spark Core?離線計算

Spark SQL?交互式查詢

Spark Streaming?實時流式計算

Spark MLlib?機器學習

Spark GraphX?圖計算

c)?特點：

i.?一站式：一個技術堆棧解決大數據領域的計算問題

ii.?基于內存

d)?Spark2009年誕生于伯克利大學的AMPLab實驗室

2010年正式開源了Spark項目

2013年Spark成為Apache下的項目

2014年飛速發展，成為Apache的頂級項目

2015年在國內興起，代替mr,hive,storm等

作者：辛湜(shi)

e)?Spark和Hive：

Spark優點：

i.?速度快

ii.?Spark SQL支持大量不同的數據源

f)?Spark?和Storm

i.?計算模型不一樣

ii.?Spark吞吐量大

g)?特點：快，易用，通用，兼容性

h)?spark運行模式

i.?local(本地)

ii.?standalone(集群)

iii.?on yarn(由?yarn作為資源調度Spark負責任務調度和計算)

iv.?on mesos(由mesos作為資源調度S)

v.?on cloud()

i)?配置步驟

=======================on yarn====================

【說明】

1.?spark任務運行在yarn上，由yarn來進行資源調度和管理，spark只負責任務的調度?和計算

2.不需要配置和啟動spark集群

3.只需要在提交任務的節點上安裝并配置spark on yarn?模式

4.必須找一臺節點安裝spark

5.?步驟：

i.安裝配置JDK

ii.?vi spark-env.sh

1.?export ?JAVA_HOME=/opt/modules/jdk1.7_6.0

2.?export ?HADOOP_CONF_DIR = /opt/modules/hadoop/etc/hadoop

iii.測試spark on yarn?模式是否安裝成功

iv.網絡測試：http://hadoop-yarn1.beicai.com:8088

=====================sdandalone模式==============

【說明】

1.??spark運行在spark?集群上，由spark進行資源調度管理，同時還負責任務的調度和?計算

2.需要配置和啟動spark集群

3.?步驟：

i.安裝配置JDK

ii.上傳并解壓Spark

iii.建立軟連接?ln -s spark spark?或者修改名稱

iv.?配置環境變量

v.安裝配置Spark,修改spark配置文件(spark-env.sh, slaves)

1.?vi spark-env.sh

a)?export ?JAVA_HOME=/opt/modules/jdk(jdk位置)

b)?export SPARK_MASTER_IP=hadoop-yarn1.beicai.com

c)?export SPARK_MASTER_PORT=7077

2.??vi slaves(用于指定在哪些節點上啟動worker)

a)?hadoop-yarn2.beicai.com

hadoop-yarn3.beicai.com

vi.將spark發送給其他主機

vii.?啟動

/opt/modules/spark/bin/start-all.sh

vii.?查看SparkUI界面：http://hadoop-yarn1.beicai.com:8080

4.?

j)?

一、Spark原理

1、Spark的運行原理

i、分布式

Ii、主要基于內存（少數情況基于磁盤）

Iii、迭代式計算

2、Spark?計算模式?VS ?MapReduce ?計算模式對比

Mr這種計算模型比較固定，只有兩種階段，map階段和reduce階段，兩個階段結束?后，任務就結束了，這意味著我們的操作很有限，只能在map階段和reduce階段，?也同時意味著可能需要多個mr任務才能處理完這個job

Spark?是迭代式計算，一個階段結束后，后面可以有多個階段，直至任務計算完?成，也就意味著我們可以做很多的操作，這就是Spark計算模型比mr?強大的地方

三、什么是Spark RDD？

1、什么是RDD？

彈性的，分布式的，數據集

（RDD在邏輯上可以看出來是代表一個HDFS上的文件，他分為多個分區，散落?在Spark的多個節點上）

3、RDD----彈性

當RDD的某個分區的數據保存到某個節點上，當這個節點的內存有限，保存不了這個?分區的全部數據時，Spark就會有選擇性的將部分數據保存到硬盤上，例如：當worker?的內存只能保存20w條數據時，但是RDD的這個分區有30w條數據，這時候Spark就?會將多余的10w條數據，保存到硬盤上去。Spark的這種有選擇性的在內存和硬盤之間的權衡機制就是RDD的彈性特點所在

4、Spark的容錯性

RDD最重要的特性就是，提供了容錯性，可以自動的從失敗的節點上恢復過來，即如?果某個節點上的RDD partition（數據），因為節點的故障丟了，那么RDD會自動的通過?自己的數據來源重新計算該partition，這一切對使用者來說是透明的

2、Spark的開發類型

（1）、核心開發：離線批處理?/?演示性的交互式數據處理

（2）、SQL查詢：底層都是RDD和計算操作

（3）、底層都是RDD和計算操作

（4）、機器學習

（5）、圖計算

3、Spark?核心開發（Spark-core == Spark-RDD）步驟

（1）、創建初始的RDD

（2）、對初始的RDD進行轉換操作形成新的RDD，然后對新的RDD再進行操作，直?至操作計算完成

（3）、將最后的RDD的數據保存到某種介質中（hive、hdfs，MySQL、hbase...）

五、Spark原理

Driver，Master，Worker，Executor，Task各個節點之間的聯系

Spark中的各節點的作用：

1、driver的作用：

（1）、 向master進行任務的注冊

（2）、構建運行任務的基本環境

（3）、接受該任務的executor的反向注冊

（4）、向屬于該任務的executor分配任務

2、什么是driver？

我們編寫的程序打成jar包后，然后找一臺能夠連接spark集群的節點做任務的driver，具體的表現為SparkSubmit

3、Master的作用：

（1）、監控集群；

（2）、動態感知worker的上下線；

（3）、接受driver端注冊請求；

（4）、任務資源的調度

4、Worker的作用：

（1）、定時向master匯報狀態；

（2）、接受master資源調度命令，進行資源的調度

（3）、啟動任務的容器Executor

5、Executor的作用：

（1）、保存計算的RDD分區數據；

（2）、向Driver反向注冊；

（3）、接受Driver端發送來的任務Task，作用在RDD上進行執行

Spark　編程的流程：

１、我們編寫的程序打包成jar包，然后調用Spark-Submit?腳本做任務的提交

２、啟動driver做任務的初始化

３、Driver會將任務極其參數（core，memory，driver相關的參數）進行封裝成ApplicationDescript通過taskSchedulerImpl?提交給Master

４、Master接受到driver端注冊任務請求時，會將請求參數進行解析，并封裝成APP，然后進行持久化，并且加入到其任務隊列中的waitingAPPs

５、當輪到咱們提交的任務運行時，master會調用schedule（）這個方法，做任務資源調度

６、Master將調度好的資源封裝成launchExecutor，發送給指定的worker

７、Worker接收到發送來的launchExecutor時，會將其解析并封裝成ExecutorRunner，然后調用start方法，啟動Executor

８、Executor啟動后，會向任務的Driver進行反向注冊

９、當屬于這個任務的所有executor啟動成功并反向注冊完之后，driver會結束SparkContext對象的初始化

１０、當sc?初始化成功后，意味著運行任務的基本環境已經準備好了，driver會繼續運行我們編寫好的代碼

１１、開始注冊初始的RDD，并且不斷的進行轉換操作，當觸發了一個action算子時，意味著觸發了一個job，此時driver就會將RDD之間的依賴關系劃分成一個一個的stage，并將stage封裝成taskset，然后將taskset中的每個task進行序列化，封裝成launchtask，發送給指定的executor執行

１２、Executor接受到driver發送過來的任務task，會對task進行反序列化，然后將對應的算子（flatmap，map，reduceByKey。。。。）作用在RDD分區上

六、RDD詳解

1、什么是RDD？

RDD（Resilient Disttibuted Dataset）叫做彈性的分布式的數據集，是spark中最基本的數據抽象，它代表一個不可變，可分區，里面的元素可并行計算的集合

2、RDD的特點：

自動容錯

位置感知性調度

伸縮性

3、RDD的屬性：

（1）、一組分片（partition），即數據集的基本組成單位。對于RDD來說，每個分片都會被一個計算任務處理，并決定并行計算的粒度，用戶可以在創建RDD時指定RDD的分片個數，如果沒有指定，那么就會采用默認值，默認值就是程序所分配到的CPU Core的數目

（2）、一個計算每個分區的函數。Spark中RDD的計算是以分片為單位的，每個RDD都會實現computer函數以達到這個目的。Computer函數會對迭代器進行復合，不需要保存每次計算的結果。

（3）、RDD之間的依賴關系。RDD的每次轉換都會生成一個新的RDD，所以RDD之間就會形成類似于流水一樣的前后依賴關系。在部分分區數據丟失時，Spark可以通過這個依賴關系重新計算丟失的分區數據，而不是對ＲＤＤ的所有分區進行重新計算。

（4）、一個partition，即RDD的分片函數。當前Spark中實現了兩種類型的分片函數，一個是基于hashPartitioner，另外一個是基于范圍的RangePartitioner。只有對于key-value的RDD，才會有Partitioner，非key-value的RDD的Partitioner的值是None。Partitioner函數不但決定了RDD本身的分片數量，也決定了partition RDD Shuffle輸出時的分片數量。

（5）、一個列表，存儲存取每個Partition的優先位置（preferred location）。對于一個HDFD文件來說。這個列表保存的就是每個Partition所在的快的位置。按照“移動數據不如移動計算”的理念。Spark在進行任務調度的時候，會盡可能的將計算任務分配到所要處理數據塊的存儲位置。

4、RDD的創建：

進行Spark核心編程時，首先要做的事就是創建一個初始的RDD。Spark Core提供了三種創建RDD的方式：

（1）、使用程序中的集合創建RDD?（調用parallelize()方法）

（2）、使用本地文件創建RDD（調用textFile()方法）

（3）、使用HDFD文件創建RDD ?（調用textFile()方法）

七、算子

1、什么是算子？

是RDD中定義的作用在每一個RDD分片上的函數，可以對ＲＤＤ中的數據進行轉換?和操作

2、RDD算子的分類

（1）、Transformation算子，這類算子變換不觸發提交作業（特點就是lazy特性）

返回的是一個RDD

（2）、Action算子，這類算子會觸發SparkContext提交作業（觸發一個spark job的運行，從而觸發這個action之前所有的transformation的執行）

返回的是一個spark對象

3、常用的Transformation算子

八、RDD分區排序

I、分區

兩種實現方式：coalesce和?repartition（底層調用coalesce）

coalesce(numPartitons,isShuffle)

第一個參數是重分區后的數量，第二個參數是是否進行shuffle

如果原來有N個分區，重分區后有M個分區

如果?M > N ,必須將第二參數設置為true（也就是進行shuffle）,等價于?repartition(numPartitons) ???如果是false將不起作用 ?

如果M < N

100-->10?重分區后的分區數比原來的小的多，那么久需要使用shuffle，也即是設置為true

100-->90?重分區后的分區數和原來的差不多的，那么就不需要使用shuffle，也就是設置為false

II、排序

sortBy(x => x)這個算子中帶有隱式轉換參數

x?能夠排序（比較大小），那么這個類就必須有比較大小的功能，也就是實現了compareTo?或者compare

實現二次排序有兩種方法：

1、繼承Comparable?接口 或者?Ordered

2、隱式轉換：可以定義隱式轉換函數（Ordered）或者隱式轉換值（Ordering）

九、自定義分區

自定義分區

要求：按照key將對應的value輸出到指定的分區中

解釋：自定義一個自定義分區類，繼承partitioner，實現他的兩個方法

1、numPartitions

2、getPartition

具體的功能根據項目的要求自定義實現，然后調用partitionBy方法，new出自定義的類，傳入參數即可

九、RDD持久化原理

1、持久化場景：對于一個rdd會被多次引用到，并且這個rdd計算過程復雜，計算時間特變耗時

2、如何進行持久化，調用rdd.persist方法或cache方法，cache方法底層就是調用persist方法

******************persist(StorageLevel.MEMORY_ONLY)*******************

如果對RDD做持久化，默認持久化級別是storageLevel.MEMORY_ONLY ,也就是持久化到內存中去，這種持久化級別是效率最快的，但是由于是純Java?對象，保存到內存中，那么內存可能保存的數量就會較少

***************persist(StorageLevel.MEMORY_ONLY_SER)****************

如果當我們集群資源有限時，那么我們可以采用MEMORY_ONLY_SER，也就是將Java對象進行序列化之后持久到內存中去，這種持久化的好處是能夠持久化更多的數據到內存中，但是由于在持久化時需要序列化，取出來之后又需要反序列化這一過程，這個過程會消耗CPU計算資源，性能相對于MEMORY_ONLY?這種持久化級別來說稍微弱點，但是還是比較高效的

3、如何選擇ＲＤＤ持久化策略？

Spark提供的多種持久化級別，主要是為了在CPU和內存消耗之間進行取舍，下面是一些通用的持久化級別的選擇建議：

1）、優先使用MEMORY_ONLY，如果可以緩存所有數據的話，那么就使用這種策略，因為純內存速度最快，而且沒有序列化，不需要消耗CPU進行反序列化操作

2）、如果MEMORY_ONLY策略，無法存儲所有數據的話，那么使用MEMORY_ONLY_SER，將數據進行序列化存儲，純內存操作還是非常快的，只是要消耗CPU進行反序列化

3）、如果需要進行快速的失敗恢復，那么就選擇帶后綴為_2的策略，進行數據的備份，這樣在失敗時，就不需要重新計算了

4、能不使用DISK相關的策略，就不要使用，有的時候，從磁盤讀取數據，還不如重新計算一次

十一、共享變量

1、共享變量分為兩種：廣播變量?和?累加器

廣播變量（broadcast）

2、日常所遇問題

因為每個task都需要拷貝這樣的一個副本到executor去執行，那么我們可以想象一下，如果有1000?個task在某個worker上執行，而這個副本有100M，那么意味著我們需要拷貝100G的數據都到某個worker上執行，這樣的話會大大消耗我們的網絡流量，同時會加大executor的內存消耗，從而增加了我們spark作業的運行時間，大大降低了spark作業的運行效率，增加了作業失敗的概率

3、如何解決以上問題，也就是說什么時候使用廣播變量?

當RDD引用到了一個外部變量并且這個外部變量數據量不小，同時這個RDD對應的task數量特別多，那么此時使用廣播共享變量再合適不過了

我們可以將這種大的外部變量做成廣播變量，外部變量做成廣播變量的時候，那么每個executor的內存中只會有一個外部變量，而這個副本針對所有的task都是共享的，這樣的話就減少了網絡流量消耗，降低了executor的內存消耗，提高了spark作業運行效率和縮短了運行時間，同時降低了作業失敗的概率

4、廣播變量的使用流程：

1）、某個executor的第一個task先執行，首先會從自己的blockManager中查找外部變量，如果沒有就從鄰居的executor的blockManager的內存中獲取這個外部變量，如果還是獲取不到，就從driver端獲取，拷貝這個外部變量到本地的executor的blockManager

2）、當這個executor的其他task執行時，就不需要從外面獲取這個外部變量的副本，直接從本地的blockManager中獲取即可

5、如何獲取廣播變量的值？

可以直接調用廣播變量的value()?這個方法即可

【注意】廣播變量是只讀的，不可寫

累加器（Accumulator）

Spark提供的Accumulator?，主要用于多個節點對一個變量進行共享性的操作，Accumulator只是提供了累加的功能。但是卻給我們提供了多個task對一個變量并行操作的功能，但是task只能對Accumulator進行累加操作

【注意】task只能對Accumulator進行類加操作，只有Driver程序可以讀取Accumulator的值

RDD分區和容錯機制講解

1、RDD?的Lineage血統

RDD只支持粗粒度轉換，即在大量記錄上執行的單個操作，將創建RDD的一系列Lineage（血統）記錄下來。以便恢復丟失的分區

2、RDD的依賴關系

RDD和它的父RDD的關系有兩種不同的類型：

1）、窄依賴（一對一，多對一）

形象的比喻：獨生子女

2）、寬依賴（多對多）

形象的比喻：超生

注釋：劃分stage的依據就是寬依賴，也就是RDD之間是否有shuffle，shuffle過程就是一個寬依賴過程，shuffle之前的tasks就屬于一個stage，shuffle之后的也屬于一個stage，shuffle之前和之后的操作都是窄依賴

【注意】shuffle過程分為：shuffle Write過程 和?shuffle read過程

4、DAG的生成（有向無環圖）和任務的劃分

DAG（Directed Acyclic Graph）叫做有向無環圖（有方向無循環的圖）

5、一個wordCount過程會產生多少個RDD？

至少會產生五個RDD，

第一個，從HDFS中加載后得到一個RDD（即使用sc.textFile()算子），即HadoopRDD

在sc.textFile()過程中還會產生一個RDD（調用map算子），產生一個MapPartitionRDD

第二個，使用flatMap算子，得到一個MapPartitionRDD

第三個，使用map算子，得到一個MapPartitionRDD

第四個，使用reduceByKey算子，也就是在經過了shuffle過程后又會得到一個shuffledRDD

第五個，使用saveAsTextFile算子，再產生一個MapPartitionRDD?

spark程序提交流程講解

Spark任務簡介：

Spark-submit--->SparkSubmit-->main-->submit-->doRunMain-->RunMain-->通過反射創建我們編寫的主類的實例對象，調用main方法-->開始執行我們編寫的代碼-->初始化SparkContext對象-->創建初始的RDD-->觸發action算子-->提交job-->worker執行任務-->任務結束

Spark任務詳解：

1）、將我們編寫的程序打成jar包

2）、調用spark-submit腳本提交任務到集群上運行

3）、運行sparkSubmit的main方法，在這個方法中通過反射的方式創建我們編寫的主類的實例對象，然后調用main方法，開始執行我們的代碼（注意，我們的spark程序中的driver就運行在sparkSubmit進程中）

4）、當代碼運行到創建SparkContext對象時，那就開始初始化SparkContext對象了

5）、在初始化SparkContext對象的時候，會創建兩個特別重要的對象，分別是：DAGScheduler

和TaskScheduler

【DAGScheduler的作用】將RDD的依賴切分成一個一個的stage，然后將stage作為taskSet提交給DriverActor

6）、在構建taskScheduler的同時，會創建兩個非常重要的對象，分別是DriverActor和ClientActor

【clientActor的作用】向master注冊用戶提交的任務

【DriverActor的作用】接受executor的反向注冊，將任務提交給executor

7）、當clientActor啟動后，會將用戶提交的任務和相關的參數封裝到ApplicationDescription對象中，然后提交給master進行任務的注冊

8）、當master接受到clientActor提交的任務請求時，會將請求參數進行解析，并封裝成Application，然后將其持久化，然后將其加入到任務隊列waitingApps中

9）、當輪到我們提交的任務運行時，就開始調用schedule()，進行任務資源的調度

10）、master將調度好的資源封裝到launchExecutor中發送給指定的worker

11）、worker接受到Maseter發送來的launchExecutor時，會將其解壓并封裝到ExecutorRunner中，然后調用這個對象的start(),?啟動Executor

12）、Executor啟動后會向DriverActor進行反向注冊

13）、driverActor會發送注冊成功的消息給Executor

14）、Executor接受到DriverActor注冊成功的消息后會創建一個線程池，用于執行DriverActor發送過來的task任務

15）、當屬于這個任務的所有的Executor啟動并反向注冊成功后，就意味著運行這個任務的環境已經準備好了，driver會結束SparkContext對象的初始化，也就意味著new SparkContext這句代碼運行完成

16）、當初始化sc成功后，driver端就會繼續運行我們編寫的代碼，然后開始創建初始的RDD，然后進行一系列轉換操作，當遇到一個action算子時，也就意味著觸發了一個job

17）、driver會將這個job提交給DAGScheduler

18）、DAGScheduler將接受到的job，從最后一個算子向前推導，將DAG依據寬依賴劃分成一個一個的stage，然后將stage封裝成taskSet，并將taskSet中的task提交給DriverActor

19）、DriverActor接受到DAGScheduler發送過來的task，會拿到一個序列化器，對task進行序列化，然后將序列化好的task封裝到launchTask中，然后將launchTask發送給指定的Executor

20）、Executor接受到了DriverActor發送過來的launchTask時，會拿到一個反序列化器，對launchTask進行反序列化，封裝到TaskRunner中，然后從Executor這個線程池中獲取一個線程，將反序列化好的任務中的算子作用在RDD對應的分區上

【注意】

Spark的任務分為為兩種：

a、shuffleMapTask：shuffle之前的任務

b、resultTask：shuffle之后的任務

Spark任務的本質：

將RDD的依賴關系切分成一個一個的stage，然后將stage作為TaskSet分批次的發送到Executor上執行

十三、Checkpoint

1、使用checkpoint的場景：

某個RDD會被多次引用，計算特別復雜，計算特別耗時

擔心中間某些關鍵的，在后面會反復幾次使用的RDD，可能會因為節點的故障，導致持久化數據的丟失

2、如何對RDD進行checkpoint？

1）、設置還原點目錄，設置checkpoint目錄

2）、調用RDD的checkpoint的方法對該RDD進行checkpoint

3、checkpoint的原理

1）、RDD調用了checkpoint方法之后，就接受RDDCheckpointData對象的管理

2）、RDDCheckpointData對象會負責將調用了checkpoint的RDD?的狀態設置為MarkedForCheckpoint

3）、當這個RDD所在的job運行結束后，會調用最后一個RDD的doCheckpoint，根據其血統向上查找，查找到被標注為MarkedForCheckpoint狀態的RDD，將其狀態改變為checkpointingInProgress

4）、啟動一個單獨的job，將血統中標記為checkpointingInProgress的RDD進行checkpoint，也就是將RDD的數據寫入到checkpoint的目錄中去

5）、當某個節點發生故障，導致包括持久化的數據全部丟失，此時會從還原點目錄還原RDD的每個分區的數據，這樣就不需要從頭開始計算一次

4、checkpoint需要注意的地方

因為RDD在做checkpoint的時候，會單獨啟動一個job對需要進行checkpoint的RDD進行重新計算，這樣就會增加spark作業運行時間，所以spark強烈建議在做checkpoint之前，應該對需要進行checkpoint的RDD進行持久化（即調用?.cache）

5、checkpoint?和持久化的區別

1）、是否改變血統：

持久化（.cache）：不會改變RDD的依賴關系，也就是不會改變其血統

Checkpoint：會改變RDD的血統，做了checkpoint的RDD會清除其所有的依賴關系，并將其父RDD強制設置為checkpointRDD，并且將RDD的狀態更改為checkpointed

2）、RDD的數據的可靠性：

持久化：只是將RDD的數據持久化到內存或磁盤中，但是如果節點發生故障，那么持久化的數據還是會丟失

Checkpoint：checkpoint的數據保存在第三方高可靠的分布式的文件系統中，機試節點發生故障，數據也不會丟失，所以checkpoint比持久化可靠性更高

6、后續

我們實現了checkpoint?之后，在某個task?又調用了該RDD的iterator()?方法時，就實現了高容錯機制，即使RDD的持久化數據丟失，或者壓根兒就沒有持久化，但是還是可以通過readCheckpointOrComputer()?方法，優先從父RDD-----checkpointRDD中讀取，HDFS（外部文件系統）的數據

第二部分?spark-sql

一、Spark-SQL前世今生

1、Spark SQL的特點

1）、支持多種數據源：Hive、RDD、Parquet、JSON、JDBC等。

2）、多種性能優化技術：in-memory columnar storage、byte-code generation、cost model動態評估等。

3）、組件擴展性：對于SQL的語法解析器、分析器以及優化器，用戶都可以自己重新開發，并且動態擴展

2、Spark SQL的性能優化技術簡介

1）、內存列存儲（in-memory columnar storage）

2）、字節碼生成技術（byte-code generation）

3）、Scala代碼編寫的優化

3、Spark SQL and DataFrame

Spark SQL是Spark中的一個模塊，主要用于進行結構化數據的處理。它提供的最核心的編程抽象，就是DataFrame。同時Spark SQL還可以作為分布式的SQL查詢引擎。Spark SQL最重要的功能之一，就是從Hive中查詢數據。

DataFrame，可以理解為是，以列的形式組織的，分布式的數據集合。它其實和關系型數據庫中的表非常類似，但是底層做了很多的優化。DataFrame可以通過很多來源進行構建，包括：結構化的數據文件，Hive中的表，外部的關系型數據庫，以及RDD。

二、Spark-sql的使用

1、RDD轉換為DataFrame（兩種）

1）、使用反射的方式來推斷包含了特定數據類型的RDD的元數據

2）、通過編程接口來創建DataFrame

2、UDF自定義函數和UDAF自定義聚合函數

UDF，其實更多的是針對單行輸入，返回一個輸出

UDAF，則可以針對多行輸入，進行聚合計算，返回一個輸出，功能更加強大

3、Spark-SQL工作原理

SqlParse ?--------->解析器

Analyser ?--------->分析器

Optimizer ?--------->優化器

SparkPlan ?--------->物理計劃

流程：

1）、自己編寫的SQL語句

大家要知道，只要在數據庫類型的技術里面，比如：最傳統的MySQL，Oracle等，包括現在大數據領域的數據倉庫，比如hive，他的基本的SQL執行的模型，都是類似的，首先都要生成一條SQL語句的執行計劃

2）、通過SqlParser（解析器）生成未解析的邏輯計劃（unresolved LogicalPlan）

3）、通過Analyzer（分析器）生成解析后的邏輯計劃（resolved LogicalPlan）

4）、通過Optimizer（優化器）生成優化后的邏輯計劃（optimized LogicalPlan）

實際上，比如傳統的Oracle等數據庫，通常都會生成多個執行計劃，然后呢，最后有一個優化器，針對多個計劃，選擇一個最好的計劃，而SparkSql這兒的優化指的是，比如說，剛生成的執行計劃中，有些地方的性能是顯而易見的，不太好，舉例說明：

比如說，我們有一個SQL語句，select name from (select ... from ...) where ..=..;

此時，在執行計劃解析出來的時候，其實就是按照他原封不動的樣子，來解析成可以執行的計劃，但是呢，Optimizer?在這里其實就會對執行計劃進行優化，比如說，發現where?條件，其實可以放在子查詢中，這樣，子查詢的數量大大變小，可以優化執行速度，此時，可能就會變成如下這樣：select name from (select name from ...where ..=..)

5）、通過SparkPlan，生成最后的物理計劃（PhysicalPlan）

到物理計劃這里，那么其實就是非常“接地氣”的計劃了。就是說，已經很明朗了，從那幾個文件讀取什么數據，從那幾個文件中讀取，如何進行關聯等等

6）、在executor中執行物理計劃

邏輯的執行計劃，更多的是偏向于邏輯，比如說吧，大致就是這種樣子的，

From table students=>filter ... => select name ...

這里基本上，邏輯計劃都是采用Tree?，樹形結構

7）、生成RDD

Select ?name ?from ?students =>?解析，從哪里去查詢，students表，在哪個文件里，從哪個文件中查詢哪些數據，比如說是name這個列，此外，復雜的SQL，還有，比如說查詢時，是否對表中的數據進行過濾和篩選，更不用說，復雜時，需要有多表的JOIN（咋傳統數據庫中，比如MySQL，執行計劃還涉及到如何掃描和利用索引）

4、spark-SQL性能優化

1）、設置shuffle過程的并行度：spark.sql.shuffle.partitions（SQLContext.setConf()）

2）、在hive數據倉庫建設過程中，合理設置數據類型，比如能設置為int的，就不要設置為bigInt，減少數據類型導致不必要的內存開銷

3）、編寫SQL時，盡量給出明確的列名，比如select name from students。不要寫select *?的方式。

4）、并行處理查詢結果：對于spark-SQL查詢的結果，如果數據量比較大，比如超過1000條，那么就不要一次性的collect（）到driver再處理，使用foreach（）算子，并行處理查詢結果

5）、緩存表：對于一條SQL語句可能對此使用到的表，可以對其進行緩存，使用?sqlContext.cacheTable(tableName)，或者DataFrame.cache()即可，spark-SQL會用內存列存儲的格式進行表的緩存，然后spark-sql就可以僅僅掃描需要使用的列，并且自動優化壓縮，來最小化內存使用和GC開銷，SQLContext.uncacheTable(tableName)可以將表從緩存中移除，用SQLContext。setConf（），設置spark.sql.inMemoryColumnarStorage.batchSize參數（默認10000），可以設置列存儲的單位

6）、廣播join表：spark.sql.autoBroadcastJoinThreshold，默認10485760 (10 MB)。在內存夠用的情況下，可以增加其大小，參數設置了一個表在join的時候，最大在多大以內，可以被廣播出去優化性能

5、Hive on Spark配置

1)、安轉配置好Hive和Spark

2）、Set hive.execution.engine=spark;

3）、set spark.master=spark://mini1:7077

第三部分spark-streaming

1, ?Dstream

?

Dstream是sparkStreaming的數據模型，本質就是一連串不間斷的RDD，但是它是一個時間段的RDD.這些時間段的RDD源源不斷的連接在一起。

這個時間可以自己設置，時間設置的越短，實時性越高，但是性能消耗也越大。

2, ?spark streaming從kafka獲取數據，有哪幾種方式？

?

有兩種方式：

1.通過receiver的方式，

2，通過direct的方式，dirrect的方式需要自己來管理偏移量。

?

3, ?sparkStreaming和storm的區別

sparkStreaming是spark里面的一個做流式準實時計算的組件，它使用的數據結構是Dstream，Dstream里面是一連串時間片的rdd。

相比于storm，sparkStreaming在實時性，保證數據不丟失方面都不占用優勢，spark streaming在spark支持者眼中的優勢是spark Streaming具有高吞吐性，最本質來說，sparkStreaming相比于storm的優勢是sparkStreaming可以和spark core，spark SQL無縫整合。

4.對于需要多次引用的，并且這個dstream計算時間特別耗時，數據特別重要，那么我們就需要對dstream進行checkpoint，（只有多次引用的，進行持久化就可以了），因為即使對這個dstream進行持久化，數據也可能會丟失，而checkpoint數據丟失的可能性小，但是這樣會影響spark-streaming的數據吞吐量，因為在做計算的同時，還需要將數據寫入到外部存儲系統中，會降低spark性能，影響吞吐量，非必要情況下不建議使用

5.如何對dstream做checkpoint

?

首先設置還原點目錄，其次調用dstream的checkpoint方法

【注意】：dstream的checkpoint的周期一定要是產生batch時間的整數倍，同時spark官方建議將checkpoint的時間設置為至少10秒。通常來說，將checkpoint間隔設置為窗口操作的滑動間隔的5-10倍

6.spark程序在啟動時，會去這個checkpointPath目錄下查看是否有保存的driver的元數據（1.dstream的操作轉換關系，2.未處理完的batch）信息，當spark-streaming程序在二次啟動后就會去checkpointPath目錄下還原這個程序，加載未處理的batch元數據信息在內存中恢復，繼續進行任務處理

7.為了保證spark-streaming程序7*24小時運行，那么我們程序應該具備高可靠性，怎樣具備高可靠性？

?

a.程序出現故障，driver死掉了，流式程序應該具備自動重啟的功能

b.沒有計算完成的rdd在程序異常停止后，下次啟動后還會將未處理的rdd進行處理

【注意】：要在spark_submit中，添加--deploy-mode參數，默認其值為client，即在提交應用的機器上啟動driver，但是要能夠自動重啟driver，就必須將其值設置為cluster；此外，需要添加--supervise參數，失敗后自動重啟

//spark_submit --executor-memory 1g --total-execute-cores 5 --deploy-model cluster --supervise

8.啟用預寫機制

a.預寫日志機制，簡寫為WAL，全稱為Write Ahead Log，從spark1.2版本開始，就引入了基于容錯的文件系統的WAL機制。如果啟用該機制，Receiver接收到的所有數據都會寫入配置的checkpoint目錄中的預寫日志。這中機制可以讓driver在恢復的時候，避免數據丟失，并且可以確保整個實時計算過程中零數據丟失

b.要配置該機制，首先調用StreamingContext的checkpoint()方法設置一個checkpoint目錄，然后需要將spark.streaming.receiver.writeAheadLog.enable參數設置為true

然而，這種極強的可靠性機制，會導致Receiver的吞吐量大幅度下降，因為單位時間內，有相當一部分時間需要將數據寫入預寫日志。如果又希望開啟預寫日志機制，確保數據零損失，又不希望影響系統的吞吐量，那么可以創建多個輸入DStream，啟動多個Receiver

此外，在啟用了預寫日志機制之后，推薦將復制持久化機制禁用掉，因為所有數據已經保存在容錯的文件系統中，不需要在用復制機制進行持久化，保存一份副本，只要將輸入的DStream的持久化機制設置一下即可，persist（StorageLevel.MEMORY_AND_DISK_SER）。

9.spark-Streaming checkpoint概述

每一個spark-streaming應用，正常來說，都是7*24小時運轉的，這就是實時計算程序的特點，因為要持續不斷的對數據進行計算，因此，對實時計算應用的要求，應該是必須要能夠對與應用程序邏輯無關的失敗，進行容錯

如果要實現這個目標，Spark Streaming程序就必須將足夠的信息checkpoint到容錯的存儲系統上，從而讓它能夠從失敗中進行恢復

有兩種數據需要被進行checkpoint

1.元數據checkpoint-將定義了流式計算邏輯的信息，保存到容錯的存儲系統上，比如HDFS，當運行spark Streaming應用程序的Driver進程所在的節點失敗時，該信息可以用于進行恢復，元數據信息包括：

a.配置信息---創建spark Streaming應用程序的配置信息，比如sparkConf中的信息

b.DStream的操作信息---定義了spark Stream應用程序的計算邏輯的DStream操作信息

c.未處理的batch信息---那些job正在排隊，還沒處理的batch信息

2.數據checkpoint---將實時計算過程中產生的RDD的數據保存到可靠的存儲系統中。對于一些將多個batch的數據進行聚合，有狀態的transformation操作，這是非常有用的，在這種transformation操作中，生成的RDD是依賴于之前batch的RDD的，這會導致隨著時間的推移，RDD的依賴鏈條變得越來越長，要避免由于依賴鏈條越來越長，導致的一起變得越來越長的失敗恢復時間，有狀態的transformation操作執行過程中中間產生的RDD,會定期被checkpoint到可靠的存儲系統上，比如HDFS，從而削減RDD的依賴鏈條進而縮短失敗恢復時，RDD的恢復時間。一句話概括，元數據checkpoint主要是為了從driver失敗中進行恢復；而RDD checkpoint主要是為了使用到有狀態的transformation操作時，能夠在其生產出的數據丟失時，進行快速的失敗恢復

10.何時啟用checkpoint機制？

a.使用了有狀態的transformation操作----比如updateStateByKey，或者reduceByKeyAndWindow操作被使用了，那么checkpoint目錄要求必須提供的，也就是必須開啟checkpoint機制，從而進行周期性的RDD checkpoint

b.要保證可以從Driver失敗中進行恢復-----元數據checkpoint需要啟用，來進行這種情況的恢復

【注意】并不是說，所有的spark streaming應用程序，都要啟用checkpoint機制，如果既不強制要求從Driver失敗中自動進行恢復，又沒使用有狀態的transformation操作，那么就不需要啟用checkpoint，事實上，這么做反而是有助于提升性能的

11.如何自動從Driver失敗中恢復過來

?

要能夠自動從Driver失敗中恢復過來運行spark Streaming應用程序的集群，就必須監控Driver運行的過程，并且在他失敗時將他重啟，對于spark自身的standalone模式，需要進行一些配置去supervise driver，在他失敗時將其重啟

首先，要在spark-submit中，添加--deploy-mode參數，默認其值為client，即在提交應用的機器上啟動Driver，但是，要能夠自動重啟Driver，就必須將其值設置為cluster，此外，需要添加--supervise參數

?

部分原理圖稍后上傳。?