深入理解Spark 2.1 Core (五):Standalone模式

firefule發表於2021-09-09

概述

前幾篇博文都在介紹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 模式介紹

圖片描述

這裡寫圖片描述

  1. 啟動app,在SparkContxt啟動過程中,先初始化DAGScheduler 和 TaskScheduler,並初始化 SparkDeploySchedulerBackend,並在其內部啟動DriverEndpoint和ClientEndpoint。

  2. ClientEndpoint想Master註冊app,Master收到註冊資訊後把該app加入到等待執行app列表中,等待由Master分配給該app worker。

  3. app獲取到worker後,Master通知Worker的WorkerEndpont建立CoarseGrainedExecutorBackend程式,在該程式中建立執行容器executor

  4. executor建立完畢後傳送資訊給Master和DriverEndpoint,告知Executor建立完畢,在SparkContext註冊,後等待DriverEndpoint傳送執行任務的訊息。

  5. SparkContext分配TaskSet給CoarseGrainedExecutorBackend,按一定排程策略在executor執行。詳見:與

  6. CoarseGrainedExecutorBackend在Task處理的過程中,把處理Task的狀態傳送給DriverEndpoint,Spark根據不同的執行結果來處理。若處理完畢,則繼續傳送其他TaskSet。詳見:

  7. 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/,如需轉載,請註明出處,否則將追究法律責任。

相關文章