Spark基础知识

第1章 Spark概况

1.1 Spark基础

spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎

• Spark Core 中提供了 Spark 最基础与最核心的功能
• Spark SQL 是 Spark 用来操作结构化数据的组件。通过 Spark SQL，用户可以使用
  SQL 或者 Apache Hive 版本的 SQL 方言（HQL）来查询数据。
• Streaming 是 Spark 平台上针对实时数据进行流式计算的组件，提供了丰富的处理数据流的 API。

HBase 是一个基于 HDFS 的分布式数据库，擅长实时地随机读/写超大规模数据集。

Spark就是在传统的MapReduce计算框架的基础上，利用其计算过程的优化，从而大大加快了数据分析、挖掘的运行和读写速度，并将计算单元缩小到更适合并行计算和重复使用的RDD计算模型。

Spark是一个分布式数据快速分析项目。它的核心技术是弹性分布式数据集（Resilient DistributedDatasets），提供了比MapReduce丰富的模型，可以快速在内存中对数据集进行多次迭代，来支持复杂的数据挖掘算法和图形计算算法。

• Spark和Hadoop的根本差异是多个作业之间的数据通信问题:Spark多个作业之间数据通信是基于内存，而Hadoop是基于磁盘。
• SparkTask的启动时间快。Spark采用fork线程的方式，而Hadoop采用创建新的进程的方式。
• Spark只有在shuffle的时候将数据写入磁盘，而Hadoop中多个MR作业之间的数据交互都要依赖于磁盘交互
• Spark的缓存机制比HDFS的缓存机制高效。

Spark确实会比MapReduce 更有优势。但是Spark是基于内存的，所以在实际的生产环境中，由于内存的限制，可能会由于内存资源不够导致Job执行失败，此时，MapReduce其实是一个更好的选择，所以Spark 并不能完全替代MR。

Spark 会替代 MR，Spark 存储依赖 HDFS，资源调度依赖 YARN，集群管理依赖 Zookeeper。

Spark相对于Hadoop的优势

Hadoop虽然已成为大数据技术的事实标准，但其本身还存在诸多缺陷，最主要的缺陷是其MapReduce计算模型延迟过高，无法胜任实时、快速计算的需求，因而只适用于离线批处理的应用场景。

回顾Hadoop的工作流程，可以发现Hadoop存在如下一些缺点：

• 表达能力有限。计算都必须要转化成Map和Reduce两个操作，但这并不适合所有的情况，难以描述复杂的数据处理过程；
• 磁盘IO开销大。每次执行时都需要从磁盘读取数据，并且在计算完成后需要将中间结果写入到磁盘中，IO开销较大；
• 延迟高。一次计算可能需要分解成一系列按顺序执行的MapReduce任务，任务之间的衔接由于涉及到IO开销，会产生较高延迟。而且，在前一个任务执行完成之前，其他任务无法开始，难以胜任复杂、多阶段的计算任务。

Spark主要具有如下优点：

• Spark的计算模式也属于MapReduce，但不局限于Map和Reduce操作，还提供了多种数据集操作类型，编程模型比MapReduce更灵活；
• Spark提供了内存计算，中间结果直接放到内存中，带来了更高的迭代运算效率；
• Spark基于DAG的任务调度执行机制，要优于MapReduce的迭代执行机制。

Spark最大的特点就是将计算数据、中间结果都存储在内存中，大大减少了IO开销

Spark提供了多种高层次、简洁的API，通常情况下，对于实现相同功能的应用程序，Spark的代码量要比Hadoop少2-5倍。

但Spark并不能完全替代Hadoop，主要用于替代Hadoop中的MapReduce计算模型。实际上，Spark已经很好地融入了Hadoop生态圈，并成为其中的重要一员，它可以借助于YARN实现资源调度管理，借助于HDFS实现分布式存储。

Hadoop和Spark的统一部署

