Spark个人理解（基础）

最新推荐文章于 2022-10-01 14:05:31 发布

Gklearlove

最新推荐文章于 2022-10-01 14:05:31 发布

阅读量190

点赞数

分类专栏： Spark 文章标签： Spark

本文链接：https://blog.csdn.net/qq_40407889/article/details/102699522

版权

Spark 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Spark学习

一、Spark整体架构介绍

Spark组件
1. Spark Core提供内存计算框架
2. Spark Streaming 伪实时计算应用
3. Spark SQL 数据查询处理
4. MLlib 机器学习
5. GraphX/Grapframes 图处理
Spark（与Hadoop区别）：
1. 执行引擎：DAG
2. 计算方式：内存计算
Spark特点：
1. 运行速度快（内存计算）
2. 易用性好（支持多种语言接口）
3. 通用性强（组件多）
4. 随处运行
Spark与Hadoop对比：
1. Spark把中间数据放到内存，运算效率高
2. Spark容错性高（使用弹性分布式数据集RDD）
3. Spark更加通用
Spark集群术语定义：
- Driver：驱动器（运行在Master），作用是创建SparkContext来准备应用环境。SparkContext和ClusterManager通信来分配和监管资源
- executor：执行器（运行在Worker），作用是运行Task并保存数据在内存或磁盘。
- Application：由一个Driver与多个executor组成。指的是Spark的应用程序负责
- Cluster Manager:获取资源的外部服务分为两种：
  - Standalone:Spark的原生资源管理，由Master负责资源分配
  - Hadoop Yarn：由Yarn的ResourceManager负责资源分配
- Worker：运行Application的节点，类似于NodeManager，在Spark on Yarn模式下就是Nodemanager
- Stage:阶段，每个Job被分成多组Task，每组被称为Stage。
- Job与Task：Job是整体，包含多个Task，而Task是一个具体的被Executor执行的任务。

二、Spark核心数据类型RDD与DateFrame

1、RDD:

概念：弹性分布式数据集
介绍：RDD是Spark的最基本的抽象，其他的数据类型比如DataFrame或DataSet都是RDD的高级封装。
特点：
- 不可变（不能修改）
- 支持分区（即支持分布式）
- 路径：即链式，在RDD叫血统，即依赖父RDD，RDD有充足的信息关于它的产生。
- 持久化：支持RDD缓存
- 操作：有丰富的动作
- 延迟计算：转换不会立刻执行，只有动作发生时，更加高效
RDD的可恢复性;由于RDD不变，且有血统，索引一旦中间某个RDD发生错误丢失或损坏，可以根据血统快速利用父RDD重建。
RDD创建：
- 使用.parallelize创建：即手动创建
- 使用外部存储数据创建（更加多用）

RDD编程

#第一步、
#创建sparkconf配置信息
#创建sparkcontext利用sparkconf创建环境
from pyspark import SparkConf, SparkContext
conf = SparkConf().setAppName("sparkapp").setMaster("local[2]")#本地测试local
sc = SparkContext(conf=conf)

#第二步
#创建RDD
#第一种方法,本地创建
date=[1,2,3]
date2 = [('a',1),('b',1)...]
rd1=sc.parallelize(date)
rd2=sc.parallelize(date2)
#第二种，外部存储创建
date_rdd = sc.textFile('文件目录',分区数)

#第三步，RDD编程

#RDD编程分为转换和动作
#转换是惰性的，即当转换时只是记录怎么转换，只有当动作事件触发时才会真正转换，更加高效。
#转换

# map() 转换,即rdd的每一个元素进行map里函数的操作，返回新的rdd
new_rdd=rdd.map(lambda x:x+1)

#filter，选择适合的元素
new_rdd = rdd.filter(lambda x:x%2==0)

#flatMap()，返回一个扁平的结果
new_rdd = rdd.flatMap(lambda x:[[x]])

#distinct()去重
new_rdd = rdd.distinct()

#sample(False,0.x,81),返回一个随机样本，其中0.x是从返回%多少，81是随机种子方式
new_rdd = rdd.sample(False,0.1,81)

