大数据，轻松应对海量数据存储与分析所带来的挑战

文章目录

• ​​一、前言​​
• ​​二、Spark​​
• 2.1 Spark架构
• 2.2 Spark核心组件
• 2.3 Spark编程模型
• 2.4 Spark计算模型
• 2.5 Spark运行流程
• 2.6 Spark RDD流程
• 2.7 Spark RDD

• 
  
• ​​三、Storm​​
• 3.1 Storm集群架构
• 3.2 Storm编程模型
• 3.3 Topology
• 3.4 Storm Streaming Grouping
• 
  
• ​​四、Hbase​​
• 4.1 Hbase

• 4.2 Hbase核心架构
• 4.3 Hbase写入流程
• 4.4 Hbase写入时触发MemStore刷盘的场景
• 4.5 Hbase与Cassandra的区别
• 
  
• ​​五、尾声​​

一、前言 二、Spark

2.1 Spark架构

Spark 提供了一个全面、统一的框架用于管理各种有着不同性质（文本数据、图表数据等）的数据集和数据源（批量数据或实时的流数据）的大数据处理的需求。

Spark 核心架构，如下图所示：

对于上图中重要概念解释：

Spark Core（即上图中第二层Apache Spark）

Spark Core 中包含 Spark 的基本功能，尤其是定义 RDD 的 API、操作以及这两者上的动作，其他 Spark 的库都是构建在 RDD 和 Spark Core 之上的。

注意：RDD,Resilient Distributed DataSet，即弹性分布式数据集。

Spark SQL

提供 HiveQL（一种 Apache Hive 的 SQL 变体 Hive 查询语言）与 Spark 进行交互的 API。每个数据库表被当做一个 RDD，Spark SQL 查询被转换为 Spark 操作。

Spark Streaming

对实时数据流进行处理和控制。Spark Streaming 允许程序能够像普通 RDD 一样处理实时数据。

Mllib（Machine Learning）

一个常用机器学习算法库，算法被实现为对 RDD 的 Spark 操作。这个库包含可扩展的学习算法，比如分类、回归等需要对大量数据集进行迭代的操作。

GraphX

控制图、并行图操作和计算的一组算法和工具的集合。GraphX 扩展了 RDD API，包含控制图、创建子图、访问路径上所有顶点的操作。

2.2 Spark核心组件

Spark 组件交互，如下图所示：

对于上图中重要概念解释：

Cluster Manager

在 standalone 模式中即为 Master 主节点，控制整个集群，监控 worker。

在 YARN 模式中为集群管理器。

Worker Node

作为从节点，负责控制计算节点，启动 Executor 或者 Driver。

Driver

运行 Application 的 main() 函数。

Executor

执行器，是为某个 Application 运行在 worker node 上的一个进程。

2.3 Spark编程模型

Spark编程模型，如下图所示：

Spark 应用程序从编写到提交、执行、输出的整个过程如图所示，图中描述的步骤如下：

(1) 用户使用SparkContext提供的API（常用的有textFile、sequenceFile、runJob、stop等）编写 Driver application 程序。此外 SQLContext、HiveContext 及 StreamingContext 对SparkContext 进行封装，并提供了 SQL、Hive 及流式计算相关的 API。

(2) 使用SparkContext提交的用户应用程序，首先会使用BlockManager和BroadcastManager 将任务的 Hadoop 配置进行广播。然后由 DAGScheduler 将任务转换为 RDD 并组织成 DAG，DAG 还将被划分为不同的 Stage。最后由 TaskScheduler 借助 ActorSystem 将任务提交给集群管理器（Cluster Manager）。

(3) 集群管理器（ClusterManager）给任务分配资源，即将具体任务分配到Worker上，Worker创建 Executor 来处理任务的运行，运行结果保存到Store存储中。Standalone、YARN、Mesos、EC2 等都可以作为 Spark的集群管理器；HDFS、Amzon、S3、Tachyon等都可以作为Store存储。

2.4 Spark计算模型

Spark计算模型运作图，如下所示：

上图中，RDD 英文全称 Resiliennt Distributed Datasets，译为 弹性分布式数据集 ，可以看做是对各种数据计算模型的统一抽象，Spark 的计算过程主要是 RDD 的迭代计算过程。RDD 的迭代计算过程非常类似于管道，即上图中每一个分区（从分区1到分区N）可以看做是一个管道。分区数量取决于 partition 数量的设定，每个分区的数据只会在一个 Task 中计算。所有分区可以在多个机器节点的 Executor 上并行执行。

