Spark 的容错机制：保障数据处理的稳定性与高效性

标签：缓存 False 容错 RDD 内存高效性 Spark True StorageLevel

在大数据处理领域，Spark 作为一款强大的分布式计算框架，面临着数据丢失和性能优化的双重挑战。为了确保数据的安全性和处理效率，Spark 构建了一套完善的容错机制。本文将深入探讨 Spark 的容错机制，包括 RDD 的持久化机制（persist 和 cache 算子）以及检查点机制（checkpoint），并分析它们的特点、适用场景以及相互之间的区别。

一、Spark 容错机制概述

1、各个软件为了防止数据丢失的解决方案

操作日志：

将内存变化操作日志追加记录在一个文件中，下一次读取文件对内存重新操作
- NAMENODE：元数据的操作日志记录在edits
- MySQL：日志记录binlog ()

副本机制：

将数据构建多份冗余副本
- HDFS：构建每个数据块的3个副本

依赖关系：

每份数据保留与其他数据之间的一个转换关系
- RDD：保留RDD与其他RDD之间的依赖关系

2、Spark如何保障数据的安全

每个RDD在构建数据时，会根据自己来源一步步导到数据来源，然后再一步步开始构建RDD数据。

问题：如果一个RDD被触发多次，这个RDD就会按照依赖关系被构建多次，性能相对较差，怎么解决？

例如：日志分析的时候，三个问题，tupleRdd 之前的所有操作都要执行三次，每次读取100M多的数据，效率非常的低

第一次：一定会通过血脉构建这个RDD的数据
希望从第二次开始，就不要重复构建，直接使用第一个构建的内容
实现：Spark持久化机制：主动将RDD进行保存，供多次使用，避免重复构建

二、RDD 持久化机制

（一）cache 算子

功能：将 RDD 缓存在内存中，以便后续多次使用时无需重新计算。
语法：cache()。
本质：底层实际调用的是 persist(StorageLevel.MEMORY_ONLY)，即只尝试将 RDD 缓存在内存。但如果内存资源不足，缓存操作可能会失败。
场景：适用于资源充足且确定 RDD 只需在内存中缓存的情况，例如对于一些频繁使用且数据量较小能够完全容纳在内存中的 RDD，可以使用 cache 算子提高数据读取速度。

（二）persist 算子

功能：能够将 RDD（包含其依赖关系）进行缓存，并且可以根据需求自行指定缓存的级别，这是它与 cache 算子的主要区别。
语法：persist(StorageLevel)。
级别：
- 将 RDD 缓存在磁盘中：
  - StorageLevel.DISK_ONLY = StorageLevel(True, False, False, False)：将庞大且暂时不急需使用的 RDD 放入磁盘，释放 Executor 内存。
  - StorageLevel.DISK_ONLY_2 = StorageLevel(True, False, False, False, 2)：在磁盘中多存储一个缓存副本，提高数据的冗余性和可用性。
  - StorageLevel.DISK_ONLY_3 = StorageLevel(True, False, False, False, 3)：类似地，存储三个副本。
```
StorageLevel.DISK_ONLY = StorageLevel(True, False, False, False)
StorageLevel.DISK_ONLY_2 = StorageLevel(True, False, False, False, 2)
StorageLevel.DISK_ONLY_3 = StorageLevel(True, False, False, False, 3)
```
- 将 RDD 缓存在内存中：
  - StorageLevel.MEMORY_ONLY = StorageLevel(False, True, False, False)：仅使用内存进行缓存，常用于高频使用且数据量不大能适应内存容量的 RDD。
  - StorageLevel.MEMORY_ONLY_2 = StorageLevel(False, True, False, False, 2)：增加一个内存缓存副本。
```
StorageLevel.MEMORY_ONLY = StorageLevel(False, True, False, False)
StorageLevel.MEMORY_ONLY_2 = StorageLevel(False, True, False, False, 2)
```
- 将 RDD 优先缓存在内存中，如果内存不足，就缓存在磁盘中：
  - StorageLevel.MEMORY_AND_DISK = StorageLevel(True, True, False, False)：对于高频使用的大 RDD 较为合适，先利用内存缓存，当内存空间不足时，自动将多余数据溢出到磁盘。
  - StorageLevel.MEMORY_AND_DISK_2 = StorageLevel(True, True, False, False, 2)：多一个缓存副本。
