Spark基础

最新推荐文章于 2024-06-16 23:15:39 发布

Niko227

最新推荐文章于 2024-06-16 23:15:39 发布

阅读量483

点赞数

分类专栏： pyspark 文章标签： python spark 大数据

本文链接：https://blog.youkuaiyun.com/niko_csdn/article/details/123874521

版权

pyspark 专栏收录该内容

1 篇文章

订阅专栏

Spark基础

1 什么是Spark
- 1.1 Spark 的特点
- 1.2 Spark 快的原因（对比MR）
2 什么是 RDD
- 2.1 RDD 的五大特性
- 2.2 RDD 的五大特点
3 构建RDD
- 3.1 并行化方式来构建RDD
- 3.2 通过读取外部数据方式构建RDD
4 RDD 算子
- 4.1 Transformation 特点: 延迟加载
- 4.2 Action 特点: 立即运行

1 什么是Spark

官网：http://spark.apache.org
Spark 3.1.2: https://spark.apache.org/docs/3.1.2/rdd-programming-guide.html
定义：Apache Spark 是用于大规模（large-scala-data）处理的统一（unified）分析引擎。
解读：Spark是一款用于处理大规模数据的分布式计算引擎, 基于内存计算, 整个spark的核心数据结构RDD(弹性的分布式数据集 Resilient Distributed Datasets)

1.1 Spark 的特点

运行速度快
① 基于内存计算的采用DAG 有向无环图进行计算操作中间的结果是保存在内存中
② spark是基于线程来运行的, 线程的启动和销毁要高于进程
易用性
① spark提供多种语言的客户端, 可以基于多种语言实现，如 python SQL scala java R …
② spark提供了高阶的API, 而且这些API在不同的语言上, 基本上都是一样的, 降低学习成本
通用型强
① spark提供了多种工具库, 用于满足各种计算的场景
② spark core: spark的核心库, 次重点, 它是学习的基础，主要是用于放置spark的核心API, 内存管理API,包括维护RDD的数据结构
③ spark SQL: 通过SQL操作spark计算框架最为重要的
④ spark streaming: spark的流式处理, 主要是用于支持流式计算(实时计算)
⑤ spark MLlib: spark的机器学习库, 主要包括相关算法: 回归聚类 …
⑥ spark graphX: spark的图计算库比如导航行程规划
随处运行
① 编写的spark程序可以运行在不同的资源调度平台: local、yarn平台、spark集群、云上的调度平台
② spark程序可以和大数据生态圈中各种软件进行集成, 更加方便使用spark对接各个软件

1.2 Spark 快的原因（对比MR）

原因一: spark 提供了一个全新的数据结构: RDD
通过这个数据结构, 让分布式执行引擎能够在内存中进行计算, 同时能够更好的进行迭代计算操作
对于MR来说, 主要是基于磁盘来计算, 而且迭代计算的时候, 需要将多个MR程序串联, 执行效率低

原因二: Spark是基于线程运行的, MR是基于进程运行的
线程的启动和销毁的速度, 要远远高于进程的启动和销毁

2 什么是 RDD

RDD(Resilient Distributed Datasets): 一个抽象的弹性的分布式数据集

2.1 RDD 的五大特性

第一个：A list of partitions
① 一组分片(Partition)/一个分区(Partition)列表，即数据集的基本组成单位；
② 对于RDD来说，每个分片都会被一个计算任务处理，分片数决定并行度；
③ 用户可以在创建RDD时指定RDD的分片个数，如果没有指定，那么就会采用默认值；

第二个：A function for computing each split
① 一个函数会被作用在每一个分区；
② Spark中RDD的计算是以分片为单位的，compute函数会被作用到每个分区上；

第三个：A list of dependencies on other RDDs
① 一个RDD会依赖于其他多个RDD；
② RDD的每次转换都会生成一个新的RDD，所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时，Spark可以通过这个依赖关系重新计算丢失的分区数据，而不是对RDD的所有分区进行重新计算（Spark的容错机制）；

第四个：Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)

① 可选项,对于KeyValue类型的RDD会有一个Partitioner，即RDD的分区函数；
② 当前Spark中实现了两种类型的分区函数，一个是基于哈希的HashPartitioner，另外一个是基于范围的RangePartitioner。
③ 只有对于于key-value的RDD，才会有Partitioner，非key-value的RDD的Parititioner的值是None。
④ Partitioner函数不但决定了RDD本身的分片数量，也决定了parent RDD Shuffle输出时的分片数量。

第五个：Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)
① 可选项，一个列表，存储存取每个Partition的优先位置(preferred location)；
② 对于一个HDFS文件来说，这个列表保存的就是每个Partition所在的块的位置。
③ 按照"移动数据不如移动计算"的理念，Spark在进行任务调度的时候，会尽可能选择那些存有数据的worker节点来进行任务计算。（数据本地性）

2.2 RDD 的五大特点

第一个：可分区的: 分区是抽象的分区, 仅仅是定义分区的信息规则
第二个：只读特性(不可变): 一个RDD对象中数据是不可变的
第三个：依赖: RDD与RDD之间是存在依赖关系: 依赖关系越长, 整个血缘关系越长,重新计算的代价就会越大；依赖中可以分为: 宽依赖和窄依赖
第四个：缓存: 当需要对一个RDD的结果进行重复使用的时候, 可以将这个RDD的计算结果缓存起来, 减少后续重新计算的资源和时间消耗
第五个： checkpoint: 检测点
当依赖链条比较长的时候, 如果其中一个算子计算失败, 重新计算一次的代价是很大的, 需要重新将整个依赖关系全部重塑, 非常耗费资源, 可以同检测点将血缘关系打断, 在对应打断点上记录当前结果数据, 这样后续即使使用了, 也不需要重塑全部依赖流程提升容错能留