2.5 Spark运行流程

Spark运行流程图，如下图所示：

对于上图的解释：

(1) 构建 Spark Application 的运行环境，启动 SparkContext。

(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 上运行，运行完释放所有资源。

2.6 Spark RDD流程

Spark RDD流程图，如下所示：

对于上图的解释：

(1) 创建 RDD 对象。

(2) DAGScheduler 模块介入运算，计算 RDD 之间的依赖关系，RDD 之间的依赖关系就形成了DAG。

(3) 每一个 Job 被分为多个 Stage。划分 Stage 的一个主要依据是当前计算因子的输入是否是确定的，如果是则将其分在同一个 Stage，避免多个 Stage 之间的消息传递开销。

2.7 Spark RDD

2.7.1 RDD 的创建方式

(1) 从Hadoop文件系统（或与Hadoop兼容的其他持久化存储系统，如Hive、Cassandra、HBase）输入（例如 HDFS）创建。

(2) 从父 RDD 转换得到新 RDD。

(3) 通过 parallelize 或 makeRDD 将单机数据创建为分布式 RDD。

2.7.2 RDD的两种操作算子(转换(Transformation)与行动(Action))

对于 RDD 可以有两种操作算子：转换（Transformation）与行动（Action）。

转换（Transformation）：Transformation操作是延迟计算的，也就是说从一个RDD转换生成另一个 RDD 的转换操作不是马上执行，需要等到有 Action 操作的时候才会真正触发运算。

行动（Action）：Action 算子会触发 Spark 提交作业（Job），并将数据输出 Spark 系统。

三、Storm

3.1 Storm集群架构

Storm 是一个免费并开源的分布式实时计算系统。利用 Storm 可以很容易做到可靠地处理无限的数据流，像 Hadoop 批量处理大数据一样，Storm 可以实时处理数据。Storm集群架构，如下图所示：

对于上图的解释：

1、Nimbus （作为master，职能：将代码分发给Supervisor）

Storm 集群的 Master 节点，负责分发用户代码，指派给具体的 Supervisor 节点上的 Worker 节点，去运行 Topology 对应的组件（Spout/Bolt）的 Task。

2、Supervisor （作为slave，职能：管理 Worker进程的启动和终止 ）

Storm 集群的从节点，负责管理运行在 Supervisor 节点上的每一个 Worker 进程的启动和终止。通过 Storm 的配置文件中的 supervisor.slots.ports 配置项，可以指定在一个 Supervisor 上最大允许多少个 Slot，每个 Slot 通过端口号来唯一标识，一个端口号对应一个 Worker 进程（如果该Worker 进程被启动）。

3、Worker （ 具体处理组件逻辑的进程 ）

运行具体处理组件逻辑的进程。Worker 运行的任务类型只有两种，一种是 Spout 任务，一种是Bolt 任务。

4、Task

worker中每一个spout/bolt的线程称为一个task. 在storm0.8之后，task不再与物理线程对应，不同 spout/bolt 的 task 可能会共享一个物理线程，该线程称为 executor。

5、ZooKeeper

用来协调 Nimbus 和 Supervisor，如果 Supervisor 因故障出现问题而无法运行 Topology，Nimbus 会第一时间感知到，并重新分配 Topology 到其它可用的 Supervisor 上运行。

3.2 Storm编程模型

strom 在运行中可分为 spout 与 bolt 两个组件，其中，数据源从 spout 开始，数据以 tuple 的方式发送到 bolt，多个 bolt 可以串连起来，一个 bolt 也可以接入多个 spot/bolt。整个运行时原理如下图：

对上图主要概念的解释：

1、Topology

Storm 中运行的一个实时应用程序的名称。将 Spout、 Bolt 整合起来的拓扑图。定义了 Spout 和Bolt 的结合关系、并发数量、配置等等。

2、Spout

在一个 topology 中获取源数据流的组件。通常情况下 spout 会从外部数据源中读取数据，然后转换为 topology 内部的源数据。

3、Bolt

接受数据然后执行处理的组件,用户可以在其中执行自己想要的操作。

4、Tuple

一次消息传递的基本单元，理解为一组消息就是一个 Tuple。

5、Stream

Tuple 的集合。表示数据的流向。

3.3 Topology

在 Storm 中,一个实时应用的计算任务被打包作为 Topology 发布，这同 Hadoop MapReduce 任务相似。但是有一点不同的是：在 Hadoop 中，MapReduce 任务最终会执行完成后结束；而在Storm 中，Topology 任务一旦提交后永远不会结束，除非你显示去停止任务。计算任务Topology 是由不同的 Spouts 和 Bolts，通过数据流（Stream）连接起来的图｡一个 Storm 在集群上运行一个 Topology 时，主要通过以下 3 个实体来完成 Topology 的执行工作：

(1). Worker （进程）

(2). Executor （线程）

(3). Task

1、Worker( 1 个 worker 进程执行的是 1 个 topology 的子集 )

1 个 worker 进程执行的是 1 个 topology 的子集（注：不会出现 1 个 worker 为多个 topology服务）。1 个 worker 进程会启动 1 个或多个 executor 线程来执行 1 个 topology 的component(spout 或 bolt)。因此，1 个运行中的 topology 就是由集群中多台物理机上的多个worker 进程组成的。

2、Executor( executor 是 1 个被 worker 进程启动的单独线程 )

Executor 是 1 个被 worker 进程启动的单独线程。每个 executor 只会运行 1 个 topology 的 1 个component(spout 或 bolt)的 task（注：task 可以是 1 个或多个，storm 默认是 1 个component 只生成 1 个 task，executor 线程里会在每次循环里顺序调用所有 task 实例）。

3、Task( 最终运行 spout 或 bolt 中代码的单元 )

Task是最终运行 spout 或 bolt 中代码的单元（注：1 个 task 即为 spout 或 bolt 的 1 个实例，executor 线程在执行期间会调用该 task 的 nextTuple 或 execute 方法）。topology 启动后，1个 component(spout 或 bolt)的 task 数目是固定不变的，但该 component 使用的 executor 线程数可以动态调整（例如：1 个 executor 线程可以执行该 component 的 1 个或多个 task 实例）。这意味着，对于 1 个 component 存在这样的条件#threads<=#tasks（即：线程数小于等于 task 数目）。默认情况下 task 的数目等于 executor 线程数目，即 1 个 executor 线程只运行 1 个 task。

3.4 Storm Streaming Grouping

Stream grouping 是 Storm 中最重要的抽象了，它能够控制 Spot/Bolt 对应的 Task 以什么样的方式来分发 Tuple，将 Tuple 发射到目的 Spot/Bolt 对应的 Task。

目前，Storm Streaming Grouping 支持如下几种类型：

1、huffle Grouping

随机分组，尽量均匀分布到下游 Bolt 中将流分组定义为混排。这种混排分组意味着来自 Spout 的输入将混排，或随机分发给此 Bolt 中的任务。shuffle grouping 对各个 task 的 tuple 分配的比较均匀。

2、Fields Grouping

按字段分组，按数据中 field 值进行分组；相同 field 值的 Tuple 被发送到相同的 Task 这种grouping 机制保证相同 field 值的 tuple 会去同一个 task。

3、All grouping ：广播

广播发送， 对于每一个 tuple 将会复制到每一个 bolt 中处理。

4、Global grouping

全局分组，Tuple 被分配到一个 Bolt 中的一个 Task，实现事务性的 Topology。Stream 中的所有的 tuple 都会发送给同一个 bolt 任务处理，所有的 tuple 将会发送给拥有最小 task_id 的 bolt任务处理。

5、None grouping ：不分组

不关注并行处理负载均衡策略时使用该方式，目前等同于 shuffle grouping,另外 storm 将会把bolt 任务和他的上游提供数据的任务安排在同一个线程下。

6、Direct grouping ：直接分组 指定分组

由 tuple 的发射单元直接决定 tuple 将发射给那个 bolt，一般情况下是由接收 tuple 的 bolt 决定接收哪个 bolt 发射的 Tuple。这是一种比较特别的分组方法，用这种分组意味着消息的发送者指定由消息接收者的哪个 task 处理这个消息。 只有被声明为 Direct Stream 的消息流可以声明这种分组方法。而且这种消息 tuple 必须使用 emitDirect 方法来发射。消息处理者可以通过TopologyContext 来获取处理它的消息的 taskid (OutputCollector.emit 方法也会返回taskid)。

四、Hbase

4.1 Hbase

4.1.1 Hbase 是一个通过大量廉价的机器解决海量数据的高速存储和读取的分布式数据库解决方案

Hbase 是分布式、面向列的开源数据库（其实准确的说是面向列族）。HDFS 为 Hbase 提供可靠的底层数据存储服务，MapReduce 为 Hbase 提供高性能的计算能力，Zookeeper 为 Hbase 提供稳定服务和 Failover 机制，因此我们说 Hbase 是一个通过大量廉价的机器解决海量数据的高速存储和读取的分布式数据库解决方案。

4.1.2 Hbase的列式存储

Hbase采用列式存储，列方式所带来的重要好处之一就是，由于查询中的选择规则是通过列来定义的，因此整个数据库是自动索引化的。

这里的列式存储其实说的是列族存储，Hbase 是根据列族来存储数据的。列族下面可以有非常多的列，列族在创建表的时候就必须指定。为了加深对 Hbase 列族的理解，下面是一个简单的关系型数据库的表和 Hbase 数据库的表：

4.1.3 Hbase的核心概念

1、Column Family 列族

Column Family 又叫列族，Hbase 通过列族划分数据的存储，列族下面可以包含任意多的列，实现灵活的数据存取。Hbase 表的创建的时候就必须指定列族。就像关系型数据库创建的时候必须指定具体的列是一样的。Hbase的列族不是越多越好，官方推荐的是列族最好小于或者等于3。我们使用的场景一般是 1 个列族。

2、Rowkey（ Rowkey 查询，Rowkey 范围扫描，全表扫描 ）

Rowkey 的概念和 mysql 中的主键是完全一样的，Hbase 使用 Rowkey 来唯一的区分某一行的数据。Hbase 只支持 3 中查询方式：基于 Rowkey 的单行查询，基于 Rowkey 的范围扫描，全表扫描。

3、Region 分区

Region：Region 的概念和关系型数据库的分区或者分片差不多。Hbase 会将一个大表的数据基于 Rowkey 的不同范围分配到不通的 Region 中，每个 Region 负责一定范围的数据访问和存储。这样即使是一张巨大的表，由于被切割到不通的 region，访问起来的时延也很低。

4、TimeStamp 多版本

TimeStamp 是实现 Hbase 多版本的关键。在 Hbase 中使用不同的 timestame 来标识相同 rowkey 行对应的不通版本的数据。在写入数据的时候，如果用户没有指定对应的timestamp，Hbase 会自动添加一个 timestamp，timestamp 和服务器时间保持一致。在

Hbase 中，相同 rowkey 的数据按照 timestamp 倒序排列。默认查询的是最新的版本，用户可同指定 timestamp 的值来读取旧版本的数据。

4.2 Hbase核心架构

Hbase 是由 Client、Zookeeper、HMaster、HRegionServer、HDFS 等几个组建组成。Hbase 架构如下图所示：

1、Hbase组件：Client

Client 包含了访问 Hbase 的接口，另外 Client 还维护了对应的 cache 来加速 Hbase 的

访问，比如 cache 的.META.元数据的信息。

2、Hbase组件：Zookeeper

Hbase 通过 Zookeeper 来做 master 的高可用、RegionServer 的监控、元数据的入口

以及集群配置的维护等工作。具体工作如下：

2. 通过 Zoopkeeper 来保证集群中只有 1 个 master 在运行，如果 master 异
   常，会通过竞争机制产生新的 master 提供服务
3. 通过 Zoopkeeper 来监控 RegionServer 的状态，当 RegionSevrer 有异常的
   时候，通过回调的形式通知 Master RegionServer 上下限的信息
4. 通过 Zoopkeeper 存储元数据的统一入口地址。

3、Hbase组件：HMaster

HMaster 节点的主要职责如下：

2. 为 RegionServer 分配 Region
3. 维护整个集群的负载均衡
4. 维护集群的元数据信息发现失效的 Region，并将失效的 Region 分配到正常RegionServer 上当 RegionSever 失效的时候，协调对应 Hlog 的拆分。

4、Hbase组件：HRegionServer

HRegionServer 直接对接用户的读写请求，是真正的“干活”的节点。它的功能概括如下：

2. 管理 master 为其分配的 Region
3. 处理来自客户端的读写请求
4. 负责和底层 HDFS 的交互，存储数据到 HDFS
5. 负责 Region 变大以后的拆分
6. 负责 Storefile 的合并工作

5、Hbase组件：HDFS

HDFS 为 Hbase 提供最终的底层数据存储服务，同时为 Hbase 提供高可用（Hlog 存储在

HDFS）的支持。

6、Region 寻址方式（通过 zookeeper .META）

Region 寻址方式，如下图所示：

第 1 步：Client 请求 ZK 获取.META.所在的 RegionServer 的地址。

第 2 步：Client 请求.META.所在的 RegionServer 获取访问数据所在的 RegionServer 地

址，client 会将.META.的相关信息 cache 下来，以便下一次快速访问。

第 3 步：Client 请求数据所在的 RegionServer，获取所需要的数据。

4.3 Hbase写入流程

Hbase 写入流程，如下图所示：

从上图可以看出氛围 3 步骤：

步骤1：获取 RegionServer

Client 获取数据写入的 Region 所在的 RegionServer。

步骤2：请求写 Hlog

请求写 Hlog, Hlog 存储在 HDFS，当 RegionServer 出现异常，需要使用 Hlog 来恢复数据。

步骤3：请求写 MemStore

请求写 MemStore,只有当写 Hlog 和写 MemStore 都成功了才算请求写入完成。MemStore 后续会逐渐刷到 HDFS 中。

4.4 Hbase写入时触发MemStore刷盘的场景

为了提高 Hbase 的写入性能，当写请求写入 MemStore 后，不会立即刷盘。而是会等到一定的时候进行刷盘的操作，总结成如下的几个场景：

1、全局内存控制

这个全局的参数是控制内存整体的使用情况，当所有 memstore 占整个 heap 的最大比

例的时候，会触发刷盘的操作。这个参数是hbase.regionserver.global.memstore.upperLimit，默认为整个 heap 内存的 40%。但这并不意味着全局内存触发的刷盘操作会将所有的 MemStore 都进行输盘，而是通过另外一个参数 hbase.regionserver.global.memstore.lowerLimit 来控制，默认是整个heap 内存的 35%。当 flush 到所有 memstore 占整个 heap 内存的比率为 35%的时候，就停止刷盘。这么做主要是为了减少刷盘对业务带来的影响，实现平滑系统负载的目的。

2、MemStore 达到上限

当 MemStore 的大小达到 hbase.hregion.memstore.flush.size 大小的时候会触发刷

盘，默认 128M 大小。

3、RegionServer 的 Hlog 数量达到上限

前面说到 Hlog 为了保证 Hbase 数据的一致性，那么如果 Hlog 太多的话，会导致故障恢复的时间太长，因此 Hbase 会对 Hlog 的最大个数做限制。当达到 Hlog 的最大个数的时候，会强制刷盘。这个参数是 hase.regionserver.max.logs，默认是 32 个。

4、手工触发

可以通过 hbase shell 或者 java api 手工触发 flush 的操作。

5、关闭 RegionServer 触发

在正常关闭 RegionServer 会触发刷盘的操作，全部数据刷盘后就不需要再使用 Hlog 恢

复数据。

6、Region 使用 HLOG 恢复完数据后触发

当 RegionServer 出现故障的时候，其上面的 Region 会迁移到其他正常的RegionServer 上，在恢复完 Region 的数据后，会触发刷盘，当刷盘完成后才会提供给业务访问。

---

4.5 Hbase与Cassandra的区别

一表小结（HBase vs Cassandra）：

	HBase	Cassandra
语言	Java	Java
出发点	BigTable	BigTable and Dynamo
License	Apache	Apache
Protocol	HTTP/REST (also Thrift)	Custom, binary (Thrift)
数据分布	表划分为多个 region 存在不同 region server 上	改进的一致性哈希（虚拟节点）
存储目标	大文件	小文件
一致性	强一致性	最终一致性，Quorum NRW 策略
架构	master/slave	p2p
高可用性	NameNode 是 HDFS 的单点故障点	P2P 和去中心化设计，不会出现单点故障
伸缩性	Region Server 扩容，通过将自身发布到Master，Master 均匀分布 Region	扩容需在 Hash Ring 上多个节点间调整数据分布
读写性能	数据读写定位可能要通过最多 6 次的网络 RPC，性能较低。	数据读写定位非常快
数据冲突处理	乐观并发控制（optimistic concurrencycontrol）	向量时钟
临时故障处理	Region Server 宕机，重做 HLog	数据回传机制：某节点宕机，hash 到该节点的新数据自动路由到下一节点做 hinted handoff，源节点恢复后，推送回源节点。
永久故障恢复	Region Server 恢复，master 重新给其分配 region	Merkle 哈希树，通过 Gossip 协议同步 Merkle Tree，维护集群节点间的数据一致性
成员通信及错误检测	Zookeeper	基于 Gossip
CAP	1，强一致性，0 数据丢失。2，可用性低。3，扩容方便。	1，弱一致性，数据可能丢失。2，可用性高。3，扩容方便。

五、尾声

大数据，轻松应对海量数据存储与分析所带来的挑战，完成了。

天天打码，天天进步！！