```
StorageLevel.MEMORY_AND_DISK = StorageLevel(True, True, False, False)
StorageLevel.MEMORY_AND_DISK_2 = StorageLevel(True, True, False, False, 2)
```
- 使用堆外内存：StorageLevel.OFF_HEAP = StorageLevel(True, True, True, False, 1)：提供了除内存和磁盘之外的存储选择，可利用堆外内存资源。
```
StorageLevel.OFF_HEAP = StorageLevel(True, True, True, False, 1)
```
- 使用序列化：StorageLevel.MEMORY_AND_DISK_DESER = StorageLevel(True, True, False, True)：在内存和磁盘缓存时采用序列化方式，有助于减少内存占用，但在读取时需要进行反序列化操作，会有一定性能开销。
```
StorageLevel.MEMORY_AND_DISK_DESER = StorageLevel(True, True, False, True)
```
场景：根据实际的资源状况，灵活地将 RDD 缓存在不同的存储介质中或者设置多个缓存副本，以平衡内存使用、数据读取速度和数据安全性。例如在内存和磁盘资源都较为充裕但内存使用较为紧张的情况下，可以选择 MEMORY_AND_DISK 级别进行缓存，既能保证数据的快速读取，又能在内存不足时利用磁盘空间。

总结：Spark的StorageLevel共有9个缓存级别

DISK_ONLY：缓存入硬盘。这个级别主要是讲那些庞大的Rdd，之后仍需使用但暂时不用的，放进磁盘，腾出Executor内存。
DISK_ONLY_2：多一个缓存副本。
MEMORY_ONLY：只使用内存进行缓存。这个级别最为常用，对于马上用到的高频rdd，推荐使用。
MEMORY_ONLY_2：多一个缓存副本。
MEMORY_AND_DISK：先使用内存，多出来的溢出到磁盘，对于高频的大rdd可以使用。
MEMORY_AND_DISK_2：多一个缓存副本。
OFF_HEAP：除了内存、磁盘，还可以存储在OFF_HEAP

常用的：

项目中经常使用

MEMORY_AND_DISK_2

MEMORY_AND_DISK_DESER

（三）unpersist 算子

功能：释放已缓存的 RDD，回收缓存占用的资源。
语法：unpersist，还可以使用 unpersist(blocking=True)，表示等待 RDD 释放完资源后再继续执行下一步操作。
场景：当确定某个 RDD 不再被使用，且后续还有大量代码需要执行时，及时调用 unpersist 算子将其数据从缓存中释放，避免资源的浪费。需要注意的是，如果不手动释放缓存，在 Spark 程序结束时，系统也会自动清理该程序中的所有缓存内存。

（四）示例代码分析

以下是一个简单的 Spark 程序示例，展示了如何使用 cache 、 persist 和 unpersist 算子：

import os
import time

# 导入pyspark模块
from pyspark import SparkContext, SparkConf
from pyspark.storagelevel import StorageLevel