3 构建RDD

3.1 并行化方式来构建RDD

from pyspark import SparkContext, SparkConf
import os

# 这里可以选择本地PySpark环境执行Spark代码，也可以使用虚拟机中PySpark环境，通过os可以配置
os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ["PYSPARK_PYTHON"] = "/root/anaconda3/envs/pyspark_env/bin/python3"
os.environ["PYSPARK_DRIVER_PYTHON"] = "/root/anaconda3/envs/pyspark_env/bin/python3"
# 注意  在执行spark代码的时候, 必须先将hadoop集群启动好 (因为日志需要记录在HDFS中)
if __name__ == '__main__':
    print("演示: 构建RDD的第一种方式: ")

    # 1) 构建sparkContext对象
    conf = SparkConf().setMaster("local[3]").setAppName("create_rdd_01")
    sc = SparkContext(conf=conf)

    # 2) 读取数据: parallelize
    rdd_init = sc.parallelize(['张三','李四','王五','赵六','田七'],7)

    # 思考: 想查看一下, 当前这个RDD, 是否存在多个分区呢? glom()
    print(rdd_init.glom().collect()) 结果: [[], ['张三'], ['李四'], [], ['王五'], ['赵六'], ['田七']]
    # 用于获取一共有多少的分区
    print(rdd_init.getNumPartitions())  结果为 7
    print("以上为分区的结果数据")
    # 3) 对数据进行处理
    #   需求: 要将每一个元素变更为 (name,1)
    rdd_map = rdd_init.map(lambda name:(name,1))

    # 4) 输出数据: 直接打印
    print(rdd_map.collect())

    # 5) 关闭sc对象
    sc.stop()

3.2 通过读取外部数据方式构建RDD

from pyspark import SparkContext, SparkConf
import os

# 这里可以选择本地PySpark环境执行Spark代码，也可以使用虚拟机中PySpark环境，通过os可以配置
os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ["PYSPARK_PYTHON"] = "/root/anaconda3/envs/pyspark_env/bin/python3"
os.environ["PYSPARK_DRIVER_PYTHON"] = "/root/anaconda3/envs/pyspark_env/bin/python3"

if __name__ == '__main__':
    print("演示通过读取外部文件的方式, 来构建RDD")

    # 1) 创建 sparkContext对象
    conf = SparkConf().setAppName("create_rdd_02").setMaster("local[2]")
    sc = SparkContext(conf=conf)

    # 2) 构建RDD对象: 加载外部数据集
    # 本地路径(指的linux的本地路径): file:///    hdfs协议: hdfs://node1:8020
    # 注意:
    #    在加载外部数据集的时候, 如果数据是本地路径, 默认情况下, 文件有多少个, 自动划分为多少个分区数量 
    #                         如果数据在HDFS路径, 默认情况下, 有多少个block块, 对应有多少个分区数量
    rdd_init = sc.textFile('file:///export/data/workspace/ky03_pyspark_parent/_02_pyspark_core/data/')

    # ---------查看每个分区中数据,以及分区的数量---------------
    print(rdd_init.getNumPartitions())

    print(rdd_init.glom().collect())

    print("--------------")
    # 3) 收集打印数据结果
    print(rdd_init.collect())

    # 4) 释放sc对象
    sc.stop()

4 RDD 算子

在整个RDD中主要有二类算子: 一类是转换(transformation)算子, 另一类动作(action)算子

官方所有算子的查看文档: https://spark.apache.org/docs/3.1.2/api/python/reference/pyspark.html#rdd-apis

转换算子: transformation
① 所有的转换算子执行都会返回一个新的RDD对象
② 转换算子的特性是lazy(惰性), 只有遇到action动作算子后才会执行
③ 不负责数据的存储, 仅仅是定义了计算规则

动作算子: action
① 立即执行(生成一个DAG有向无环图, 执行任务): 一个spark程序中, 有多少个action算子, 那么也就代表着会运行多少个任务
② action算子不会返回RDD对象: 要不就是没有返回值(saveAsTextFile). 要不返回其他的具体内容(collect)

4.1 Transformation 特点: 延迟加载

转换	含义
map(func)	返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
filter(func)	返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
flatMap(func)	类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
mapPartitions(func)	类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func)	类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Iterator[T]) => Iterator[U]
sample(withReplacement, fraction, seed)	根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
union(otherDataset)	对源RDD和参数RDD求并集后返回一个新的RDD
intersection(otherDataset)	对源RDD和参数RDD求交集后返回一个新的RDD
distinct([numTasks]))	对源RDD进行去重后返回一个新的RDD
groupByKey([numTasks])	在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
reduceByKey(func, [numTasks])	在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])
sortByKey([ascending], [numTasks])	在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])	与sortByKey类似，但是更灵活
join(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
cogroup(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
cartesian(otherDataset)	笛卡尔积
pipe(command, [envVars])

4.2 Action 特点: 立即运行

动作算子，在源码中Action算子会调用 runJob 方法，每调用一个action算子就相当于提交了一个Job

动作	含义
reduce(func)	通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的
collect()	在驱动程序中，以数组的形式返回数据集的所有元素
count()	返回RDD的元素个数
first()	返回RDD的第一个元素（类似于take(1)）
take(n)	返回一个由数据集的前n个元素组成的数组
takeSample(withReplacement,num, [seed])	返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n, [ordering])	takeOrdered和top类似，只不过以和top相反的顺序返回元素
saveAsTextFile(path)	将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)	将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)
countByKey()	针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)	在数据集的每一个元素上，运行函数func进行更新。