Spark从入门到精通9 -- Spark Streaming

Spark Streaming

Spark Streaming简介

• Spark Streaming是Spark为了处理实时流数据而设计的模型，允许基于批处理API进行对实时流数据进行处理。

• Spark Streaming使用离散化流(discretized stream)作为抽象表示，叫做DStream。类似于Spark中的RDD，用于存储实时流数据。DStream是将实时流数据分批整合成RDD，是RDD组成的序列。所以DStream支持转化操作(RDD之间的转换)与输出操作(将数据写入外部系统)。

• Spark Streaming因为是处理实时流数据，所以需要保证7*24不间断工作，为了保证任务的容错性，会提供检查点机制。

Spark Streaming架构与抽象

• Spark Streaming采用微批次的架构作为处理流数据的方式。Spark Streaming从各种输入源中读取数据，每个新的批次是一个时间间隔内接收到的数据，一个批次的数据作为一个RDD对象，可以通过控制批次间隔的参数控制每次批处理数据RDD的大小。一般是几百毫秒到几秒之间。

graph LR
	source[输入源]
	subgraph Streaming
		B[接收器] --> C[DStream]
	end	
	source --> B
	C --> D[输出结果]

• DStream数据结构

DStream

时间0到1的数据

时间1到2的数据

时间2到3的数据

时间3到4的数据

时间4到5的数据

Spark Streaming转化操作

• Spark Streaming根据批次处理是否依赖于之前批次数据的条件，将转化操作分为有状态(依赖)和无状态(不依赖)两种。

无状态

• 无状态转化操作可以看做是分别对每个批次的RDD单独操作，每个批次之间相互独立。

• 支持的常见API

函数名称	目的	示例
map()	转换元素格式或取值	ds.map(x => x+1)
flatMap()	元素切分为多个元素	ds.flatMap(x => x.split(" "))
filter()	返回制定条件的元素	ds.filter(x => x != "")
repartition()	修改分区数	ds.repartition(10)
reduceByKey()	键值对数据类型处理相同key值	ds.reduceByKey((x,y) => x+y)
groupByKey()	键值对数据类型相同key的值分组	ds.groupByKey()

有状态

• 窗口时长：每次计算最近多少个批次的数据，如果一个批次的时间间隔为10秒，如果窗口时长为30表示每次计算3个批次的数据。

• 滑动步长：滑动步长默认值与批次间隔一样，表示每隔多少时间，进行一次计算，如果期望每隔两个批次计算一次，则滑动步长时间为批次间隔的二倍。

• 窗口时长为30秒,滑动步长为20秒,批次间隔为10秒的数据处理示意图：(每隔两个批次对前三个批次进行计算)

t1

r1

t2

r2

t3

t4

r3

t5

t6

• 常用API简介

//linesTimes数据格式为 （key,1）表示流数据获取中每个key值出现的个数 默认为1
val lineTimes = lines.map(x => (x,1))
lineTimes.reduceByKeyAndWindow(
  {(x,y) => x+y}, //对新入窗口的批次 相同key次数相加
  {(x,y) => x-y}, //对离开窗口的批次 相同key次数相减
  Seconds(30),  //窗口时长30秒 6个批次
  Seconds(5)  //滑动步长5秒 每隔一次批次就计算一次
)

API	含义
countByWindow()	返回每个窗口中元素个数
countByValueAndWindow()	返回每个窗口中值对应的个数

• updateStateByKey()

操作键值对格式的DStream，并进行无限增长的计算。

def main(args: Array[String]): Unit = {
    
    /*
    values ： 表示当前批次中相同key值 的value值集合
    state :  表示当前key值的之前状态
    */
    def updateStateMethod(values:Seq[Int],state:Option[Int]) ={
      //创建一个变量，用于记录单词出现次数
      var newValue=state.getOrElse(0) //getOrElse相当于if....else.....
      for(value <- values){
        newValue +=value //将单词出现次数累计相加
      }
      Option(newValue)
    }

    //连接nc(netcat)服务,接收数据源，产生Dtream 对象
    val lines=ssc.socketTextStream("localhost",7777)

    //分隔单词，并将分隔后的每个单词出现次数记录为１
    val pairs=lines.flatMap(_.split(" "))
      .map(word=>(word,1))

    //调用updateStateByKey算子，统计单词在全局中出现的次数
    val result = pairs.updateStateByKey[Int](updateStateMethod)
    //result : DStream[scala.Tuple2[String, Int]]
    
    ssc.start()
    ssc.awaitTermination()
}

Spark Streaming输出操作

• print()

默认打印每个批次的前10行

• saveAsTextFiles("outputDir", "txt")

将内容按批次保存成文本文件

• foreachRDD{}

获取每个批次RDD，将RDD自定义存储到外部系统

7*24不间断工作

检查点机制

为了保证Spark Streaming的容错性，我们将Spark Streaming中的应用数据阶段性的存储到可靠的文件系统中。即便Spark自带谱系图实现RDD数据丢失的容错性，Spark Streaming还是从性能角度设置了检查点机制，直接将获取的RDD数据保存在可靠的文件系统中，保证数据的容错性。

ssc.checkpoint("文件系统路径")

驱动器程序容错

def createStreamingContext(): StreamingContext = {
    val sc = new SparkContext(conf)
    val ssc = new StreamingContext(sc, Seconds(1))
    ssc.checkpoint(checkpointDir)
    ssc
}

val ssc = StreamingContext.getOrCreate(checkpointDir, createStreamingContext)

• 当驱动器程序失败后，重启驱动器程序，getOrCreate方法会从检查点目录的位置初始化StreamingContext对象，继续处理。

工作节点容错

• 所有从外部节点获取到的数据会在多个节点中备份，包括基于转化操作生成的RDD都允许一个节点的失败。

接收器容错

• 当接收器节点上的发生错误，Spark Streaming会在别的节点上重启失败的接收器。对于重启过程中接收失败的数据，是否会丢失，取决于上游数据源是否具有事务机制。

处理保证

• 因为任务某种原因，输出操作会执行多次，这时需要保证输出到外部系统的代码部分具有事务，保证同一条数据在多次插入过程中生成一条结果。例如，向mysql插入数据时，先查询唯一列的值是否存在。

性能考量

批次与窗口大小

• 当处理时间不变时尽量使用更小的批次，保证内存的可用性。一般情况下500毫秒为较好的最小批次大小。10秒为一个较大的批次大小，

并行度

• 增加接收器数量

创建多个DStream(每个DStream会创建一个新的接收器)，然后使用union将数据合并为同一个数据源。

• 将接收到的数据显式分区

DStream.repartition(分区数)

• 提高聚合计算的并行度

val init = sc.parallelize(List("1 2","3 4","3 6"))
val kv = init.map(x => (x.split(" ")(0).toInt, x.split(" ")(1).toInt))
//(1,2),(3,10)
println(kv.reduceByKey((x, y) => x+y, 10).collect().mkString(","))