if __name__ == '__main__':
    # 配置环境
    os.environ['JAVA_HOME'] = 'C:/Program Files/Java/jdk1.8.0_241'
    # 配置Hadoop的路径，就是前面解压的那个路径
    os.environ['HADOOP_HOME'] = 'D:/hadoop-3.3.1'
    # 配置base环境Python解析器的路径
    os.environ['PYSPARK_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'  # 配置base环境Python解析器的路径
    os.environ['PYSPARK_DRIVER_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'

    # 获取 conf 对象
    # setMaster  按照什么模式运行，local  bigdata01:7077  yarn
    #  local[2]  使用2核CPU   * 你本地资源有多少核就用多少核
    #  appName 任务的名字
    conf = SparkConf().setMaster("local[*]").setAppName("spark的持久化机制")
    # 假如我想设置压缩
    # conf.set("spark.eventLog.compression.codec","snappy")
    # 根据配置文件，得到一个SC对象，第一个conf 是 形参的名字，第二个conf 是实参的名字
    sc = SparkContext(conf=conf)
    print(sc)

    fileRdd = sc.textFile("../resources/1.dat")
    # cache 是转换算子
    #cacheRdd = fileRdd.cache()
    cacheRdd = fileRdd.persist(StorageLevel.MEMORY_AND_DISK_2)
    print(type(cacheRdd))

    cacheRdd.foreach(lambda x: print(x))

    time.sleep(20)

    cacheRdd.unpersist(blocking=True)

    time.sleep(10)

    # 使用完后，记得关闭
    sc.stop()

# unpersist(blocking=True)：等RDD释放完再继续下一步
# blocking = True：阻塞

在上述代码中，首先配置了 Spark 运行所需的环境变量，然后创建了 SparkConf 和 SparkContext 对象。通过 textFile 方法读取文本文件创建了 fileRdd，接着使用 persist 算子将其缓存到内存和磁盘，并设置了两个副本。之后对缓存的 cacheRdd 进行了遍历操作，模拟了对 RDD 的使用。在暂停 20 秒后，调用 unpersist 算子释放缓存，最后关闭 SparkContext。

三、RDD 检查点机制

（一）功能与原理

功能：将 RDD 的数据（不包含 RDD 依赖关系）存储在可靠的存储系统（如 HDFS）中。可以将其类比为虚拟机中的快照，作为数据处理过程中的一个重要里程碑。
设置与使用：
- 首先需要设置一个检查点目录，例如：sc.setCheckpointDir("../datas/chk/chk1")。
- 然后对需要设置检查点的 RDD 调用 checkpoint() 方法，如：rs_rdd.checkpoint()。需要注意的是，一定要在触发该 RDD 的算子之前调用 checkpoint() 方法，否则检查点中可能没有数据。
注意事项：启用检查点机制后，在代码执行过程中会专门多一个 job，用于将 RDD 数据持久化存储到 HDFS 中。

（二）适用场景

适用于对 RDD 数据安全性要求极高，但对性能要求相对不那么苛刻的场景。例如在一些数据处理任务中，数据的准确性和完整性至关重要，不容许因为任何故障导致数据丢失或错误，即使这可能会带来一定的性能开销，如在金融数据处理、关键业务数据分析等领域。

四、RDD 的 cache、persist 持久化机制和 checkpoint 检查点机制的区别

存储位置：
- persist：可以将 RDD 缓存在内存或者磁盘中，根据指定的缓存级别灵活选择存储介质。
- checkpoint：将 RDD 的数据存储在文件系统磁盘（通常是 HDFS）中，提供更可靠的持久化存储。
生命周期：
- persist：当代码中遇到了 unpersist 算子调用或者整个 Spark 程序结束时，缓存会被自动清理，释放资源。
- checkpoint：检查点的数据不会被自动清理，需要手动删除，这使得数据在长时间内都能保持可用状态，有利于数据的长期保存和回溯。
存储内容：
- persist：会保留 RDD 的血脉关系，即与其他 RDD 的依赖关系。这样在缓存丢失时，可以依据依赖关系重新构建 RDD，恢复数据。
- checkpoint：会斩断 RDD 的血脉关系，仅存储 RDD 的数据本身。这意味着一旦检查点数据可用，就不再依赖之前的 RDD 依赖链，简化了数据恢复过程，但也失去了基于依赖关系的灵活重建能力。

五、将日志分析案例进行优化

对前文的一个案例进行优化

import os
import re

# 导入pyspark模块
from pyspark import SparkContext, SparkConf
import jieba
from pyspark.storagelevel import StorageLevel

if __name__ == '__main__':
	# 配置环境
	os.environ['JAVA_HOME'] = 'D:/Program Files/Java/jdk1.8.0_271'
	# 配置Hadoop的路径，就是前面解压的那个路径
	os.environ['HADOOP_HOME'] = 'D:/hadoop-3.3.1/hadoop-3.3.1'
	# 配置base环境Python解析器的路径
	os.environ['PYSPARK_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'  # 配置base环境Python解析器的路径
	os.environ['PYSPARK_DRIVER_PYTHON'] = 'C:/ProgramData/Miniconda3/python.exe'

	# 获取 conf 对象
	# setMaster  按照什么模式运行，local  bigdata01:7077  yarn
	#  local[2]  使用2核CPU   * 你本地资源有多少核就用多少核
	#  appName 任务的名字
	conf = SparkConf().setMaster("local[*]").setAppName("第一个Spark程序")
	# 假如我想设置压缩
	# conf.set("spark.eventLog.compression.codec","snappy")
	# 根据配置文件，得到一个SC对象，第一个conf 是 形参的名字，第二个conf 是实参的名字
	sc = SparkContext(conf=conf)

	fileRdd = sc.textFile("../datas/sogou.tsv")
	print(fileRdd.count())
	print(fileRdd.first())
	listRdd = fileRdd.map(lambda line: re.split("\\s+", line))
	filterList = listRdd.filter(lambda l1: len(l1) == 6)
	# 这个结果只获取而来时间 uid 以及热词，热词将左右两边的[] 去掉了
	tupleRdd = filterList.map(lambda l1: (l1[0], l1[1], l1[2][1:-1]))
	# 将tupleRdd 缓存到内存中
	tupleRdd.cache()
	#tupleRdd.persist(storageLevel=StorageLevel.MEMORY_AND_DISK)

	# 求热词
	wordRdd = tupleRdd.flatMap(lambda t1: jieba.cut_for_search(t1[2]))
	filterRdd2 = wordRdd.filter(lambda word: len(word.strip()) != 0 and word != "的").filter(
		lambda word: re.fullmatch("[\u4e00-\u9fa5]+", word) is not None)
	# filterRdd2.foreach(print)
	result = filterRdd2.map(lambda word: (word, 1)).reduceByKey(lambda sum, num: sum + num).sortBy(
		keyfunc=lambda tup: tup[1], ascending=False).take(10)

	for ele in result:
		print(ele)


	# 第二问：  (（uid,"功夫")  10)
	# [(time,uid,"中华人民"),()]
	def splitWord(tupl):
		li1 = jieba.cut_for_search(tupl[2]) # 中国 中华 共和国
		li2 = list()
		for word in li1:
			li2.append(((tupl[1], word),1))
		return li2
	newRdd = tupleRdd.flatMap(splitWord)
	#newRdd.foreach(print)
	reduceByUIDAndWordRdd = newRdd.reduceByKey(lambda sum,num : sum + num)
	# reduceByUIDAndWordRdd.foreach(print)

	valList =reduceByUIDAndWordRdd.values()
	
	print(valList.max())
	print(valList.min())
	print(valList.mean()) # 中位数
	print(valList.sum() / valList.count()) #

	# 第三问 统计一天每小时点击量并按照点击量降序排序
	reductByKeyRDD = tupleRdd.map(lambda tup: (tup[0][0:2],1)).reduceByKey(lambda sum,num : sum + num)
	sortRdd = reductByKeyRDD.sortBy(keyfunc=lambda tup:tup[1],ascending=False)
	listNum = sortRdd.take(24)
	for ele in listNum:
		print(ele)

	tupleRdd.unpersist(blocking=True)
	# 使用完后，记得关闭
	sc.stop()

将任务运行，运行过程中，发现内存中存储了50M的缓存数据

适用场景：RDD需要多次使用，或者RDD是经过非常复杂的转换过程所构建。

一般缓存的RDD都是经过过滤，经过转换之后重复利用的rdd,可以添加缓存，否则不要加。

六、总结

Spark 的容错机制通过多种方式保障了数据处理的稳定性和高效性。RDD 的持久化机制（包括 cache 和 persist 算子）为频繁使用的 RDD 提供了灵活的缓存策略，能够有效减少重复计算，提高处理效率。而检查点机制则侧重于数据的高安全性存储，在面对可能的缓存丢失或系统故障时，确保数据的完整性和可用性。在实际应用中，需要根据数据处理任务的特点、资源状况以及对数据安全性和性能的要求，合理选择使用持久化机制和检查点机制，以充分发挥 Spark 框架的优势，构建可靠高效的大数据处理应用。

标签：缓存,False,容错,RDD,内存,高效性,Spark,True,StorageLevel
From： https://blog.csdn.net/weixin_64726356/article/details/143671973