一方面，由于Hadoop生态系统中的一些组件所实现的功能，目前还是无法由Spark取代的，比如，Storm可以实现毫秒级响应的流计算，但是，Spark则无法做到毫秒级响应。另一方面，企业中已经有许多现有的应用，都是基于现有的Hadoop组件开发的，完全转移到Spark上需要一定的成本。因此，在许多企业实际应用中，Hadoop和Spark的统一部署是一种比较现实合理的选择。
由于Hadoop MapReduce、HBase、Storm和Spark等，都可以运行在资源管理框架YARN之上，因此，可以在YARN之上进行统一部署（如图9-16所示）。这些不同的计算框架统一运行在YARN中，可以带来如下好处：

• 计算资源按需伸缩；
• 不用负载应用混搭，集群利用率高；
• 共享底层存储，避免数据跨集群迁移。
  

1.2 Spark核心模块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XFRUEa55-1614082527822)(C09418EA15E14558890FEDBDE8614E94)]
SparkCore

• Spark Core包含Spark的基本功能，如内存计算、任务调度、部署模式、故障恢复、存储管理等。Spark建立在统一的抽象RDD之上，使其可以以基本一致的方式应对不同的大数据处理场景；通常所说的Apache Spark，就是指Spark Core；
• SparkCore中提供了Spark最基础与最核心的功能，Spark其他的功能如：SparkSQL，SparkStreaming，GraphX,MLlib都是在SparkCore的基础上进行扩展的。

SparkSQL

• Spark SQL允许开发人员直接处理RDD，同时也可查询Hive、HBase等外部数据源。Spark SQL的一个重要特点是其能够统一处理关系表和RDD，使得开发人员可以轻松地使用SQL命令进行查询，并进行更复杂的数据分析；

SparkStreaming

• SparkStreaming是Spark平台上针对实时数据进行流式计算的组件，提供了丰富的处理数据流的API。

SparkMLlib

• MLlib是Spark提供的一个机器学习算法库。MLlib不仅提供了模型评估、数据导入等额外的功能，还提供了一些更底层的机器学习原语。

SparkGraphX

• GraphX是Spark面向图计算提供的框架与算法库。

第2章 Spark快速上手

1、通过Scala语言开发
maven项目

2、Spark运行环境
Spark作为一个数据处理框架和计算引擎，被设计在所有常见的集群环境中运行,在国内工作中主流的环境为Yarn，不过逐渐容器式环境也慢慢流行起来。接下来，我们就分别看看不同环境下Spark的运行
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TscoK3Zf-1614082527825)(D9494F32F23C4D0183929780BA437992)]

2.1 Spark三种部署方式

Spark应用程序在集群上部署运行时，可以由不同的组件为其提供资源管理调度服务（资源包括CPU、内存等）。比如，可以使用自带的独立集群管理器（standalone），或者使用YARN，也可以使用Mesos。因此，Spark包括三种不同类型的集群部署方式，包括standalone、Spark on Mesos和Spark on YARN。

1. standalone模式
   与MapReduce1.0框架类似，Spark框架本身也自带了完整的资源调度管理服务，可以独立部署到一个集群中，而不需要依赖其他系统来为其提供资源管理调度服务。在架构的设计上，Spark与MapReduce1.0完全一致，都是由一个Master和若干个Slave构成，并且以槽（slot）作为资源分配单位。不同的是，Spark中的槽不再像MapReduce1.0那样分为Map 槽和Reduce槽，而是只设计了统一的一种槽提供给各种任务来使用。
2. Spark on Mesos模式
   Mesos是一种资源调度管理框架，可以为运行在它上面的Spark提供服务。Spark on Mesos模式中，Spark程序所需要的各种资源，都由Mesos负责调度。由于Mesos和Spark存在一定的血缘关系，因此，Spark这个框架在进行设计开发的时候，就充分考虑到了对Mesos的充分支持，因此，相对而言，Spark运行在Mesos上，要比运行在YARN上更加灵活、自然。目前，Spark官方推荐采用这种模式，所以，许多公司在实际应用中也采用该模式。
