精华内容
参与话题
问答
  • Spark运行原理【史上最详细】

    万次阅读 多人点赞 2018-08-16 19:00:42
    Spark应用程序以进程集合为单位在分布式集群上运行,通过driver程序的main方法创建的SparkContext对象与集群交互。 1、Spark通过SparkContext向Cluster manager(资源管理器)申请所需执行的资源(cpu、内存等) 2、...

    Spark应用程序以进程集合为单位在分布式集群上运行,通过driver程序的main方法创建的SparkContext对象与集群交互。

    1、Spark通过SparkContext向Cluster manager(资源管理器)申请所需执行的资源(cpu、内存等)

    2、Cluster manager分配应用程序执行需要的资源,在Worker节点上创建Executor

    3、SparkContext 将程序代码(jar包或者python文件)和Task任务发送给Executor执行,并收集结果给Driver。

                                                              图1 Spark运行原理图

    Spark详细运行过程如下图

                                                            图2 Spark运行详细流程

                                                             图3 Spark运行流程描述


    涉及的几个定义和详细的运行过程如下:

    1、Application:Spark应用程序

        指的是用户编写的Spark应用程序,包含了Driver功能代码和分布在集群中多个节点上运行的Executor代码。

        Spark应用程序,由一个或多个作业JOB组成,如下图所示。

                                                            图4 Spark应用程序组成

    2、Driver:驱动程序

        Spark中的Driver即运行上述Application的Main()函数并且创建SparkContext,其中创建SparkContext的目的是为了准备Spark应用程序的运行环境。在Spark中由SparkContext负责和ClusterManager通信,进行资源的申请、任务的分配和监控等;当Executor部分运行完毕后,Driver负责将SparkContext关闭。通常SparkContext代表Driver,如下图所示。

                                                                     图5  Driver驱动程序组成

    3、Cluster Manager:资源管理器

        指的是在集群上获取资源的外部服务,常用的有:Standalone,Spark原生的资源管理器,由Master负责资源的分配;Haddop Yarn,由Yarn中的ResearchManager负责资源的分配;Messos,由Messos中的Messos Master负责资源管理。

    4、Executor:执行器

        Application运行在Worker节点上的一个进程,该进程负责运行Task,并且负责将数据存在内存或者磁盘上,每个Application都有各自独立的一批Executor,如下图所示。

                                                                     图6 Executor运行原理

    5、Worker:计算节点

        集群中任何可以运行Application代码的节点,类似于Yarn中的NodeManager节点。在Standalone模式中指的就是通过Slave文件配置的Worker节点,在Spark on Yarn模式中指的就是NodeManager节点,在Spark on Messos模式中指的就是Messos Slave节点,如下图所示。

                                                                       图7 Worker运行原理

     

    6、DAGScheduler:有向无环图调度器

    基于DAG划分Stage 并以TaskSet的形势提交Stage给TaskScheduler;负责将作业拆分成不同阶段的具有依赖关系的多批任务;最重要的任务之一就是:计算作业和任务的依赖关系,制定调度逻辑。在SparkContext初始化的过程中被实例化,一个SparkContext对应创建一个DAGScheduler。

                                                                图8 DAGScheduler图解

    7、TaskScheduler:任务调度器

    将Taskset提交给worker(集群)运行并回报结果;负责每个具体任务的实际物理调度。如图所示。

                                                              图9 TaskScheduler图解

    8、Job:作业

    由一个或多个调度阶段所组成的一次计算作业;包含多个Task组成的并行计算,往往由Spark Action催生,一个JOB包含多个RDD及作用于相应RDD上的各种Operation。如图所示。

                                                         图10 Job图解

    9、Stage:调度阶段

    一个任务集对应的调度阶段;每个Job会被拆分很多组Task,每组任务被称为Stage,也可称TaskSet,一个作业分为多个阶段;Stage分成两种类型ShuffleMapStage、ResultStage。如图所示。

     

                                                           图11 Stage图解

    Application多个job多个Stage:Spark Application中可以因为不同的Action触发众多的job,一个Application中可以有很多的job,每个job是由一个或者多个Stage构成的,后面的Stage依赖于前面的Stage,也就是说只有前面依赖的Stage计算完毕后,后面的Stage才会运行。

    划分依据:Stage划分的依据就是宽依赖,何时产生宽依赖,reduceByKey, groupByKey等算子,会导致宽依赖的产生。

    核心算法:从后往前回溯,遇到窄依赖加入本stage,遇见宽依赖进行Stage切分。Spark内核会从触发Action操作的那个RDD开始从后往前推,首先会为最后一个RDD创建一个stage,然后继续倒推,如果发现对某个RDD是宽依赖,那么就会将宽依赖的那个RDD创建一个新的stage,那个RDD就是新的stage的最后一个RDD。然后依次类推,继续继续倒推,根据窄依赖或者宽依赖进行stage的划分,直到所有的RDD全部遍历完成为止。

    将DAG划分为Stage剖析:如上图,从HDFS中读入数据生成3个不同的RDD,通过一系列transformation操作后再将计算结果保存回HDFS。可以看到这个DAG中只有join操作是一个宽依赖,Spark内核会以此为边界将其前后划分成不同的Stage. 同时我们可以注意到,在图中Stage2中,从map到union都是窄依赖,这两步操作可以形成一个流水线操作,通过map操作生成的partition可以不用等待整个RDD计算结束,而是继续进行union操作,这样大大提高了计算的效率。

    10、TaskSet:任务集

    由一组关联的,但相互之间没有Shuffle依赖关系的任务所组成的任务集。如图所示。

                                                   图12 Stage图解

    提示:

    1)一个Stage创建一个TaskSet;

    2)为Stage的每个Rdd分区创建一个Task,多个Task封装成TaskSet

    11、Task:任务

    被送到某个Executor上的工作任务;单个分区数据集上的最小处理流程单元(单个stage内部根据操作数据的分区数划分成多个task)。如图所示。

                                    图13 Task图解

    总体如图所示:

                                                                             图14 汇总图解

     

     部分内容转载自:http://www.sohu.com/a/217196727_100065429

    展开全文
  • spark工作流程及原理(一)

    千次阅读 2018-06-27 14:35:53
    Spark架构的组成图如下: Cluster Manager:在standalone模式中即为Master主节点,控制整个集群,监控worker。在YARN模式中为资源管理器 Worker节点:从节点,负责控制计算节点,启动Executor或者Driver。 ...

    Spark架构的组成图如下:

    Cluster Manager:在standalone模式中即为Master主节点,控制整个集群,监控worker。在YARN模式中为资源管理器

    Worker节点:从节点,负责控制计算节点,启动Executor或者Driver。

    Driver: 运行Application 的main()函数

           Executor:执行器,是为某个Application运行在worker node上的一个进程

     

    spark运行流程图如下:

            1.构建Spark Application的运行环境,启动SparkContext

      

    val conf = new SparkConf();
    conf.setAppName("test01")
    conf.setMaster("local")
    val sc = new SparkContext(conf)

    2.SparkContext向资源管理器(可以是Standalone,Mesos,Yarn)申请运行Executor资源,并启动StandaloneExecutorbackend,

    3.Executor向SparkContext申请Task

    4.SparkContext将应用程序分发给Executor

    5.SparkContext构建成DAG图,将DAG图分解成Stage、将Taskset发送给Task Scheduler,最后由Task Scheduler将Task发送给Executor运行

    6.Task在Executor上运行,运行完释放所有资源

     

         Spark运行特点:

    每个Application获取专属的executor进程,该进程在Application期间一直驻留,并以多线程方式运行Task。这种Application隔离机制是有优势的,无论是从调度角度看(每个Driver调度他自己的任务),还是从运行角度看(来自不同Application的Task运行在不同JVM中),当然这样意味着Spark Application不能跨应用程序共享数据,除非将数据写入外部存储系统

    Spark与资源管理器无关,只要能够获取executor进程,并能保持相互通信就可以了

    提交SparkContext的Client应该靠近Worker节点(运行Executor的节点),最好是在同一个Rack里,因为Spark Application运行过程中SparkContext和Executor之间有大量的信息交换

    Task采用了数据本地性和推测执行的优化机制

     

    常用术语

     

    Application: Appliction都是指用户编写的Spark应用程序,其中包括一个Driver功能的代码和分布在集群中多个节点上运行的Executor代码

    Driver:  Spark中的Driver即运行上述Application的main函数并创建SparkContext,创建SparkContext的目的是为了准备Spark应用程序的运行环境,在Spark中有SparkContext负责与ClusterManager通信进行资源申请、任务的分配和监控等,当Executor部分运行完毕后,Driver同时负责将SparkContext关闭,通常用SparkContext代表Driver

    Executor:  某个Application运行在worker节点上的一个进程,  该进程负责运行某些Task, 并且负责将数据存到内存或磁盘上,每个Application都有各自独立的一批Executor, 在Spark on Yarn模式下,其进程名称为CoarseGrainedExecutor Backend。一个CoarseGrainedExecutor Backend有且仅有一个Executor对象, 负责将Task包装成taskRunner,并从线程池中抽取一个空闲线程运行Task, 这个每一个oarseGrainedExecutor Backend能并行运行Task的数量取决与分配给它的cpu个数

    Cluter Manager:指的是在集群上获取资源的外部服务。目前有三种类型

    Standalone : spark原生的资源管理,由Master负责资源的分配

    Apache Mesos:与hadoop MR兼容性良好的一种资源调度框架

    Hadoop Yarn: 主要是指Yarn中的ResourceManager

    Worker: 集群中任何可以运行Application代码的节点,在Standalone模式中指的是通过slave文件配置的Worker节点,在Spark on Yarn模式下就是NoteManager节点

    Task: 被送到某个Executor上的工作单元,但hadoopMR中的MapTask和ReduceTask概念一样,是运行Application的基本单位,多个Task组成一个Stage,而Task的调度和管理等是由TaskScheduler负责

    Job: 包含多个Task组成的并行计算,往往由Spark Action触发生成, 一个Application中往往会产生多个Job

    Stage: 每个Job会被拆分成多组Task, 作为一个TaskSet, 其名称为Stage,Stage的划分和调度是有DAGScheduler来负责的,Stage有非最终的Stage(Shuffle Map Stage)和最终的Stage(Result Stage)两种,Stage的边界就是发生shuffle的地方

    DAGScheduler: 根据Job构建基于Stage的DAG(Directed Acyclic Graph有向无环图),并提交Stage给TASkScheduler。 其划分Stage的依据是RDD之间的依赖的关系找出开销最小的调度方法,如下图

    TASKSedulter: 将TaskSET提交给worker运行,每个Executor运行什么Task就是在此处分配的. TaskScheduler维护所有TaskSet,当Executor向Driver发生心跳时,TaskScheduler会根据资源剩余情况分配相应的Task。另外TaskScheduler还维护着所有Task的运行标签,重试失败的Task。下图展示了TaskScheduler的作用

    在不同运行模式中任务调度器具体为:

    Spark on Standalone模式为TaskScheduler

    YARN-Client模式为YarnClientClusterScheduler

    YARN-Cluster模式为YarnClusterScheduler

    将这些术语串起来的运行层次图如下:

    Job=多个stage,Stage=多个同种task, Task分为ShuffleMapTask和ResultTask,Dependency分为ShuffleDependency和NarrowDependency

    spark作业提交原理

     

     

    展开全文
  • Spark基本架构及运行原理

    万次阅读 2018-04-12 13:20:39
    Spark软件栈 Spark Core: 包含Spark的基本功能,包含任务调度,内存管理,容错机制等,内部定义了RDDs(弹性分布式数据集),提供了很多APIs来创建和操作这些RDDs。为其他组件提供底层的服务。 Spark SQL: ...

    Spark软件栈

    这里写图片描述

    • Spark Core:

    包含Spark的基本功能,包含任务调度,内存管理,容错机制等,内部定义了RDDs(弹性分布式数据集),提供了很多APIs来创建和操作这些RDDs。为其他组件提供底层的服务。

    • Spark SQL:

    Spark处理结构化数据的库,就像Hive SQL,Mysql一样,企业中用来做报表统计。

    • Spark Streaming:

    实时数据流处理组件,类似Storm。Spark Streaming提供了API来操作实时流数据。企业中用来从Kafka接收数据做实时统计。

    • MLlib:

    一个包含通用机器学习功能的包,Machine learning lib包含分类,聚类,回归等,还包括模型评估和数据导入。MLlib提供的上面这些方法,都支持集群上的横向扩展。

    • Graphx:

    处理图的库(例如,社交网络图),并进行图的并行计算。像Spark Streaming,Spark SQL一样,它也继承了RDD API。它提供了各种图的操作,和常用的图算法,例如PangeRank算法。

    Spark提供了全方位的软件栈,只要掌握Spark一门编程语言就可以编写不同应用场景的应用程序(批处理,流计算,图计算等)。Spark主要用来代替Hadoop的MapReduce部分。

    Hadoop MapReduce缺点:

    1. 表达能力有限
    2. 磁盘IO开销大,任务之间的衔接涉及IO开销
    3. 延迟高,Map任务要全部结束,reduce任务才能开始。

    Spark借鉴Hadoop MapReduce优点的同时,解决了MapReuce所面临的问题,有如下优点:

    1. Spark的计算模式也属于MapReduce,但不局限于Map和Reduce操作,还提供多种数据集操作类型,编程模型比Hadoop MapReduce更灵活。
    2. Spark提供了内存计算,可将中间结果放到内存中,对于迭代运算效率更高
    3. Spark基于DAG的任务调度执行机制,要优于Hadoop MapReduce的迭代执行机制。

    Spark运行架构及流程

    这里写图片描述

    基本概念:

    • Application:用户编写的Spark应用程序。
    • Driver:Spark中的Driver即运行上述Application的main函数并创建SparkContext,创建SparkContext的目的是为了准备Spark应用程序的运行环境,在Spark中有SparkContext负责与ClusterManager通信,进行资源申请、任务的分配和监控等,当Executor部分运行完毕后,Driver同时负责将SparkContext关闭。
    • Executor:是运行在工作节点(WorkerNode)的一个进程,负责运行Task。
    • RDD:弹性分布式数据集,是分布式内存的一个抽象概念,提供了一种高度受限的共享内存模型。
    • DAG:有向无环图,反映RDD之间的依赖关系。
    • Task:运行在Executor上的工作单元。
    • Job:一个Job包含多个RDD及作用于相应RDD上的各种操作。
    • Stage:是Job的基本调度单位,一个Job会分为多组Task,每组Task被称为Stage,或者也被称为TaskSet,代表一组关联的,相互之间没有Shuffle依赖关系的任务组成的任务集。
    • Cluter Manager:指的是在集群上获取资源的外部服务。目前有三种类型
      1) Standalon : spark原生的资源管理,由Master负责资源的分配
      2) Apache Mesos:与hadoop MR兼容性良好的一种资源调度框架
      3) Hadoop Yarn: 主要是指Yarn中的ResourceManager

    一个Application由一个Driver和若干个Job构成,一个Job由多个Stage构成,一个Stage由多个没有Shuffle关系的Task组成。

    当执行一个Application时,Driver会向集群管理器申请资源,启动Executor,并向Executor发送应用程序代码和文件,然后在Executor上执行Task,运行结束后,执行结果会返回给Driver,或者写到HDFS或者其它数据库中。

    与Hadoop MapReduce计算框架相比,Spark所采用的Executor有两个优点:

    1. 利用多线程来执行具体的任务减少任务的启动开销;
    2. Executor中有一个BlockManager存储模块,会将内存和磁盘共同作为存储设备,有效减少IO开销;

    Spark运行基本流程:

    这里写图片描述

    1. 为应用构建起基本的运行环境,即由Driver创建一个SparkContext进行资源的申请、任务的分配和监控
    2. 资源管理器为Executor分配资源,并启动Executor进程
    3. SparkContext根据RDD的依赖关系构建DAG图,DAG图提交给DAGScheduler解析成Stage,然后把一个个TaskSet提交给底层调度器TaskScheduler处理。
      Executor向SparkContext申请Task,TaskScheduler将Task发放给Executor运行并提供应用程序代码。
    4. Task在Executor上运行把执行结果反馈给TaskScheduler,然后反馈给DAGScheduler,运行完毕后写入数据并释放所有资源。

    Spark运行架构特点:

    1. 每个Application都有自己专属的Executor进程,并且该进程在Application运行期间一直驻留。Executor进程以多线程的方式运行Task。
    2. Spark运行过程与资源管理器无关,只要能够获取Executor进程并保存通信即可。
    3. Task采用数据本地性和推测执行等优化机制。

    RDD

    一个RDD就是一个分布式对象集合,本质上是一个只读的分区记录集合,每个RDD可分成多个分区,每个分区就是一个数据集片段,并且一个RDD的不同分区可以被保存到集群中不同的节点上,从而可以在集群的不同节点上进行并行计算。

    RDD提供了一种高端受限的共享内存模型,即RDD是只读的记录分区的集合,不能直接修改,只能基于稳定的物理存储中的数据集创建RDD,或者通过在其他RDD上执行确定的转换操作(如map,join和group by)而创建得到新的RDD。

    RDD执行过程:

    1. RDD读入外部数据源进行创建
    2. RDD经过一系列的转换(Transformation)操作,没一次都会产生不同的RDD供下一个转换操作使用
    3. 最后一个RDD经过“动作”操作进行转换并输出到外部数据源

    优点:惰性调用、管道化、避免同步等待,不需要保存中间结果。这和Java8中Stream的概念极其类似。
    这里写图片描述
    RDD特性

    1. 高效的容错性,根据DAG图恢复分区,数据复制或者记录日志
      RDD血缘关系、重新计算丢失分区、无需回滚系统、重算过程在不同节点之间并行、只记录粗粒度的操作
    2. 中间结果持久化到内存,数据在内存中的多个RDD操作之间进行传递,避免了不必要的读写磁盘开销
    3. 存放的数据可以是Java对象,避免了不必要的对象序列化和反序列化

    窄依赖和宽依赖

    • 窄依赖:表现为一个父RDD的分区对应于一个子RDD的分区或者多个父RDD的分区对应于一个子RDD的分区。
    • 宽依赖:表现为存在一个父RDD的一个分区对应一个子RDD的多个分区。
      这里写图片描述

    Stage的划分

    Spark通过分析各个RDD的依赖关系生成了DAG,在通过分析各个RDD中的分区之间的依赖关系来决定如何划分Stage。具体划分方法如下:

    • 在DAG中进行反向解析,遇到宽依赖就断开,遇到窄依赖就把当前的RDD加入到Stage中;
    • 将窄依赖尽量划分在同一个Stage中,可以实现流水线计算
      这里写图片描述

    此文主要参考厦门大学Spark基础教程

    展开全文
  • Spark原理篇之工作原理

    千次阅读 2019-06-02 17:17:47
    1 Spark背景       Spark是一个加州大学伯克利分校(UC Berkeley AMP)开发的一个分布式数据快速分析项目。它的核心技术是弹性分布式数据集(Resilient distributed datasets),提供...

    1 Spark背景

          Spark是一个加州大学伯克利分校(UC Berkeley AMP)开发的一个分布式数据快速分析项目。它的核心技术是弹性分布式数据集(Resilient distributed datasets),提供了比Hadoop更加丰富的MapReduce模型,可以快速在内存中对数据集进行多次迭代,来支持复杂的数据挖掘算法和图计算算法。

    2 Spark工作原理

    2.1 Spark专业术语定义

    (1)Application:Spark应用程序
          指的是用户编写的Spark应用程序,包含Driver功能代码和分布在集群中多个节点上运行的Executor代码。Spark应用程序,由一个或多个作业Job组成,如下图所示: 在这里插入图片描述
    (2)Driver:驱动程序
          Spark中的Driver即运行上述Application的Main()函数并且创建SparkContext,其中创建SparkContext的目的是为了准备Spark应用程序的运行环境。在Spark中由SparkContext负责和ClusterManager通信,进行资源的申请、任务的分配和监控等;当Executor部分运行完毕后,Driver负责将SparkContext关闭。通常SparkContext代表Driver,如下图所示:
    在这里插入图片描述
    (3)Cluster Manager:资源管理器
          指的是在集群上获取资源的外部服务,常用的有:Local,Spark单机运行,一般用于开发测试;Standalone,Spark原生的资源管理器,由Master负责资源的分配;Hadoop Yarn,由Yarn中的ResearchManager负责资源的分配;由Messos中的Messos Master负责资源管理。
    (4)Executor:执行器
          Application运行在Worker节点上的一个进程,该进程负责运行Task,并且负责将数据存在内存或者磁盘上,每个Application都有各自独立的一批Executor,如下图所示:
    在这里插入图片描述
    (5)Worker:计算节点
          集群中任何可以运行Application代码的节点,类似于Yarn中的NodeManager节点。在Standalone模式中指的是通过Slave文件配置的Worker节点,在Spark on Yarn模式汇总指的就是NodeManager节点,在Spark on Messos模式中指的就是Messos Slave节点,如下图所示:
    在这里插入图片描述
    (6)RDD (Resilient distributed datasets):弹性分布式数据集
          Spark的基本计算单元,可以通过一系列算子进行操作(主要有Transformation和Action操作),如下图所示:
    在这里插入图片描述
    (7)窄依赖
          父RDD每一个分区最多被一个子RDD的分区所用;表现为一个父RDD的分区对应于一个子RDD的分区,或两个父RDD的分区对应于一个子RDD的分区。如图所示: 在这里插入图片描述
          一个Stage内的窄依赖进行pipeline操作(Spark为了加快计算,做的优化),举例:
          ① 优化:1+1+1+1=4;
          ② 未优化:1+1=2,2+1=3,3+1=4。
    (8)宽依赖
          父RDD的每个分区都可能被多个子RDD分区所使用,子RDD分区通常对应所有的父 RDD分区。如图所示: 在这里插入图片描述
          常见的宽窄依赖有:map、filter、union、mapPartitions、mapValues、join(父RDD是hash-partitioned:如果joinAPI之前被调用的RDD API是宽依赖【存在shuffle】,而且两个join的RDD的分区数量一致,join结果的RDD分区数量也一样,这个时候join API是窄依赖)。
          常见的宽依赖有:groupByKey、partitionBy、reduceByKey、join(父RDD不是hash-partitioned:除此之外的,RDD的join API都是宽依赖)。
          对hash-partitioned想要更详细的理解,请参考文章[4][5]。
    (9)DAG (Directed Acycle Graph):有向无环图
          反应RDD之间的依赖关系,如图所示: 在这里插入图片描述
    (10)DAGScheduler:有向无环图调度器
          基于DAG划分Stage并以TaskSet的形式提交Stage给TaskScheduler;负责将作业拆分成不同阶段的具有宽窄依赖关系的多批任务;最重要的任务之一就是:计算作业和任务的依赖关系,指定调度逻辑。在SparkContext初始化的过程中被实例化,一个SparkContext对应一个DAGScheduler。 在这里插入图片描述
    (11)TaskScheduler:任务调度器
          将TaskSet提交给Worker(集群)运行并汇报结果;负责每个具体任务的实际物理调度。如图所示: 在这里插入图片描述
    (12)Job:作业
          由一个或多个调度阶段所组成的一次计算作业;包含多个Task组成的并行计算,往往由Spark Action催生,一个Job包含多个RDD及作用于相应RDD上的各种Operation。如图所示: 在这里插入图片描述
    (13)Stage:调度阶段
          一个任务对应的阶段;每个Job会被拆分很多组Task,每组任务被称为Stage,也可称TaskSet,一个作业分为多个阶段;Satge分成两种类型ShuffleMapStage、ResultStage。如图所示: 在这里插入图片描述
    (14)TaskSet:任务集
          由一组关联的,但相互之间没有Shuffle依赖关系的任务所组成的任务集。如图所示: 在这里插入图片描述
    提示
          1) 一个Stage创建一个TaskSet;
          2) 为Stage的每个RDD分区创建一个Task,多个Task分装成TaskSet。
    (15)Task:任务
          被送到某个Executor上的工作任务;单个分区数据集上的最小处理流程单元。如图所示:
    在这里插入图片描述
          总体如图所示:
    在这里插入图片描述

    2.2 Spark基本流程

    (1)Spark内核架构图
    在这里插入图片描述
          1-14步属于SparkContext的初始化阶段。
    (2)运行基本流程
    在这里插入图片描述
    在这里插入图片描述

    2.3 Spark运行架构特点

    (1)Executor进程专属
          每个Application获取专属的Executor进程,该进程在Application期间一直驻留,并以多线程方式运行Tasks。Spark Application不能跨应用程序共享数据,除非将数据写入到外部存储系统。如图所示: 在这里插入图片描述
    (2)支持多种资源管理器
          Spark与资源管理器无关,只要能够获取Executor进程,并能保持相互通信就可以了,Spark支持资源管理器(Standalone、Messos和Yarn)
    (3)Job提交就近原则
          提交SparkContext的Client靠近Worker节点(运行Executor的节点),最好是在同一个Rack(机架)里,因为Spark Application运行过程中SparkContext和Executor之间有大量的信息交换;如果想在远程集群中运行,最好使用RPC将SparkContext提交给集群,不要远离Worker运行SparkContext。
    (4)移动程序而非移动数据的原则执行
          Task采用了数据本地性和推测执行的优化机制。关键方法:taskIdToLocations、getPreferedLocations。
    2.4 Spark核心原理透视
    (1)计算流程 在这里插入图片描述
    (2)从代码构建DAG图
          Spark的计算发生在RDD的Action操作,而对Action之前的所有Transformation,Spark只是记录下RDD生成的轨迹,而不会触发真正的计算。
    Spark内核会在需要计算发生的时刻绘制一张关于计算路径的有向无环图,也就是DAG。
    在这里插入图片描述
    (3)将DAG划分为Stage核心算法
          Application多个Job多个Stage:Spark Application中可以因为不同的Action触发众多的Job,一个Application中可以有很多的Job,每个Job是由一个或多个Stage构成的,后面的Stage依赖于前面的Stage,也就是说只有前面的Stage计算完毕后,后面的Stage才会运行。
          划分依据:Stage划分的依据就是宽依赖,何时产生宽依赖,reduceByKey,groupByKey等算子,会导致宽依赖的产生。
          核心算法:从后往前回溯,遇到窄依赖加入本Stage,遇见宽依赖进行Stage切分。Spark内核会从触发Action操作的那个RDD开始从后往前推,首先会为最后一个RDD创建一个Stage,然后继续倒推,如果发现对某个RDD是宽依赖,那么就会将宽依赖的那个RDD创建一个新的Stage,那个RDD就是新的Stage的最后一个RDD。然后以此类推,继续倒推,根据窄依赖或者宽依赖进行Stage的划分,直到所有的RDD全部遍历完成为止。
    (4)将DAG划分为Stage剖析
          从HDFS中读取数据生成3个不同的RDD,通过一系列Transformation操作后再将计算结果保存到HDFS。可以看到这个DAG中只有join操作是一个窄依赖,Spark内核会以此为边界将其前后划分成不同的Stage。同时我们可以注意到,在图中Stage2中,从map到union都是窄依赖,这两步操作可以形成一个流水线操作,通过map操作生成的partition可以不用等待整个RDD计算结束,而是继续进行union操作,这样大大提高了计算的效率。 在这里插入图片描述
    (5)提交Stages
          调度阶段的提交,最终会将转换成一个任务集的提交,DAGScheduler通过TaskScheduler接口提交任务集,这个任务集最终会触发TaskScheduler构建一个TaskSetManager的实例来管理这个任务集的生命周期,对于DAGScheduler来说,提交调度阶段的工作到此就完成了。而TaskScheduler的具体实现则会在得到计算资源的时候,进一步通过TaskSetManager调度具体的任务到对应的Executor节点上进行运算。
    在这里插入图片描述
          TaskSetManager负责管理TaskSchedulerImpl中一个单独TaskSet,跟踪每一个Task,如果Task失败,负责重试Task直到达到Task重试次数的最多次数。
    (6)监控Job、Task和Executor
          DAGScheduler监控Job和Task:要保证相互依赖的作业调度阶段能够得到顺利地调度执行。DAGScheduler需要监控当前作业调度阶段乃至任务的完成情况。这通过对外暴露的一系列的回调函数来实现的,对于TaskScheduler来说,这些回调函数主要包括任务的开始结束失败、任务集的失败,DAGScheduler根据这些任务的生命周期信息进一步维护作业和调度阶段的状态信息。
          DAGScheduler监控Executor的生命状态:TaskScheduler通过回调函数通知DAGScheduler具体的Executor的生命状态,如果某一个Executor崩溃了,则对应的调度阶段任务集的ShuffleMap Task的输出结果也将标志位不可用,这将导致对应任务集状态的变更,进而重新执行相关计算任务,以获取丢失的相关数据。
    (7)获取任务执行结果
          结果DAGScheduler:一个具体的任务在Executor中执行完毕后,其结果需要以某种形式返回给DAGScheduler,根据任务类型的不同,任务结果的返回方式也不同。
          两种结果,中间结果与最终结果:对于FinalStage所对应的任务,返回给DAGScheduler的是运算结果本身,而对于中间阶段对应的任务ShuffleMap Task,返回给DAGScheduler的是一个MapStatus里的相关存储信息,而非结果本身,这些存储位置信息作为下一个调度阶段的任务获取输入数据的依据。
          两种类型,DirectTaskResult与IndirectTaskResult:根据任务结果大小的不同,ResultTask返回的结果又分为两类,如果结果足够小,则直接放在DirectTaskResult对象内存中,如果超过特定尺寸则在Executor端会将DirectTaskResult先序列化,再把序列化的结果作为一个数据块放在BlockManager中,然后将BlockManager返回的BlockID放在IndirectTaskResult对象中返回给TaskScheduler,TaskScheduler进而调用TaskResultGetter将IndirectTaskResult中的BlockID取出并通过BlockManager最终取得对应的DirectTaskResult。
    (8)任务调度总体诠释 在这里插入图片描述

    2.4 Spark运行模式

    2.4.1 Standalone模式

    (1)Standalone架构图 在这里插入图片描述
    (2)Standalone运行过程
          ① SparkContext连接到Master,向Master注册并申请资源(CPU Core and Memory)。
          ② Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定哪个Worker上分配资源,然后在该Worker上获取资源,然后启动Executor,Executor向SparkContext注册。
          ③ SparkContext将Application代码发送到Executor。同时,SparkContext解析Application代码,构建DAG图,并提交给DAGScheduler分解成Stage,然后以Stage(或者称为TaskSet)提交给TaskScheduler,TaskScheduler负责将Task分配到相应的Worker,最后提交给Executor执行。
          ④ Executor会建立Executor线程池,开始执行Task,并向SparkContext报告,直至Task完成。
          ⑤ 所有Task完成后,SparkContext向Master注销,释放资源。如图所示: 在这里插入图片描述

    2.4.2 Spark on Yarn模式

    (1)Yarn-Cluster模式 在这里插入图片描述
          ① Client向Yarn中提交应用程序,包括ApplicationMaster程序、启动ApplicationMaster的命令、需要在Executor中运行的程序等。
          ② ResourceManager收到请求后,在集群中选择一个NodeManager,为该应用程序分配第一个Container,要求它在这个Container中启动应用程序的ApplicationMaster,其中ApplicationMaster进行SparkContext等的初始化。
          ③ ApplicationMaster向ResourceManager注册,这样用户可以直接通过ResourceManage查看应用程序的运行状态,然后它将采用轮询的方式通过RPC协议为各个任务申请资源,并监控它们的运行状态直到运行结束。
          ④ 一旦ApplicationMaster申请到资源后,便与对应的NodeManager通信,要求它在获得的Container中启动Executor,启动后会向ApplicationMaster中的SparkContext注册并申请Task。
          ⑤ ApplicationMaster中的SparkContext分配Task给Executor执行,Executor运行Task并向ApplicationMaster汇报运行的状态和进度,以让ApplicationMaster随时掌握各个任务的运行状态,从而可以在任务失败时重新启动任务。
          ⑥ 应用程序运行完成后,ApplicationMaster向ResourceManager申请注销并关闭自己。
    (2)Spark on Yarn-Client 模式 在这里插入图片描述
          ① Client向Yarn的ResourceManager申请启动ApplicationMaster。同时,在SparkContext初始化中将创建DAGScheduler和TaskScheduler。
          ② ResourceManager收到请求后,在集群中选择一个NodeManager,为该能够用程序分配第一个Container,要求它在这个Container中启动应用程序的ApplicationMaster。
          ③ Client中的SparkContext初始化完毕后,与ApplicationMaster建立通讯,向ResourceManager注册,根据任务信息向ResourceManager申请资源。
          ④ 一旦ApplicationMaster申请到资源后,便与对应的NodeManager通信,要求它在获得的Container中启动Executor,启动后会向Client中的SparkContext注册并申请Task。
          ⑤ Client中的SparkContext分配Task给Executor执行,Executor运行Task并向Driver汇报运行的状态和进度,以让Client随时掌握各个任务的运行状态,从而可以在任务失败时重新启动任务。
          ⑥ 应用程序运行完成后,Client的SparkContext向ResourceManager申请注销并关闭自己。
    (3)Yarn-Cluster与Yarn-Client的区别
          它们的区别就是ApplicationMaster的区别:Yarn-Cluster中ApplicationMaster不仅负责申请资源,并负责监控Task的运行状况,因此可以关掉Client;而Yarn-Client中ApplicationMaster仅负责申请资源,由Client中的Driver来监控调度Task的运行,因此不能关掉Client。
    (4)Spark on Yarn与MapReduce on Yarn的区别
          Spark的高性能一定程度上取决于它采用的异步并发模型(这里指server/driver端采用 的模型),这与Hadoop 2.0(包括Yarn和MapReduce)是一致的。Hadoop 2.0自己实现了类似Actor的异步并发模型,实现方式是epoll+状态机,而Spark则直接采用了开源软件Akka,该软件实现了Actor模型,性能非常高。尽管二者在server端采用了一致的并发模型,但在任务级别(特指Spark任务和MapReduce任务)上却采用了不同的并发机制:Hadoop MapReduce采用了多进程模型,而Spark采用了多线程模型。
          注意,这里的多进程和多线程,指的是同一个节点上多个任务的运行模式。无论是MapReduce和Spark,整体上看,都是多进程:MapReduce应用程序是由多个独立的Task进程组成的;Spark应用成的运行环境是由多个独立的Executor进程构建的临时资源池构成的。
          多进程模型便于细粒度控制每个任务占用的资源,但会消耗较多的启动时间,不适合运行低延迟类型的作业,这是MapReduce广为诟病的原因之一。而多线程模型则相反,该模型使得Spark很适合运行低延迟类型的作业。总之,Spark同节点上的任务以多线程的方式运行在一个JVM进程中,可带来以下好处:
          ① 任务启动速度快,与之相反的是MapReduce Task进程的慢启动速度,通常需要1s左右;
          ② 同节点上所有任务运行在一个进程中,有利于共享内存。这非常适合内存密集型任务,尤其对于那些需要加载大量词典的应用程序,可大大节省内存;
          ③ 同节点上所有任务可运行在一个JVM进程(Executor)中,且Executor所占资源可连续被多批任务使用,不会在运行部分任务后释放掉,这避免了每个任务重复申请资源带来的时间开销,对于任务数目非常多的应用,可大大降低运行时间。与之对比的是MapReduce中的Task:每个Task单独申请资源,用完后马上释放,不能被其他任务重用,尽管1.0支持JVM重用在一定程度上弥补了该问题,但2.0尚未支持该功能。
          尽管Spark的多线程模型带来了很多好处,但同样存在不足,主要有:
          ① 由于节点上所有任务运行在一个进程中,因此,会出现严重的资源争用,难以细粒度控制每个任务占用资源。与之相反的是MapReduce,它允许用户单独为Map Task和Reduce Task设置不同的资源,进而细粒度控制任务占用资源量,有利于大作业的正常平稳运行。
          下面简要介绍MapReduce的多进程模型进而Spark多线程模型
          1)MapReduce多进程模型 在这里插入图片描述
          ① 每个Task运行在一个独立的JVM进程中;
          ② 可单独为不同类型的Task设置不同的资源量,目前支持内存和CPU两种资源;
          ③ 每个Task运行完后,释放所占用的资源,这些资源不能被其他Task复用,即使是同一个作业相同类型的Task。也就是说,每个Task都要经历“申请资源->运行Task->释放资源”的过程。
    2)Spark多线程模型 在这里插入图片描述
          ① 每个节点上可以运行一个或多个Executor服务(一个节点上可以有多个Container);
          ② 每个Executor配有一定数量的slot,表示该Executor中可以同时运行多少个ShuffleMap Task或者Reduce Task;
          ③ 每个Executor单独运行在一个JVM进程中,每个Task则是运行在Executor中的一个线程(每个线程可以通过轮询的方式运行每个Task);
          ④ 同一个Executor内部的Task可共享内存,比如通过函数SparkContext.broadcast广播的文件或者数据结构只会在每个Executor中加载一次,而不会像MapReduce那样,每个Task加载一次;
          ⑤ Executor一旦启动后,将一直运行,且它的资源可以一直被Task复用,直到Spark程序运行完成后才释放退出。
          总体上看,Spark采用的是经典的scheduler/workers模式,每个Spark应用程序运行的第一步是构建一个可重用的资源池,然后在这个资源池里运行所有的ShuffleMap Task和Reduce Task(注意,尽管Spark引擎内部只用两类Task便可表示出一个复杂的应用程序,即ShuffleMap Task和Reduce Task),而MapReduce应用程序则不同,它不会构建一个可重用的资源池,而是让每个Task动态申请资源,且运行完后马上释放资源。

    参看文章:
    [1] http://www.raincent.com/content-85-11052-1.html
    [2] http://www.raincent.com/content-85-11090-1.html
    [3] http://www.raincent.com/content-85-11118-1.html
    [4] https://www.cnblogs.com/rxingyue/p/7113100.html
    [5] https://blog.csdn.net/andybegin/article/details/78190807

    展开全文
  • 目录一、Spark概述(1)概述(2)Spark整体架构(3)Spark特性(4)Spark...原理(1)分布式数据集(2)弹性(3)迭代式处理(4)容错性三、Spark 运行模式及集群角色(1)Spark运行模式(2)Spark集群角色(1)Cluster...
  • Spark工作原理

    万次阅读 多人点赞 2018-09-05 23:49:32
    Apache Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架,最初在2009年由...1.运行速度快,Spark拥有DAG执行引擎,支持在内存中对数据进行迭代计算。官方提供的数据表明,如果数据由磁盘读取,速度是H...
  • spark核心技术原理透视一(Spark运行原理

    万次阅读 多人点赞 2018-03-25 15:50:28
    原文链接:http://www.raincent.com/content-85-11052-1.html在大数据领域,只有深挖数据科学领域,走在学术前沿,才能在底层算法和模型...Spark的这种学术基因,使得它从一开始就在大数据领域建立了一定优势。无论...
  • Spark运行原理

    2017-01-19 16:26:25
    转载自,http://blog.csdn.net/lovehuangjiaju/article/details/48634607  在此向作者致敬! ...Spark运行方式Spark运行原理解析 本节内容及部分图片来自:  http://blog.csdn.net/boo
  • 原文链接:... Spark学习之路 (十二)SparkCore的调优之资源调优 ...目录一、概述二、Spark作业基本运行原理三、资源参数调优3.1 num-executors3.2 executor-memory3.3 e...
  • Spark原理详解

    千次阅读 2018-03-04 18:54:32
    Spark的出现很好的弥补了Hadoop在大数据处理上的不足,核心部分是对RDD进行阶段划分,同时随着枝叶不断散开,出线了很多的衍生的接口模块丰富了Spark的应用场景,也降低了Spark与其他技术的接入门槛
  • Spark 学习: spark 原理简述与 shuffle 过程介绍

    万次阅读 多人点赞 2016-11-03 17:55:40
    Spark学习: 简述总结 Spark 是使用 scala 实现的基于内存计算的大数据开源集群计算环境.提供了 java,scala, python,R 等语言...1 spark 运行原理 RDD 初识 shuffle 和 stage 性能优化 1 缓存机制和 cache 的意义 2 shu
  • Hadoop、Spark运行原理

    2019-05-06 14:24:52
    Hadoop、Spark运行原理hadoop 运行原理Spark运行原理 hadoop 运行原理 Hadoop的主要组成模块包括以下三个部分: Hadoop Distributed File System(HDFS):分布式文件存储系统。 MapReduce:并行计算框架(可以...
  • Spark原理

    千次阅读 2020-04-17 10:38:21
    基本概念 http://spark.apache.org/docs/latest/cluster-overview.html ●名词解释 1.Application:指的是用户编写的Spark应用程序/...2.Driver:Spark中的Driver即运行上述Application的Main()函数并且创建Spa...
  • spark原理:概念与架构、工作机制

    万次阅读 2018-09-03 11:05:37
    一、Hadoop、Spark、Storm三大框架比较 Hadoop:离线海量数据批处理,基于磁盘的 Spark:基于内存。 Spark特点:运行速度快,使用DAG执行引擎以支持循环数据流与内存计算, 2、容易使用:多种语言编程,通过spark ...
  • spark原理解析和spark core

    千次阅读 2018-05-06 21:56:58
    spark原理解析解析一:resilient distributed dataset (RDD)resilient distributed dataset (RDD):弹性分布式数据集,有容错机制可并行执行。分布式即体现在每个rdd分多个partition,每个partition在执行时为一个...
  • Spark应用程序以进程集合为单位在分布式集群上运行,通过driver程序的main方法创建的SparkContext对象与集群交互。 1、Spark通过SparkContext向Cluster manager(资源管理器)申请所需执行的资源(cpu、内存等) 2、...
  • 基本概念 名词解释 Application:指的是用户编写的...Driver:Spark中的Driver即运行上述Application的Main()函数并且创建SparkContext,SparkContext负责和ClusterManager通信,进行资源的申请、任务的分配和...
  • Spark运行原理剖析

    2018-04-15 18:22:46
    http://ihoge.cn/2018/Spark%20Scheduler.html ...Spark的核心是根据RDD来实现的,Spark Scheduler则为Spark核心实现的重要一环,其作用就是任务调度。Spark的任务调度就是如何组织任务去处理RDD中每个...
  • spark 生态及运行原理Spark 特点运行速度快 => Spark拥有DAG执行引擎,支持在内存中对数据进行迭代计算。官方提供的数据表明,如果数据由磁盘读取,速度是Hadoop MapReduce的10倍以上,如果数据从内存中读取...
  • spark运行原理简单介绍和一些总结

    千次阅读 2018-08-22 19:09:05
    1·,运行原理 看个流程图: 解说就是: 1,构建spark Application运行环境 2,sparkcontext向资源管理器注册 3,sparkContext向资源管理器申请运行Executor(执行器) 4,资源管理器分配executor 5,资源...
  • Spark相关名词解释: Driver 主进程,执行了一个Spark Application的main函数和创建Spark Contex的进程 在Yarn集群中: Yarn-Cluster Driver进程在集群的节点上 Yarn-Client Driver进程存在本地,方便调试,但是会...
  • Spark on Yarn的运行原理

    2019-03-13 17:00:25
    一、YARN是集群的资源管理系统 1、ResourceManager:负责整个集群的资源管理和分配。 2、ApplicationMaster:YARN中每个Application对应一个AM进程,负责与RM协商获取资源,获取资源后告诉NodeManager为其分配并...
  • spark 运行原理

    2017-09-18 16:34:15
    job task stage http://litaotao.github.io/deep-into-spark-exection-model
  • spark原理总结

    2019-09-16 21:24:08
    spark原理 driver创建sparkContext,sparkContext向master申请资源,申请完资源之后,启动worker上面的excutor进程,启动之后,资源准备好了,等待driver把任务提交,sparkContext开始构建DAG,然后划分stage,将任务...
  • spark运行原理

    2019-06-21 07:56:38
    添加链接描述
  • Spark 原理详解 整理

    千次阅读 2017-06-14 20:41:43
    Hadoop缺陷: 基于磁盘,无论是...这些都使得Hadoop在大数据运算上表现太“慢”,Spark应运而生。 Spark的架构设计: ClusterManager负责分配资源,有点像YARN中ResourceManager那个角色,大管家握有所有...
  • 提供了 java,scala, python,R 等语言的调用接口.Spark学习 简述总结引言1 Hadoop 和 Spark 的关系Spark 系统架构1 spark 运行原理RDD 初识shuffle 和 stage性能优化1 缓存机制和 cache 的意义2 shuffle 的优化3 资源...
  • Spark SQL运行原理解析

    2020-04-20 09:29:19
    Spark SQL和mysql、hivesql从SQL规范来说都一样 引擎: sparksql底层执行是spark,执行效率高,分布式 mysql底层执行是InnoDB,当然还有其他的引擎,单节点执行 hivesql底层执行默认是mapreduce,也可以更换为...
  • Spark原理、运维、与开发》,电子版免费贡献出来,供大家下载。正如书名所示,该书涵盖技术原理、安装配置、基本的开发等三个方面的内容。寥寥100多页的篇幅,使得大家对大数据工具Hadoop和Spark有一个初步的认识。 ...
  • 小白学习Spark原理

    千次阅读 2018-03-28 13:20:50
    Spark是UC Berkeley AMP lab所开发类似于Hadoop MapReduce的通用并行计算框架,Spark是基于map reduce算法实现分布式计算,拥有Hadoop MapReduce所具有的优点;但不同于MapReduce的是Job中间输出的结果可以保存在...

空空如也

1 2 3 4 5 ... 20
收藏数 38,071
精华内容 15,228
关键字:

spark运行原理