深入理解Spark 2.1 Core (五):Standalone模式
概述
前幾篇博文都在介紹Spark的排程,這篇博文我們從更加宏觀的排程看Spark,講講Spark的部署模式。Spark部署模式分以下幾種:
local 模式
local-cluster 模式
Standalone 模式
YARN 模式
Mesos 模式
我們先來簡單介紹下YARN模式,然後深入講解Standalone模式。
YARN 模式介紹
YARN介紹
YARN是一個資源管理、任務排程的框架,主要包含三大模組:ResourceManager(RM)、NodeManager(NM)、ApplicationMaster(AM)。
其中,ResourceManager負責所有資源的監控、分配和管理;ApplicationMaster負責每一個具體應用程式的排程和協調;NodeManager負責每一個節點的維護。
對於所有的applications,RM擁有絕對的控制權和對資源的分配權。而每個AM則會和RM協商資源,同時和NodeManager通訊來執行和監控task。幾個模組之間的關係如圖所示。
這裡寫圖片描述
Yarn Cluster 模式
這裡寫圖片描述
Spark的Yarn Cluster 模式流程如下:
本地用YARN Client 提交App 到 Yarn Resource Manager
-
Yarn Resource Manager 選個 YARN Node Manager,用它來
建立個ApplicationMaster,SparkContext相當於是這個ApplicationMaster管的APP,生成YarnClusterScheduler與YarnClusterSchedulerBackend
選擇叢集中的容器啟動CoarseCrainedExecutorBackend,用來啟動spark.executor。
ApplicationMaster與CoarseCrainedExecutorBackend會有遠端呼叫。
Yarn Client 模式
這裡寫圖片描述
Spark的Yarn Client 模式流程如下:
本地啟動SparkContext,生成YarnClientClusterScheduler 和 YarnClientClusterSchedulerBackend
YarnClientClusterSchedulerBackend啟動yarn.Client,用它提交App 到 Yarn Resource Manager
Yarn Resource Manager 選個 YARN Node Manager,用它來選擇叢集中的容器啟動CoarseCrainedExecutorBackend,用來啟動spark.executor
YarnClientClusterSchedulerBackend與CoarseCrainedExecutorBackend會有遠端呼叫。
Standalone 模式介紹
這裡寫圖片描述
啟動app,在SparkContxt啟動過程中,先初始化DAGScheduler 和 TaskScheduler,並初始化 SparkDeploySchedulerBackend,並在其內部啟動DriverEndpoint和ClientEndpoint。
ClientEndpoint想Master註冊app,Master收到註冊資訊後把該app加入到等待執行app列表中,等待由Master分配給該app worker。
app獲取到worker後,Master通知Worker的WorkerEndpont建立CoarseGrainedExecutorBackend程式,在該程式中建立執行容器executor
executor建立完畢後傳送資訊給Master和DriverEndpoint,告知Executor建立完畢,在SparkContext註冊,後等待DriverEndpoint傳送執行任務的訊息。
SparkContext分配TaskSet給CoarseGrainedExecutorBackend,按一定排程策略在executor執行。詳見:與
CoarseGrainedExecutorBackend在Task處理的過程中,把處理Task的狀態傳送給DriverEndpoint,Spark根據不同的執行結果來處理。若處理完畢,則繼續傳送其他TaskSet。詳見:
app執行完成後,SparkContext會進行資源回收,銷燬Worker的CoarseGrainedExecutorBackend程式,然後登出自己。
Standalone 啟動叢集
這裡寫圖片描述
啟動Master
master.Master
我們先來看下Master物件的main函式做了什麼:
private[deploy] object Master extends Logging { val SYSTEM_NAME = "sparkMaster" val ENDPOINT_NAME = "Master" def main(argStrings: Array[String]) { Utils.initDaemon(log) //建立SparkConf val conf = new SparkConf //解析SparkConf引數 val args = new MasterArguments(argStrings, conf) val (rpcEnv, _, _) = startRpcEnvAndEndpoint(args.host, args.port, args.webUiPort, conf) rpcEnv.awaitTermination() } def startRpcEnvAndEndpoint( host: String, port: Int, webUiPort: Int, conf: SparkConf): (RpcEnv, Int, Option[Int]) = { val securityMgr = new SecurityManager(conf) val rpcEnv = RpcEnv.create(SYSTEM_NAME, host, port, conf, securityMgr) //建立Master val masterEndpoint = rpcEnv.setupEndpoint(ENDPOINT_NAME, new Master(rpcEnv, rpcEnv.address, webUiPort, securityMgr, conf)) val portsResponse = masterEndpoint.askWithRetry[BoundPortsResponse](BoundPortsRequest) //返回 Master RpcEnv, //web UI 埠, //其他服務的埠 (rpcEnv, portsResponse.webUIPort, portsResponse.restPort) } }
master.MasterArguments
接下來我們看看master是如何解析引數的:
private[master] class MasterArguments(args: Array[String], conf: SparkConf) extends Logging { //預設配置 var host = Utils.localHostName() var port = 7077 var webUiPort = 8080 //Spark屬性檔案 //預設為 spark-default.conf var propertiesFile: String = null // 檢查環境變數 if (System.getenv("SPARK_MASTER_IP") != null) { logWarning("SPARK_MASTER_IP is deprecated, please use SPARK_MASTER_HOST") host = System.getenv("SPARK_MASTER_IP") } if (System.getenv("SPARK_MASTER_HOST") != null) { host = System.getenv("SPARK_MASTER_HOST") } if (System.getenv("SPARK_MASTER_PORT") != null) { port = System.getenv("SPARK_MASTER_PORT").toInt } if (System.getenv("SPARK_MASTER_WEBUI_PORT") != null) { webUiPort = System.getenv("SPARK_MASTER_WEBUI_PORT").toInt } parse(args.toList) // 轉變SparkConf propertiesFile = Utils.loadDefaultSparkProperties(conf, propertiesFile) //環境變數的SPARK_MASTER_WEBUI_PORT //會被Spark屬性spark.master.ui.port所覆蓋 if (conf.contains("spark.master.ui.port")) { webUiPort = conf.get("spark.master.ui.port").toInt } //解析命令列引數 //命令列引數會把環境變數和Spark屬性都覆蓋 @tailrec private def parse(args: List[String]): Unit = args match { case ("--ip" | "-i") :: value :: tail => Utils.checkHost(value, "ip no longer supported, please use hostname " + value) host = value parse(tail) case ("--host" | "-h") :: value :: tail => Utils.checkHost(value, "Please use hostname " + value) host = value parse(tail) case ("--port" | "-p") :: IntParam(value) :: tail => port = value parse(tail) case "--webui-port" :: IntParam(value) :: tail => webUiPort = value parse(tail) case ("--properties-file") :: value :: tail => propertiesFile = value parse(tail) case ("--help") :: tail => printUsageAndExit(0) case Nil => case _ => printUsageAndExit(1) } private def printUsageAndExit(exitCode: Int) { System.err.println( "Usage: Master [options]n" + "n" + "Options:n" + " -i HOST, --ip HOST Hostname to listen on (deprecated, please use --host or -h) n" + " -h HOST, --host HOST Hostname to listen onn" + " -p PORT, --port PORT Port to listen on (default: 7077)n" + " --webui-port PORT Port for web UI (default: 8080)n" + " --properties-file FILE Path to a custom Spark properties file.n" + " Default is conf/spark-defaults.conf.") System.exit(exitCode) } }
我們可以看到上述引數設定的優先順序別為:
$large系統環境變數 < spark-default.conf中的屬性 < 命令列引數 < 應用級程式碼中的引數設定$
啟動Worker
worker.Worker
我們先來看下Worker物件的main函式做了什麼:
private[deploy] object Worker extends Logging { val SYSTEM_NAME = "sparkWorker" val ENDPOINT_NAME = "Worker" def main(argStrings: Array[String]) { Utils.initDaemon(log) //建立SparkConf val conf = new SparkConf //解析SparkConf引數 val args = new WorkerArguments(argStrings, conf) val rpcEnv = startRpcEnvAndEndpoint(args.host, args.port, args.webUiPort, args.cores, args.memory, args.masters, args.workDir, conf = conf) rpcEnv.awaitTermination() } def startRpcEnvAndEndpoint( host: String, port: Int, webUiPort: Int, cores: Int, memory: Int, masterUrls: Array[String], workDir: String, workerNumber: Option[Int] = None, conf: SparkConf = new SparkConf): RpcEnv = { val systemName = SYSTEM_NAME + workerNumber.map(_.toString).getOrElse("") val securityMgr = new SecurityManager(conf) val rpcEnv = RpcEnv.create(systemName, host, port, conf, securityMgr) val masterAddresses = masterUrls.map(RpcAddress.fromSparkURL(_)) //建立Worker rpcEnv.setupEndpoint(ENDPOINT_NAME, new Worker(rpcEnv, webUiPort, cores, memory, masterAddresses, ENDPOINT_NAME, workDir, conf, securityMgr)) rpcEnv } ***
worker.WorkerArguments
worker.WorkerArguments與master.MasterArguments類似:
private[worker] class WorkerArguments(args: Array[String], conf: SparkConf) { var host = Utils.localHostName() var port = 0 var webUiPort = 8081 var cores = inferDefaultCores() var memory = inferDefaultMemory() var masters: Array[String] = null var workDir: String = null var propertiesFile: String = null // 檢查環境變數 if (System.getenv("SPARK_WORKER_PORT") != null) { port = System.getenv("SPARK_WORKER_PORT").toInt } if (System.getenv("SPARK_WORKER_CORES") != null) { cores = System.getenv("SPARK_WORKER_CORES").toInt } if (conf.getenv("SPARK_WORKER_MEMORY") != null) { memory = Utils.memoryStringToMb(conf.getenv("SPARK_WORKER_MEMORY")) } if (System.getenv("SPARK_WORKER_WEBUI_PORT") != null) { webUiPort = System.getenv("SPARK_WORKER_WEBUI_PORT").toInt } if (System.getenv("SPARK_WORKER_DIR") != null) { workDir = System.getenv("SPARK_WORKER_DIR") } parse(args.toList) // 轉變SparkConf propertiesFile = Utils.loadDefaultSparkProperties(conf, propertiesFile) if (conf.contains("spark.worker.ui.port")) { webUiPort = conf.get("spark.worker.ui.port").toInt } checkWorkerMemory() @tailrec private def parse(args: List[String]): Unit = args match { case ("--ip" | "-i") :: value :: tail => Utils.checkHost(value, "ip no longer supported, please use hostname " + value) host = value parse(tail) case ("--host" | "-h") :: value :: tail => Utils.checkHost(value, "Please use hostname " + value) host = value parse(tail) case ("--port" | "-p") :: IntParam(value) :: tail => port = value parse(tail) case ("--cores" | "-c") :: IntParam(value) :: tail => cores = value parse(tail) case ("--memory" | "-m") :: MemoryParam(value) :: tail => memory = value parse(tail) //工作目錄 case ("--work-dir" | "-d") :: value :: tail => workDir = value parse(tail) case "--webui-port" :: IntParam(value) :: tail => webUiPort = value parse(tail) case ("--properties-file") :: value :: tail => propertiesFile = value parse(tail) case ("--help") :: tail => printUsageAndExit(0) case value :: tail => if (masters != null) { // Two positional arguments were given printUsageAndExit(1) } masters = Utils.parseStandaloneMasterUrls(value) parse(tail) case Nil => if (masters == null) { // No positional argument was given printUsageAndExit(1) } case _ => printUsageAndExit(1) } ***
資源回收
我們在概述中提到了“ app執行完成後,SparkContext會進行資源回收,銷燬Worker的CoarseGrainedExecutorBackend程式,然後登出自己。”接下來我們就來講解下Master和Executor是如何感知到Application的退出的。
呼叫棧如下:
SparkContext.stop
-
DAGScheduler.stop
CoarseGrainedSchedulerBackend.stop
CoarseGrainedSchedulerBackend.DriverEndpoint.receiveAndReply
CoarseGrainedSchedulerBackend.DriverEndpoint.receiveAndReply
Executor.stop
CoarseGrainedExecutorBackend.receive
CoarseGrainedSchedulerBackend.stopExecutors
TaskSchedulerImpl.stop
SparkContext.stop
SparkContext.stop會呼叫DAGScheduler.stop
*** if (_dagScheduler != null) { Utils.tryLogNonFatalError { _dagScheduler.stop() } _dagScheduler = null } ***
DAGScheduler.stop
DAGScheduler.stop會呼叫TaskSchedulerImpl.stop
def stop() { //停止訊息排程 messageScheduler.shutdownNow() //停止事件處理迴圈 eventProcessLoop.stop() //呼叫TaskSchedulerImpl.stop taskScheduler.stop() }
TaskSchedulerImpl.stop
TaskSchedulerImpl.stop會呼叫CoarseGrainedSchedulerBackend.stop
override def stop() { //停止推斷 speculationScheduler.shutdown() //呼叫CoarseGrainedSchedulerBackend.stop if (backend != null) { backend.stop() } //停止結果獲取 if (taskResultGetter != null) { taskResultGetter.stop() } starvationTimer.cancel() }
CoarseGrainedSchedulerBackend.stop
override def stop() { //呼叫stopExecutors() stopExecutors() try { if (driverEndpoint != null) { //傳送StopDriver訊號 driverEndpoint.askWithRetry[Boolean](StopDriver) } } catch { case e: Exception => throw new SparkException("Error stopping standalone scheduler's driver endpoint", e) } }
CoarseGrainedSchedulerBackend.stopExecutors
我們先來看下CoarseGrainedSchedulerBackend.stopExecutors
def stopExecutors() { try { if (driverEndpoint != null) { logInfo("Shutting down all executors") //傳送StopExecutors訊號 driverEndpoint.askWithRetry[Boolean](StopExecutors) } } catch { case e: Exception => throw new SparkException("Error asking standalone scheduler to shut down executors", e) } }
CoarseGrainedSchedulerBackend.DriverEndpoint.receiveAndReply
DriverEndpoint接收並回應該訊號:
case StopExecutors => logInfo("Asking each executor to shut down") for ((_, executorData) <- executorDataMap) { //給CoarseGrainedExecutorBackend傳送StopExecutor訊號 executorData.executorEndpoint.send(StopExecutor) } context.reply(true)
CoarseGrainedExecutorBackend.receive
CoarseGrainedExecutorBackend接收該訊號:
case StopExecutor => stopping.set(true) logInfo("Driver commanded a shutdown") //這裡並沒有直接關閉Executor, //因為Executor必須先返回確認幀給CoarseGrainedSchedulerBackend //所以,這的策略是給自己再發一個Shutdown訊號,然後處理 self.send(Shutdown) case Shutdown => stopping.set(true) new Thread("CoarseGrainedExecutorBackend-stop-executor") { override def run(): Unit = { // executor.stop() 會呼叫 `SparkEnv.stop()` // 直到 RpcEnv 徹底結束 // 但是, 如果 `executor.stop()` 執行在和RpcEnv相同的執行緒裡面, // RpcEnv 會等到`executor.stop()`結束後才能結束, // 這就產生了死鎖 // 因此,我們需要新建一個執行緒 executor.stop() }
Executor.stop
def stop(): Unit = { env.metricsSystem.report() //關閉心跳 heartbeater.shutdown() heartbeater.awaitTermination(10, TimeUnit.SECONDS) //關閉執行緒池 threadPool.shutdown() if (!isLocal) { //停止SparkEnv env.stop() } }
CoarseGrainedSchedulerBackend.DriverEndpoint.receiveAndReply
我們回過頭來看CoarseGrainedSchedulerBackend.stop,呼叫stopExecutors()結束後,會給 driverEndpoint傳送StopDriver訊號。CoarseGrainedSchedulerBackend.DriverEndpoint.接收訊號並回復:
case StopDriver => context.reply(true) //停止driverEndpoint stop()
作者:小爺Souljoy
連結:
來自 “ ITPUB部落格 ” ,連結:http://blog.itpub.net/1834/viewspace-2819261/,如需轉載,請註明出處,否則將追究法律責任。
相關文章
- Spark開發-Standalone模式Spark模式
- Spark Standalone模式 高可用部署Spark模式
- 深入理解Spark 2.1 Core (四):運算結果處理和容錯的原理Spark
- 【Spark篇】--Spark中Standalone的兩種提交模式Spark模式
- 部署spark2.2叢集(standalone模式)Spark模式
- Windows上搭建Standalone模式的Spark環境Windows模式Spark
- Spark Standalone模式 Master程式掛掉問題Spark模式AST
- spark 2.1.0 standalone模式配置&&打包jar包透過spark-submit提交Spark模式JARMIT
- spark之 spark 2.2.0 Standalone安裝、wordCount演示Spark
- Reactor:深入理解reactor coreReact
- 《深入理解Spark》之Spark的整體執行流程Spark
- 深入理解代理模式模式
- 《深入理解Spark》之sparkSQL 處理流程SparkSQL
- 深入理解spark之架構與原理Spark架構
- 深入理解工廠模式模式
- 深入理解單例模式單例模式
- 深入淺出理解 Spark:環境部署與工作原理Spark
- Windows 10 安裝Spark2.1WindowsSpark
- 深入理解JVM(五)——垃圾回收器JVM
- MVC設計模式深入理解MVC設計模式
- [深入理解Android卷二 全文-第五章]深入理解PowerManagerServiceAndroid
- .NET Core 3.0之深入原始碼理解HttpClientFactory(二)原始碼HTTPclient
- .NET Core 3.0之深入原始碼理解HttpClientFactory(一)原始碼HTTPclient
- 深入理解Aspnet Core之Identity(4)IDE
- Java核心(五)深入理解BIO、NIO、AIOJavaAI
- standalone執行模式下 應用模式作業部署模式
- 深入原始碼理解Spark RDD的資料分割槽原理原始碼Spark
- 使用.NET Core 2.1的Azure WebJobsWeb
- 深入理解 EF Core:EF Core 寫入資料時發生了什麼?
- 深入理解 EF Core:EF Core 讀取資料時發生了什麼?
- 深入理解Java記憶體模型(五)——鎖Java記憶體模型
- Spark 叢集搭建從零開始之3 Spark Standalone叢集安裝、配置與測試Spark
- asp.net core 2.1 配置管理ASP.NET
- 深入理解[Future模式]原理與技術模式
- 深入理解RxJava中的觀察者模式RxJava模式
- java 23種設計模式 深入理解Java設計模式
- 深入理解javascript系列(五):變數物件(VO)2JavaScript變數物件
- .NET Core 3.0之深入原始碼理解Configuration(二)原始碼