Spark总结(SparkCore,SparkSQL,SparkStreaming)

SparkCore

1.一句话介绍Hadoop 和 Spark

​ spark是基于内存的分布式计算框架。

​ hadoop是一个分布式计算开源框架,包含分布式文件系统HDFS、 MapReduce分布式计算的软件架构和Yarn资源管理调度系统。

2.Spark和MR的区别

1.MR是基于磁盘迭代处理数据,Spark是基于内存处理数据

2.Spark有DAG有向无环图做优化

3.MR是细粒度资源申请,application执行慢,spark是粗粒度资源申请,application执行快

4.MR没有SQL,流处理功能,Spark有SQL功能以及流处理功能

5.MR没有高级算子的封装,Spark提供了各种高级算子(函数)

3.Spark的运行模式

1)Local:运行在一台机器上。 测试用。

2)Standalone:是Spark自身的一个调度系统。 对集群性能要求非常高时用。国内很少使用。

3)Yarn:采用Hadoop的资源调度器。 国内大量使用。

4)Mesos:国内很少使用。

4.常用端口号总结

Hadoop

​ NameNode WebUI 2.x 50070 3.x 9870

​ 访问MR执行情况端口(yarn) 8088

​ 历史服务器 19888

​ 客户端访问集群端口(内部通信) 2.x 9000 3.x 8020

Spark

​ spark-shell任务端口 4040

内部通讯端口                            7077

standalone,master web         8080 

​ 历史服务器 18080

其他

​ zookeeper 2181

​ redis 6379

​ mysql 3306

​ kafka 9092

​ hbase master WebUI 60010

5.简述Spark的架构与作业提交流程

在这里插入图片描述

6.RDD的五大特性

RDD是由一系列Partition组成

算子是作用在partition上的

RDD之间有依赖关系

分区器是作用在KV格式的RDD上的

partition对外提供了最佳的计算位置(移动数据不如移动计算)

7.Transformation算子

单value

map

mapPartitions

mapPartitionsWithIndex

flatMap

groupBy

filter
sample(true,0.3) 放回抽样,抽样比例0.3

distinct去重,原理reduceByKey 有shuffle

coalesce 减少分区用coalesce(num,false) 不shuffle

repartition 增加分区用repartition(num) =coalesce(num,true) 有shuffle

sortBy

双value

intersection 它是去二个rdd的交集 有shuffle

union 取两个RDD的并集,不去重,会增加partition的数量,同时并行度也会增加

K-V

reduceByKey

groupByKey

sortByKey

aggregateByKey

join

8.action算子

collect

count

first take(1)

take

foreach

foreachPartitons

top

takeOrdered(n) 取出前n个元素,按升序列

9.Spark提交作业参数

./spark-submit --master yarn --deploy-mode cluster --class …jar …

1)在提交任务时的几个重要参数

executor-cores 4

num-executors 10

executor-memory 8g

driver-cores 2

driver-memory 8g

2)边给一个提交任务的样式

spark-submit \

–master yarn \

–deploy-mode cluster \

–driver-cores 2 \

–driver-memory 8g \

–executor-cores 4\

–num-executors 10 \

–executor-memory 8g \

–class PackageName.ClassName XXXX.jar \

–name “Spark Job Name” \

InputPath \

OutputPath

10.Spark宽窄依赖

窄依赖:父rdd与子rdd是一对一或多对一的关系

宽依赖:父rdd与子rdd是一对多或多对多的关系 有shuffle shuffle会落地到磁盘

比如,coalesce(num,false) 减少分区时,就不会产生shuffle

11.粗细粒度资源申请

粗粒度资源申请-Spark

Application执行之前首先将所有的资源申请完毕,Application中的每个job执行时不需要自己申请资源,自己释放资源,当application中最后一个job执行完成之后,所有的资源才会被释放,job执行快,application执行快,集群的资源不能充分利用。

细粒度资源申请-MR