#leftOuterJoin(),左外连接
new_rdd = rdd1.leftOuterJoin(rdd2)

#join() 普通连接
new_rdd = rdd1.join(rdd2)

#intersection() 返回两个相同的rdd
new_rdd = rdd1.intersection(rdd2)

#repartition(x) 分区,x为分区个数
new_rdd = rdd.repartition(x)

#操作（返回的不是rdd而是数据）：

#take(n) 返回前n行数据
shuju = rdd.take(2)
print(shuju)

#collect() 返回所有数据
shuju = rdd.collect()

#reduce(方式) 规约数据，即利用规约方法对每一个数据进行规约
shuju = rdd.reduce(add)#利用+方法规约

#reduceByKey() 规约数据，只是相同的键进行规约。特殊在它返回的是新rdd
new_rdd = rdd.reduceBykey(add).collect()

#count()方法 返回共多少个数据
shuju = rdd.count()

#countByKey().items() 按照键进行统计
shuju = rdd.countByKey().items()

#saveAsTextFile(路径) 保存数据
rdd.saveAsTextFile('1.txt')

#foreach 每个元素进行迭代应用相同函数
def f(x):
    print(x)
rdd.foreach(f)

RDD缓存
- 可以在内存中持久化数据集，只有当内存不够时才会溢出到磁盘，但尽量不要溢出到磁盘，因为会大大影响性能
- 通过RDD缓存，可以更加高效的使用数据集，一般来说一个节点60%用作缓存，40%做task
- 优点在于当某个RDD失败丢失时，通过缓存可以使用血统快速恢复。
RDD共享变量
- 共享变量就是解决节点需要某一相同的变量
- 第一种共享变量:广播变量：
  - 广播变量要缓存在各个节点的内存上
  - 广播变量特点：
    - 缓存到各个节点，通常是只读
    - 缓存到各节点内存上
    - 广播变量可以被集群任意函数使用
- 第二种共享变量：累加器
  - 累加器就是在调试时对作业执行过程中的事件进行计数。

2、DataFrame

概念：以RDD为基础，是一种不可变的分布式数据集，类似于数据库的表，但不是表。
与RDD区别：DataFrame带有元数据（列名，类型等），更加有利于Spark SQL进行操作。
优点：
- 结构化，可以利用Spark SQL来查询（即类SQL语言来操作）
- 优化了Python，使得Python的性能与Java/Scala一致

创建：

使用RDD来创建DataFrame（一般RDD格式是JSON的格式，因为有列名）:

利用反射推断模式（自识别类型）：

#json格式的RDD转成DataFrame
df = spark.read.json(json类型的RDD)#转换成DataFrame，惰性的，只有执行下一步									才执行
df.createOrReplaceTemView('df')#创建DataFrame

#查看当前DataFrame格式
df.printSchema()

利用编程式（自定义类型）

#1、创建满足某个格式类型的RDD，然后创建格式
from pyspark.sql.types import *
type_rdd = sc.parallelize([
    (数据1-1,数据2-1,数据3-1),
    （数据1-2,数据2-2,数据3-2）,
    .
    .
    .
])

schema = StructType(
	StructField("列名1",数据类型,True),
	StructField("列名2",数据类型,True),
	StructField("列名3",数据类型,True),
)
#其中数据类型有：
LongType():长整型
StringType():字符串型
#True/False：是是否为空

#2、将RDD应用到这种格式创建DataFrame
df = spark.createDataFrame(type_rdd,schema)#转换成DataFrame，惰性的，只有执行											下一步才执行
df.createOrReplaceTemView('df')#创建DataFrame

#3、查看DataFrame格式
df.printSchema()

使用外部数据创建DataFrame

df = spark.read.csv('路径',header = 'true')
df.createOrReplaceTemView('df')#创建DataFrame

DataFrame的API操作：

#用show()来返回数据

#查询前n行
df.show(n)

#得到DataFrame的行数
df.count()

#DataFrame的查询
df.select("列名","列名").show()

#DataFrame的筛选
df.filter(筛选条件).show()
#比如df.select('name').filter(df.age>=30).show()

