Standalone模式
提交任务的方式
        client提交方式
            
              在提交Application的客户端上启动Driver进程
                流程: Driver 向 Master 申请资源  --->  Master 在 Worker 启动excutor ---> Driver分发task  --->Worker返回结果
              总结: 
                    client模式适用于测试调试程序,Driver进程是在提交应用程序的客户端启动的,这样在Driver端可以看到task执行的情况。
                    生产环境下不能使用client模式,进程提交应用程序,客户端网卡流量暴增的问题。
                命令:
./spark-submit --master spark://..... --deploy-mode client --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10
# 或
./spark-submit --master spark://..... --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10
        cluster提交方式
            
            随机选择一台Worker节点启动Driver进程
            流程: 向 Master 启动 Driver  --->  Master 在某一台启动 Driver ---> Driver 向 Master 申请资源  --->  Master 在 Worker 启动excutor ---> Driver分发task  ---> Worker返回结果给Driver
            总结: 
    Driver进程是在集群某一台Worker上启动的,在客户端是无法查看task的执行情况的。
                    每次Driver会随机在某一台Worker上启动,那么这100次网卡流量暴增的问题就散布在集群上。
             命令:
./spark-submit --master spark://..... --deploy-mode cluster --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10
       总结以上两种方式提交任务,Driver与集群的通信包括:
                1. Driver负责应用程序资源的申请
                2. 任务的分发。
                3. 结果的回收。
                4. 监控task执行情况。

术语解释
    Master(standalone):资源管理的主节点(进程)
    Cluster Manager:在集群上获取资源的外部服务(例如standalone,Mesos,Yarn )
    Worker Node(standalone):资源管理的从节点(进程) 或者说管理本机资源的进程
    Application:基于Spark的⽤用户程序,包含了driver程序和运行在集群上的executor程序
    Driver Program:用来连接工作进程(Worker)的程序
    Executor:是在一个worker进程所管理的节点上为某Application启动的⼀一个进程,该进程负责运行任务,并且负责将数据存在内存或者磁盘上。每个应⽤用都有各自独⽴立的executors
    Task:被送到某个executor上的工作单元
    Job:包含很多任务(Task)的并行计算,可以看做和action对应
    Stage:⼀个Job会被拆分很多组任务,每组任务被称为Stage(就像Mapreduce分map task和reduce task一样)