Application启动之后,每个job自己申请资源自己释放资源,每个job执行完成之后,资源立即释放,集群资源可以充分利用, application执行相对慢。

12. Spark任务的划分

(1)Application:初始化一个SparkContext即生成一个Application;

(2)Job:一个Action算子就会生成一个Job;

(3)Stage:Stage等于宽依赖的个数加1;

(4)Task:一个Stage阶段中,最后一个RDD的分区个数就是Task的个数。

13.cache缓存级别

DataFrame的cache默认采用 MEMORY_AND_DISK

RDD 的cache默认方式采用MEMORY_ONLY

其他缓存级别

DISK_ONLY

MEMORY_AND_DISK_SER

MEMORY_AND_DISK_SER_2 数据存两份

MEMORY_AND_DISK_2

cache() = persist(StorageLevel.MEMORY_ONLY)

14.缓存和检查点

1)Checkpoint 需要手动指定磁盘目录,当Spark的application执行完成之后数据不会被清空,由于这个特点,checkpoint在Spark中常用于状态管理

2)Cache缓存只是将数据保存起来,不切断血缘依赖,当Spark的application执行完成之后数据会被清空。Checkpoint检查点切断血缘依赖。

3)建议对checkpoint()的RDD使用Cache缓存,这样checkpoint的job只需从Cache缓存中读取数据即可,否则需要再从头计算一次RDD。

15.Saprk二次排序

将数据封装到一个对象中,使用SortByKey对对象排序,对象需要实现可排序 Comparable 接口

16.Spark分组取TopN

1.GroupByKey后分组的数据放到集合中进行排序。取出前n个 数据量大会OOM

2.GroupByKey后分组的数据进行迭代,使用定长数组的方式拿到前n个,迭代器本身不储存数据。

17.Saprk广播变量

1)当Executor端使用到Driver端的变量时,如果不使用广播变量,每个Executor有多少task就有多少变量的副本。使用广播变量后,每个Executor只有一份Driver端变量的副本。

2)广播变量不能对RDD进行广播,可以将RDD回收到Driver端进行广播

3)广播变量只能在Driver端定义,在Executor端不能修改广播变量的值

4)广播变量的声明和使用

val broadcast :Broadcast[String] = sc.broadcast(str)

rdd.filter{

​ log=>log.contains(broadcast.value)

}

18.Spark累加器

累加器只能在Driver端定义初始化,在Executor累加

val sum:LongAccumulator = sc.longAccumulator(“sum”);

rdd.foreach{

​ sum.add(1)

}

19.会引起shuffle的Spark算子

reduceBykey:map端预聚合

groupByKey:没有map端预聚合

repartition: 重分区,一般用于增加分区

aggregateByKey

SortByKey:

SparkSQL

1.Hive on Spark 与Spark On Hive

hive on spark : hive映射HDFS上的表,解析优化SQL,底层转化为Spark执行

spark on hive : hive映射HDFS上的表,Spark解析优化SQL,Spark执行,写的是Spark代码

2.RDD & Dataset & DataFrame

1)RDD 是Spark Core底层操作的对象

2)Dataset是SparkSQL底层操作的对象,Dataset底层hash,filter,sort时不需要反序列化数据成对象,性能比RDD高

3)DataFrame = Dataset[Row] ,DataFrame中有数据和Schema信息,在Java api 没有DataFrame对象,就是Dataset

3.Spark配置对象和上下文对象

SparkConf : Spark 配置

SparkContext : Spark上下文,SparkCore编程需要创建SparkContext

SQLContext : 在SparkSQL编程中需要创建的对象,创建SQLContext,需要创建SparkConf,SparkContext()

HiveContext : SparkSQL读取Hive中的数据需要创建的对象,HiveContext就是SQLContext的子类

SparkSession :Spark2.0+ 版本之后推出对象,兼容了SparkConf,SparkContext,SQLContext,HiveContext对象,方便编程。

4.RDD如何转换为DataFrame