3. Spark on YARN模式
   Spark可运行于YARN之上，与Hadoop进行统一部署，即“Spark on YARN”，其架构如图9-13所示，资源管理和调度依赖YARN，分布式存储则依赖HDFS。

安装spark

brew install scala

vim /etc/profile
export SCALA_HOME=/usr/local/Cellar/scala
export PATH=$PATH:$SCALA_HOME/bin
exportSPARK_HOME=/Users/sx/open-source/spark-2.3.0-bin-hadoop2.7
export PATH=$PATH:$SPARK_HOME/bin


tar -zxvf /Users/kolor/Downloads/spark-3.0.1-bin-hadoop2.7.tgz
cd /Users/kolor/spark-3.0.1-bin-hadoop2.7
___ 以上是local本地模式，再加上以下这些就是Standalone模式

1）进入 conf文件夹，修改slaves.template文件名为slaves
2）修改slaves文件，添加work节点
linux1
linux2
linux3
3）修改spark-env.sh.template文件名为spark-env.sh
mv spark-env.sh.template spark-env.sh
4）修改spark-env.sh
export JAVA_HOME=/opt/module/jdk1.8.0_144
SPARK_MASTER_HOST=linux1
SPARK_MASTER_PORT=7077
注意：7077端口，相当于hadoop内部通信的8020端口，此处的端口需要确认自己的hadoop配置。

5）分发spark-standalone目录
xsync spark-standalone
6）启动集群
sh /Users/kolor/spark-3.0.1-bin-hadoop2.7/start-all.sh

使用

scala> var i = 10

scala> sc.textFile("word.txt").flatMap(_.split(" ")).map((_,1).reduceByKey(_+_).collect

local模式

访问http即可获得WEB UI界面，linux1:4040
提交：把应用程序提交到本地环境中执行。（Spark案例）

SparkPi是类名

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master local[2] \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

Standalone模式

local本地毕竟只是用来进行练习演示的，真实工作中还是要将应用提交到对应的集群中去执行，这里我们来看看只使用Spark自身节点运行的集群模式，也就是我们所谓的独立部署（Standalone）模式。Spark的Standalone模式体现了经典的master-slave模式。
提交应用

SparkPi是类名

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://linux1:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

1) --class表示要执行Spark程序中包含主函数的类
2) --master spark://linux1:7077 独立部署模式，连接到spark集群。
表示Spark程序运行的模式（环境）
模式：local[*]、spark://linux1:7077、Yarn
3) spark-examples_2.12-3.0.0.jar，运行类所在的jar包
4）数字10表示程序的入口参数，用于设定当前应用的任务数量

--executor-memory 1G，指定每个executor可用内存为1G
--total-executor-cores 2，指定所有executor使用的cpu核数为2个。
--executor-cores，指定每个executor使用的cpu核数
application-jar，打包好的应用jar，包含依赖。这个URL在集群中全局可见。比如：hdfs://xxx，那么所有的节点的path都包含同样的jar
application-arguments，传给main()方法的参数

Yarn模式

为什么要用Yarn来部署Spark？
因为 Yarn 支持动态资源配置。Standalone 模式只支持简单的固定资源分配策略，每个任务固定数量的 core，各 Job 按顺序依次分配在资源，资源不够的时候就排队。这种模式比较适合单用户的情况，多用户的情境下，会有可能有些用户的任务得不到资源。

Yarn 作为通用的种子资源调度平台，除了 Spark 提供调度服务之外，还可以为其他系统提供调度，如 Hadoop MapReduce, Hive 等。

独立部署（Standalone）模式由Spark自身提供计算资源，无需其他框架提供资源。这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。但是你也要记住，Spark主要是计算框架，而不是资源调度框架，所以本身提供的资源调度并不是它的强项，所以还是和其他专业的资源调度框架集成会更靠谱一些。