利用SparkSQL来操作

#利用SparkSQL的语句来操作DataFrame
spark.sql("sparksql语句").show()

3、打包Spark应用程序

格式：spark-submit 选项 python文件.py

选项详解

--master:启动的方式，可以是Local，可以是standlone可以是yarn。
--name 应用程序名称
--py-files 依赖的文件
--conf 动态修改配置
--driver-memory 驱动器内存大小
--executor-memory 执行器内存大小
--deploy-mode 允许在本地启动Spark程序
#原因是要指定运行一个作业，要在外部指定某些参数，如果写在文件内，如果想要改变就只能修改文件

流程

文件：
from pyspark.sql import SparkSession
spark = SparkSession.builder....设置环境
业务逻辑代码

shell:./spark-submit --master yarn --deploy-mode cluster --executor-memory 512M test.py /input.txt

三、SparkSQL

1、SparkSQL的背景

Hive是将HQL转成MapReduce作业，所以需要有个类似于Hive的HQL的工具，来处理Hive中的数据或者操作DataFrame这种类表结构的数据。于是Shark诞生。由于Shark对于Hive有过多的依赖，影响了其他的Spark组件所以诞生了全新的SparkSQL
什么是SparkSQL：

SparkSQL就是在Spark生态圈中操作存储于Hive的数据，由于Hive来处理的话，会转成MapReduce作业。使用SparkSQL来处理的话，底层转的不再是MapReduce作业而是Spark的核心内存计算Spark Core，这样的话速度会显著提升。
SparkSQL的特点：
- 内存列存储（在内存中存储的不是JVM对象而是类表结构）

2、SparkSQL的分支

HiveContext（默认）：

支持SQL语法解析器与HiveSQL解析器
SQLcontext：

仅支持SQL语法解析器

3、SparkSQL模块

Core:核心计算
Catalyst（核心模块）：优化器或者查询引擎（优化语句）
Hive：对Hive数据的处理
Hive-Thrifserver：提供JDBC/ODBC接口

4、SparkSQL应用场景

在DataFrame编程中使用SparkSQL，用类似于SQL的语言对DataFrame这种类表结构快速编程
在Hive的基础上，使用SparkSQL操作存储于Hive的数据（底层转成Spark Core来内存计算）

四、Spark Streaming

1、Spark Streaming介绍：

SparkStreaming概念：
- 是流式处理架构，即数据流系统；采用的是RDD批量模式
SparkStreaming的特点
- 高容错：由于底层是分成多个RDD进行批量计算，RDD是高容错的所以SparkStreaming也是高容错的
- 实时的
- 数据源多样（可以是Kafka,Flume，tcp等）
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9U3RsHWs-1571807889897)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1568737183620.png)]
工作原理：

所谓的SparkStreaming实时流处理本质上是实时接收数据，将数据流DStream切分成多个批处理的作业（默认每1s切分数据，形成RDD），然后将对DStream的转换操作，变成对多个RDD的转换操作，然后将RDD结果保存在内存，分批生成数据流。

本质上还是批处理，即伪流式处理。

SparkStreaming的数据流高级抽象：DStream（内部是一系列的RDD）
SparkStreaming的应用场景：
- 流ETL
- 触发器
- 数据浓缩
- 复杂会话和持续学习
编程模型：
- 将DStream转成一系列RDD，对DStream的操作转成对RDD的操作，然后形成新的DStream
  
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hTAjSszF-1571807889899)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1568738000567.png)]

五、GraphFrames

简介：

GraphFrames是图处理，处理的是图形结构。基于Spark的DataFrame，支持多种语言。

可以使用SparkSQL与DataFrame的API进行查询
组成：顶点和边（以DataFrame形式存储）

Gklearlove

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spark个人理解（基础）

Spark学习一、Spark整体架构介绍Spark组件Spark Core提供内存计算框架Spark Streaming 伪实时计算应用Spark SQL 数据查询处理MLlib 机器学习GraphX/Grapframes 图处理Spark（与Hadoop区别）：执行引擎：DAG计算方式：内存计算Spark特点：运行速度快...
复制链接

扫一扫