1)通过反射方式(推荐)

(1)把数据切分组装到bean类中,用map算子返回

(2)导入隐式转换函数 import session.implicits._

(3)rdd.toDF

2)通过动态创建Schema

​ (1)把数据切分组装到Row中,用map算子返回

​ (2)构建StructType

val scheme: StructType = StructType(List[StructField](
      StructField("id", DataTypes.IntegerType, true),
      StructField("name", DataTypes.StringType, true),
      StructField("age", DataTypes.IntegerType, true),
      StructField("score", DataTypes.IntegerType, true)
    ))

​ (3) session.createDataFrame(rdd,scheme)

5.UDF

一对一

(1)导入隐式转换函数 import session.implicits._

​ (2) 向sparkSessionj注册udf函数 val addName: UserDefinedFunction = session.udf.register(“addName”, (x: String) => “Name=” + x)

​ (3) 在session.sql(“”)使用

SparkStreaming

1.MR & Spark &Storm

MR只能处理批数据,MR只有map和reduce,有原生api,没有高级算子的封装

Storm 处理实时流数据的框架,处理数据是一条条的,有原生api,不支持sql api

Spark 可以处理批数据,也可以处理流数据 可以使用Sql,有高级算子封装

SparkStreaming 是微批处理,吞吐量高,数据延迟较高,可以保证数据的一致性

2.SparkStreaming编程

val ssc = new StreamingContext(SparkConf,Durations.second(xx))

ssc.start()之后业务逻辑不能改变

3.SparkStreaming 处理数据过程

1.SparkStreaming读取socket数据首先 会启动一个job,接收数据

2.将batchInterval 接收过来的数据封装到一个batch中,batch又被封装到RDD中,RDD又被封装到DStream中

3.DStream有Transformation类算子可以转换数据,懒执行的,需要DStream的outputOperator类算子触发执行

4.reduceByKeyAndWindow 滑动窗口

每隔一段时间处理最近一段时间内数据 可以使用窗口操作

  • 窗口长度:window length - wl ,必须是batchInterval整数倍

  • 滑动间隔:sliding interval -si ,必须是batchInterval整数倍

  • reduceByKeyAndWindow(fun,窗口长度,滑动间隔) : 普通机制,每次计算都是将当前窗口内的批次全部重新计算

  • reduceByKeyAndWindow(fun1,fun2,窗口长度,滑动间隔) :优化机制,需要设置checkpoint 保存状态,每次计算根据上次结果统计得到

object SparkStreamingWindowFun {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local[2]")
    conf.setAppName("test")
    val ssc = new StreamingContext(conf,Durations.seconds(5))
    ssc.checkpoint("./data/ck1")
    ssc.sparkContext.setLogLevel("Error")
    val lines: ReceiverInputDStream[String] = ssc.socketTextStream("node5",9999)

    val ds: DStream[String] = lines.window(Durations.seconds(15),Durations.seconds(5))

    val words: DStream[String] = lines.flatMap(_.split(" "))
    val pairWords: DStream[(String, Int)] = words.map(word=>{(word,1)})
    val result: DStream[(String, Int)] = pairWords.reduceByKeyAndWindow(
      (v1: Int, v2: Int) => {v1 + v2},
      (v1: Int, v2: Int) => {v1 - v2},
      Durations.seconds(15),
      Durations.seconds(5))

//    val result: DStream[(String, Int)] = pairWords.reduceByKeyAndWindow((v1: Int, v2: Int) => {
//      v1 + v2
//    },
//      Durations.seconds(15),
//      Durations.seconds(5))
    result.print()

    ssc.start()
    ssc.awaitTermination()

  }

5.foreachRDD

1).foreachRDD可以获取DStream中的RDD,对RDD使用RDD的算子操作,但是一定要对转换之后的RDD使用RDD的action算子触发

2).foreachRDD 算子内获取的RDD算子外的代码是在Driver端执行的。可以利用这个特点做到动态的改变广播变量