窄依赖和宽依赖

    
    当一个RDD中的一个Partition的数据流向下一个RDD的多个Partition时,这两个RDD为宽依赖 (一对多)
    当一个RDD中的一个Partition的数据都只流向下一个RDD的一个Partition时,这两个RDD为窄依赖 (多对一
  

        

Stage切割规则
      
        当一个 action算子  触发执行Job时,会从 finalRDD往前回溯查找依赖为什么不从前往后? 因为 RDD 只知道自己依赖谁,不知道被谁依赖
        当碰到 宽依赖  (即碰到会产生shuffle的算子时),就会切分Stage,即 连续的窄依赖  会被划分在同一个Stage
Task
        在一个Stage内,只有窄依赖,不会产生shuffle ,也就是RDD内的一个Partition数据经过计算后还会在 同一个节点的Partition内 
        也就是说这个Partition的数据可以 只由一个Task来处理,也就是说这些 Task 可以 并行计算
        而由上图可以直观看到 Task 的个数由Stage内的 finalRDD的Partition个数决定 
        pipeline
                综上可得在一个Stage内,一个Partition会被 一个Task  执行  多个  不会产生Shuffle的算子   进行处理
                那么某一个算子的执行结果就不需要落到磁盘,而是每输出一行直接在内存中传递到下一个算子作为输入  。
                    伪代码(对于一行数据) map(filter(textFile(path)))
                即数据在一个task会像在一个管道(pipeline)内传递,从一个算子传递到另外一个算子,这样提高了执行效率
                 
               也就是Spark中的一个task才相当与MapReduce中的一个task,而不是一个算子相当于MR中的一个task
                例如  WordCount:
                        MapReduce中Mapper做的事情,在Spark中需要map和flatmap两个算子。
                        而这个两个算子实际运行时并不是独立的,而是通过pipeline管道,flatmap 每输出一行,就会进入到map中执行(而不是flatmap全部执行完,才执行map)
                
                同时由于一个task内算子与算子之间的数据不需要缓存,所以也就解释了为什么checkpoint时,RDD需要重新计算,
                而不想重新算一遍的话,就需要在 数据在 pipeline 里流动时,调用执行cache(),让数据落地 而让spark对数据进行缓存。

        当 一个task执行完后 ,即到了Stage边界的时候,会 进入 shuffle Write 阶段 ,将 数据落地 到磁盘,等待下一个Stage的task过来拉取聚合 (shuffle read)。
            shuffle小文件拉取过程: 详解 shuffle 时的数据拉取过程
            shuffle过程详解:Spark Shuffle 详解与优化
运行流程
       1、当所有Worker启动完成后,Worker会向Master注册,注册信息包括当前节点的资源情况
        2、Driver会在代码执行到 new SparkContext() 时启动,根据RDD之间的依赖关系将Application形成一个DAG有向无环图 ,并创建 高层调度器 DAGScheduler 和 任务调度器 TaskScheduler 对象。
        3、当TaskScheduler对象创建完后,TaskScheduler会向Master发送请求,注册Application信息,并申请资源。
        4、 Master在接收到请求后,根据配置的资源要求决定在哪些Worker上启动多少个Executor , 然后会向Worker发送消息,启动对应的计算进程executor。
        5、当Worker上的executor启动成功后会反向注册给 Driver中的 TaskScheduler
        6、DAGScheduler会根据action算子划分Job,然后根据 Job 的宽窄依赖来划分 Stage ,并将每个 stage 分为一组并行计算的task,然后将 Stage封装在 taskSet 对象中交给TaskScheduler
       7、 TaskScheduler 在收到 taskSet对象后,交给调度池调度池会将task序列化,然后根据 partition 的数据位置(也就是数据block位置)为优先分发 位置,将task 到对应的 executor中。
       8、 executor会执行收到的task,将task反序列化封装成线程,放到线程池中执行,并且会向TaskScheduler发送心跳信息,报告task执行情况。
                    如果task执行失败,会由TaskScheduler 负责重试,默认重试三次,
                    如果还是失败,会有 DAGScheduler 重试stage,默认重试4次,
                    如果还是失败,则 Job失败。
                    如果开启了推测执行,当TaskScheduler判断某个task为 挣扎的任务(stragglings task 可能失败的任务)时,会另起一个task执行,不会杀死原来的。这时就可能造成数据重复,与消耗了更多的性能资源。
       9、 当执行到 sc.stop() 时Driver会向Master发送消息,可以把 executor 全部杀死了。
       10、这时Master会通知Worker把excutor给kill掉。


Yarn模式
    Spark 运行在 yarn 上,这种模式yarn集群里的机器 不需要 安装Spark,因为 提交节点 执行代码里的主函数时创建的Driver进程 会将Spark依赖包(spark-assembly-1.6.0-hadoop2.6.0.jar 与 application.jar)上传到hdfs,然后执行任务时NodeManager会将依赖包下载到本地,这样Executor就可以执行Jar里的Spark代码了,也就是说有了spark-assembly.jar 这个依赖包就不需要Spark安装包了。
模式配置
        client提交方式
            
        执行流程:
        1、在客户端执行提交命令,在本地启动一个Drive进程.
        2、Drive进程启动完毕后,会向ResourceManager申请启动一个ApplicationMaster.
                        3、RM 收到请求,随机选择一台 NodeManager 启动 ApplicationMaster.
                        4、AM启动后,会向RM请求一批container资源(用于启动Executor).
                        5、RM会找到一批NM返回给AM,AM会向NM发送命令启动Executor.
                        6、Executor启动后,会反向注册给Driver,Driver发送task到Executor. 
        总结
                        Yarn-client模式同样是适用于测试,因为Driver运行在本地,Driver会与yarn集群中的Executor进行大量的通信,会造成客户机网卡流量的大量增加
                        ApplicationMaster的作用:
                                1、为当前的Application申请资源
                                2、给NodeManager发送消息启动Executor。
                                注意:ApplicationMaster有launchExcutor和申请资源的功能,并没有作业调度的功能。
                命令:
./spark-submit --master yarn-client --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10
# 或
./spark-submit --master yarn --deploy-mode client --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10
        cluster提交方式
            
        执行流程
        1、客户端执行提交命令,并不会启动Drive进程,客户端向RM申请启动一个ApplicationMaster
        2、RM收到请求后随机在一台NM上启动AM(相当于Driver端)
                ApplicationMaster(Driver)启动成功后向RM申请资源
        3、AM启动后,AM发送请求到RM,请求一批container(用于启动Excutor)。
        4、RM返回一批NM节点给AM,AM发送请求到NM启动Executor。
        5、Executor反向注册到AM所在的节点的Driver。Driver发送task到Executor。
        总结
                        Yarn-Cluster主要用于生产环境中,因为Driver运行在Yarn集群中某一台nodeManager中,每次提交任务的Driver所在的机器都是随机的,不会产生某一台机器网卡流量激增的现象,缺点是任务提交后不能看到日志。只能通过yarn查看日志。
                        ApplicationMaster的作用:
                                1、为当前的Application申请资源
                                2、给NameNode发送消息启动Excutor。
                                3、任务调度。
                命令:
./spark-submit --master yarn-cluster --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10
# 或
./spark-submit --master yarn --deploy-mode cluster --class org.apache.spark.examples.SparkPi spark-1.6.0/lib/spark-examples-1.6.0-hadoop2.6.0.jar 10


粗粒度资源调度:Spark
    再Application执行前将 所有的资源申请完毕,然后再进行任务调度,直到所有的 task执行完才释放资源
    资源的复用 :   Spark中所有的task可以复用同一批Executor线程资源 ,task执行完后exector不需要杀死
    优点:
            在每一个task执行前,资源就已经申请完毕了,不需要为每一个task单独去申请资源,那么这task的启动时间就少了,任务会执行更快。
    缺点:
            不是动态分配资源且task执行完才释放资源,资源无法充分利用
细粒度资源调度:MapReduce
    Application在执行之前 不会去提前申请资源,而是直接任务调度,每一task在 执行前自己去申请资源  ,申请到了就执行,申请不到就一直申请。
    MapReduce里面每一个map task对应一个JVM进程,每个MapTask执行都要新建一个JVM线程,运行完这个进程就死了。
    优点:
            可以充分利用集群资源
    缺点:
            task执行时间加长

添加新评论