1、解压缩文件
将spark-3.0.0-bin-hadoopp3.2.tgz文件上传到linux并解压缩，放置在指定位置。
tar -zxvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/module
cd /opt/module
mv spark-examples_2.12-3.0.0 spark-yarn

2、修改配置文件
1）修改hadoop配置文件/opt/module/hadoop/etc/hadoop/yarn-site.xml 并分发

2）vim spark-env.sh
export JAVA_HOME=/opt/module/jdk1.8.0
YARN_CONF_DIR=/opt/module/hadoop/etc/hadoop

3、启动HDFS以及YARN集群

4、发布任务
bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode cluster \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

Spark Streaming

Spark Streaming处理结果可以保存到 HDFS、Database、Dashboard

Spark是以线程级别并行，实时响应级别高，可以实现秒级响应、变相实现高效的流计算。
（SparkStreaming把流计算切成一段段，每段都是批处理，达到模仿流计算效果）

Spark 的核心是建立在统一的抽象弹性分布式数据集（Resiliennt Distributed Datasets，RDD）之上的，这使得 Spark 的各个组件可以无缝地进行集成，能够在同一个应用程序中完成大数据处理。
RDD 是 Spark 提供的最重要的抽象概念，它是一种有容错机制的特殊数据集合，可以分布在集群的结点上，以函数式操作集合的方式进行各种并行操作。
通俗点来讲，可以将 RDD 理解为一个分布式对象集合，本质上是一个只读的分区记录集合。每个 RDD 可以分成多个分区，每个分区就是一个数据集片段。一个 RDD 的不同分区可以保存到集群中的不同结点上，从而可以在集群中的不同结点上进行并行计算。

SparkStreaming无法实现毫秒级响应，借助Storm实现

之前的方案是通过Hadoop批量处理与Storm实时流计算。 现在直接通过Spark方案

配置高可用（HA）

所谓的高可用是因为当前集群中的Master节点只有一个，所以会存在单点故障问题。为了解决单点故障问题，需要在集群中配置多个Master节点，一旦处于活动状态的Master发生故障时，由备用Master提供服务，保证作业才可以继续执行。这里的高可用一般采用Zookeeper设置。

第3章 Spark运行架构

Spark基本概念

在具体讲解Spark运行架构之前，需要先了解几个重要的概念：

• RDD：是弹性分布式数据集（Resilient Distributed Dataset）的简称，是分布式内存的一个抽象概念，提供了一种高度受限的共享内存模型；
• DAG：是Directed Acyclic Graph（有向无环图）的简称，反映RDD之间的依赖关系；
• Executor：是运行在工作节点（Worker Node）上的一个进程，负责运行任务，并为应用程序存储数据；
• 应用：用户编写的Spark应用程序；
• 任务：运行在Executor上的工作单元；
• 作业：一个作业包含多个RDD及作用于相应RDD上的各种操作；
• 阶段：是作业的基本调度单位，一个作业会分为多组任务，每组任务被称为“阶段”，或者也被称为“任务集”。

3.1 运行架构

Spark框架的核心是一个计算引擎，整体来说，它采用了标准master-slave的结构。

如下图所示，它展示了一个Spark执行时的基本结构。图形中的Driver表示master，负责管理整个集群中的作业任务调度。图形中的Executor则是slave，负责实际执行任务。

3.2 核心组件

由上图可以看出，对于Spark框架有两个核心组件：

3.2.1 Driver

Spark驱动器节点，用于执行Spark任务中的main方法，负责实际代码的执行工作。

Driver在Spark作业执行时主要负责：

• 将用户程序转化为作业（job）
• 在Executor之间调度任务（task）
• 跟踪Executor的执行情况
• 通过UI展示查询运行情况
  实际上，我们无法准确地描述Driver的定义，因为在整个的编程过程中没有看到任何有关Driver的字眼。所以简单理解，所谓的Driver就是驱动整个应用运行起来的程序，也称之为Driver类。

3.2.2 Executor