6.transform

1).可以获取DStream中的RDD,对RDD 可以使用RDD的算子操作,需要返回一个RDD

2).在transform算子内获取的RDD的算子外,代码是在Driver端执行的,可以做到动态改变广播变量

7.Driver HA

1.需要提交任务时指定 --supervise

  1. val ssc: StreamingContext = StreamingContext.getOrCreate(ckdir,myFun)
  2. myFun为返回StreamingContext的方法,里面是保存的状态和逻辑

/**
  *  Driver HA
  *   实现 : 1. 需要提交任务时指定 --supervise 2.在代码中恢复数据
  */
object SparkStreamingDriverHA {
  val ckdir = "./data/ck"
  def main(args: Array[String]): Unit = {
    //从checkpoint中恢复数据
    val ssc: StreamingContext = StreamingContext.getOrCreate(ckdir,myFun)
    ssc.start()
    ssc.awaitTermination()
  }

  def myFun():StreamingContext = {
    //SparkStreaming 配置
    val conf = new SparkConf()
    conf.setMaster("local")
    conf.setAppName("test")
    val ssc = new StreamingContext(conf,Durations.seconds(5))

    //设置checkpoint
    /**
      * checkpoint中保存数据:
      *   1.SparkStreaming 配置信息
      *   2.当前SparkStreaming 处理的逻辑
      *   3.保存当前SparkStreaming 处理数据状态(处理job的进度,每次处理数据的批次信息)
      */
    ssc.checkpoint(ckdir)

    //DStream处理逻辑
    val lines: DStream[String] = ssc.textFileStream("./data/monitorFile")
    lines.flatMap(_.split(" "))
        .map((_,1))
        .reduceByKey(_+_)
        .foreachRDD(rdd=>{
          rdd.map(tp=>{
            println("xxxxx"+tp)
            tp._1+"_"+tp._2
          }).foreach(println)
        })
//        .print()
    ssc
  }
}

8.SparkStreaming+kafka

receiver模式

receiver模式理解:
在SparkStreaming程序运行起来后,Executor中会有receiver tasks接收kafka推送过来的数据。数据会被持久化,默认级别为MEMORY_AND_DISK_SER_2,这个级别也可以修改。receiver task对接收过来的数据进行存储和备份,这个过程会有节点之间的数据传输。备份完成后去zookeeper中更新消费偏移量,然后向Driver中的receiver tracker汇报数据的位置。最后Driver根据数据本地化将task分发到不同节点上执行。

receiver模式中存在的问题
当Driver进程挂掉后,Driver下的Executor都会被杀掉,当更新完zookeeper消费偏移量的时候,Driver如果挂掉了,就会存在找不到数据的问题,相当于丢失数据。使用的是kafka的高级api,不能手动维护offset

如何解决这个问题?

开启WAL(write ahead log)预写日志机制,在接受过来数据备份到其他节点的时候,同时备份到HDFS上一份(我们需要将接收来的数据的持久化级别降级到MEMORY_AND_DISK),这样就能保证数据的安全性。不过,因为写HDFS比较消耗性能,要在备份完数据之后才能进行更新zookeeper以及汇报位置等,这样会增加job的执行时间,这样对于任务的执行提高了延迟度。

Driect模式

Direct模式理解
SparkStreaming+kafka 的Driect模式就是将kafka看成存数据的一方,不是被动接收数据,而是主动去取数据。消费者偏移量也不是用zookeeper来管理,而是SparkStreaming内部对消费者偏移量自动来维护,默认消费偏移量是在内存中,当然如果设置了checkpoint目录,那么消费偏移量也会保存在checkpoint中。当然也可以实现用zookeeper来管理。使用的是kafka的低级api,能手动维护offset,可以实现精准消费一条数据,偏移量的保存,是保存在zookeeper,Redis,MySQL中的。

Direct模式并行度设置
Direct模式的并行度是由读取的kafka中topic的partition数决定的。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页