Spark Executor 是集群中工作节点（Worker）中的一个 JVM 进程，负责在 Spark 作业
中运行具体任务（Task），任务彼此之间相互独立。Spark 应用启动时，Executor 节点被同时启动，并且始终伴随着整个 Spark 应用的生命周期而存在。如果有 Executor 节点发生了
故障或崩溃，Spark 应用也可以继续执行，会将出错节点上的任务调度到其他 Executor 节点
上继续运行。

Executor 有两个核心功能：

• 负责运行组成 Spark 应用的任务，并将结果返回给驱动器进程
• 它们通过自身的块管理器（Block Manager）为用户程序中要求缓存的 RDD 提供内存
  式存储。RDD 是直接缓存在 Executor 进程内的，因此任务可以在运行时充分利用缓存
  数据加速运算。

3.2.3 Master&Worker

Spark 集群的独立部署环境中，不需要依赖其他的资源调度框架，自身就实现了资源调
度的功能，所以环境中还有其他两个核心组件：Master 和 Worker，

• 这里的 Master 是一个进
  程，主要负责资源的调度和分配，并进行集群的监控等职责，类似于 Yarn 环境中的 RM,
• 而
  Worker 呢，也是进程，一个 Worker 运行在集群中的一台服务器上，由 Master 分配资源对
  数据进行并行的处理和计算，类似于 Yarn 环境中 NM。

3.2.4 ApplicationMaster

Hadoop 用户向 YARN 集群提交应用程序时,提交程序中应该包含 ApplicationMaster，用
于向资源调度器申请执行任务的资源容器 Container，运行用户自己的程序任务 job，监控整
个任务的执行，跟踪整个任务的状态，处理任务失败等异常情况。

说的简单点就是，ResourceManager（资源）和 Driver（计算）之间的解耦合靠的就是
ApplicationMaster。

3.3 核心概念

3.3.1 Executor与Core

Spark Executor 是集群中运行在工作节点（Worker）中的一个 JVM 进程，是整个集群中
的专门用于计算的节点。在提交应用中，可以提供参数指定计算节点的个数，以及对应的资
源。这里的资源一般指的是工作节点 Executor 的内存大小和使用的虚拟 CPU 核（Core）数
量。

应用程序相关启动参数如下：

--num-executors 配置Executor的数量
--executor-memory  配置每个Executor的内存大小
--executor-cores   配置每个Executor的虚拟CPU core数量

3.3.2 并行度（Parallelism）

在分布式计算框架中一般都是多个任务同时执行，由于任务分布在不同的计算节点进行
计算，所以能够真正地实现多任务并行执行，记住，这里是并行，而不是并发。这里我们将
整个集群并行执行任务的数量称之为并行度。那么一个作业到底并行度是多少呢？这个取决
于框架的默认配置。应用程序也可以在运行过程中动态修改。

并行是同时计算（多个任务多核），并发是多线程（多个任务抢占1个核数）

---

3.4 Spark运行基本流程

Spark的基本运行流程如下：

1. 当一个Spark应用被提交时，首先需要为这个应用构建起基本的运行环境，即由任务控制节点（Driver）创建一个SparkContext，由SparkContext负责和资源管理器（Cluster Manager）的通信以及进行资源的申请、任务的分配和监控等。SparkContext会向资源管理器注册并申请运行Executor的资源；
2. 资源管理器为Executor分配资源，并启动Executor进程，Executor运行情况将随着“心跳”发送到资源管理器上；
3. SparkContext根据RDD的依赖关系构建DAG图，DAG图提交给DAG调度器（DAGScheduler）进行解析，将DAG图分解成多个“阶段”（每个阶段都是一个任务集），并且计算出各个阶段之间的依赖关系，然后把一个个“任务集”提交给底层的任务调度器（TaskScheduler）进行处理；Executor向SparkContext申请任务，任务调度器将任务分发给Executor运行，同时，SparkContext将应用程序代码发放给Executor；
4. 任务在Executor上运行，把执行结果反馈给任务调度器，然后反馈给DAG调度器，运行完毕后写入数据并释放所有资源。
   

3.5 Spark运行模式

Spark 的运行模式有 Local(也称单节点模式），Standalone(集群模式），Spark on Yarn(运行在Yarn上），Mesos以及K8s等常用模式，现在天网在不同的环境使用的模式也不尽相同

• 本地模式：Local（用于天网本地测试环境）
• 集群模式：Standalone，Spark自带的一个资源调度框架，支持完全分布式(用于天网qa环境)
• 集群模式：yarn，运行在yarn资源管理器框架之上，由yarn负责资源管理，Spark负责任务调度和计算
  1. yarn-client模式：driver端启动在本地 (现在天网线上环境使用的模式)
  2. yarn-clust模式：Yarn集群内部的RM(Resource Manager)中

3.6 Spark常用术语

Spark的常用术语

• Application：Spark的应用程序，包含一个Driver program和若干Executor
• SparkContext：Spark应用程序的入口，负责调度各个运算资源，协调各个Worker Node上的Executor
• Driver Program：运行Application的main()函数并且创建SparkContext
• Executor：是为Application运行在Worker node上的一个进程，该进程负责运行Task，并且负责将数据存在内存或者磁盘上。每个Application都会申请各自的Executor来处理任务
• Job：包含多个Task组成的并行计算，一个或多个Stage所组成的一次计算作业
  Stage：每个Job会被拆分很多组Task，作为一个TaskSet
• Task：运行在Executor上的工作单元
• RDD（Resilient distributed datasets）：弹性分布式数据集
• DAGScheduler：负责分析用户提交的应用，并根据计算任务的依赖关系建立DAG，且将DAG划分为不同的Stage，每个Stage可并发执行一组task
• TaskScheduler：将Taskset提交给Worker node集群运行并返回结果

3.7 Yarn-Client模式下的任务提交方式

1.Spark Yarn Client向YARN的ResourceManager申请启动Application Master。同时在SparkContent初始化中将YarnClientClusterScheduler和YarnClientSchedulerBackend；（这里初始化的对象和选择的模式有关）

2.yarn中的ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，启动与drive中的SparkContext进行联系进行资源的调度；

3.Client中的SparkContext初始化完毕后，与ApplicationMaster建立通讯，向ResourceManager注册，根据任务信息向ResourceManager申请资源（Container）；

4.一旦Application Master申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动启动excutor，excutor启动后会向Client中的SparkContext注册并申请Task； 注：在yarn-client模式下可以理解，yarn中Application master节点只是初始化的时候进行yarn中资源的委派，实际运行过程中，还是driver任务中的sparkContext进行实际的任务的分配和执行

5.Client中的SparkContext分配Task给excutor执行，excutor运行Task并向Driver汇报运行的状态和进度，以让Client随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务；

6.应用程序运行完成后，Client的SparkContext向ResourceManager申请注销并关闭自己。（天网的任务在没有干预下不会停止）

第4章 Spark Streaming

Spark Streaming和JStorm的本质区别
实时计算和离线计算对应，是计算的场景，是需求。流计算和批量计算对应是计算的方式。

流计算的本质是：无状态性
批量计算的本质是有状态计算，或者说没有状态性的批量计算根本就是流计算，只是把时间维度的计算变成了空间维度的计算。

存在大量的状态保存的需求，都是需要使用Spark Streaming来计算的。
其实就算使用Spark和Storm的混合架构，数据两次进内存（进程间数据流）也是对网络带宽的浪费，所以如果 在不考虑很高的实时要求的情况下，对于有状态运算的项目完全可以用Spark Streaming取代掉Storm。 对于没有状态的项目，当然可以完全用JStorm了。

Spark Streaming处理结果可以保存到 HDFS、Database、Dashboard

Spark是以线程级别并行，实时响应级别高，可以实现秒级响应、变相实现高效的流计算。
（SparkStreaming把流计算切成一段段，每段都是批处理，达到模仿流计算效果）

Spark 的核心是建立在统一的抽象弹性分布式数据集（Resiliennt Distributed Datasets，RDD）之上的，这使得 Spark 的各个组件可以无缝地进行集成，能够在同一个应用程序中完成大数据处理。

RDD 是 Spark 提供的最重要的抽象概念，它是一种有容错机制的特殊数据集合，可以分布在集群的结点上，以函数式操作集合的方式进行各种并行操作。

通俗点来讲，可以 将 RDD 理解为一个分布式对象集合，本质上是一个只读的分区记录集合。每个 RDD 可以分成多个分区，每个分区就是一个数据集片段。 一个 RDD 的不同分区可以保存到集群中的不同结点上，从而可以在集群中的不同结点上进行并行计算。

SparkStreaming无法实现毫秒级响应，借助Storm实现

Spark 会替代 MR，Spark 存储依赖 HDFS，资源调度依赖 YARN，集群管理依赖 Zookeeper。

之前的方案是通过Hadoop批量处理与Storm实时流计算。 现在直接通过Spark方案

-

第5章 Spark安装

Spark消费 Kafka，分布式的情况下，如何保证消息的顺序?

Kafka 分布式的单位是 Partition。如何保证消息有序，需要分几个情况讨论。

• 同一个 Partition 用一个 write ahead log 组织，所以可以保证 FIFO 的顺序。
• 不同 Partition 之间不能保证顺序。但是绝大多数用户都可以通过 message key 来定义，因为同一个 key 的 message 可以保证只发送到同一个 Partition。比如说 key 是 user id，table row id 等等，所以同一个 user 或者同一个 record 的消息永远只会发送到同一个 Partition上，保证了同一个 user 或 record 的顺序。
• 当然，如果你有 key skewness 就有些麻烦，需要特殊处理。

实际情况中: （1）不关注顺序的业务大量存在；（2）队列无序不代表消息无序。

第（2）条的意思是说:：我们不保证队列的全局有序，但可以保证消息的局部有序。举个例子: 保证来自同1个 order id 的消息，是有序的！

Kafka 中发送1条消息的时候，可以指定(topic, partition, key) 3个参数。partiton 和 key 是可选的。如果你指定了 partition，那就是所有消息发往同1个 partition，就是有序的。并且在消费端，Kafka 保证，1个 partition 只能被1个 consumer 消费。或者你指定 key（比如 order id），具有同1个 key 的所有消息，会发往同1个 partition。也是有序的。

---

yarn模式两种提交任务方式（yarn-client与yarn-cluster）

https://blog.csdn.net/huojiao2006/article/details/80563112

Spark On Yarn 的优势

1. Spark 支持资源动态共享，运行于 Yarn 的框架都共享一个集中配置好的资源池
2. 可以很方便的利用 Yarn 的资源调度特性来做分类·，隔离以及优先级控制负载，拥有更灵活的调度策略
3. Yarn 可以自由地选择 executor 数量
4. Yarn 是唯一支持 Spark 安全的集群管理器，使用 Yarn，Spark 可以运行于 Kerberos Hadoop 之上，在它们进程之间进行安全认证

yarn-client 和 yarn cluster 的异同 ：

1. 从广义上讲，yarn-cluster 适用于生产环境。而 yarn-client 适用于交互和调试，也就是希望快速地看到 application 的输出。
2. 从深层次的含义讲，yarn-cluster 和 yarn-client 模式的区别其实就是 Application Master 进程的区别，yarn-cluster 模式下，driver 运行在 AM(Application Master)中，它负责向 YARN 申请资源，并监督作业的运行状况。当用户提交了作业之后，就可以关掉 Client，作业会继续在 YARN 上运行。然而 yarn-cluster 模式不适合运行交互类型的作业。而 yarn-client 模式下，Application Master 仅仅向 YARN 请求 executor，Client 会和请求的 container 通信来调度他们工作，也就是说 Client 不能离开。