【Spark】Spark Streaming的程序运行原理及与Kafka的集成

1、Spark Streaming介绍

(1)Streaming
Streaming:是一种数据传送技术,它把客户机收到的数据变成一个稳定连续的流,源源不断地送出,使用户听到的声音或看到的图象十分平稳,而且用户在整个文件送完之前就可以开始在屏幕上浏览文件。
(2)流式计算系统 Streaming Compute
常用的有三种:Apache Storm、Spark Streaming和Apache Samza。
这三种实时计算系统都是开源的分布式系统,具有低延迟、可扩展和容错性等诸多优点,它们的共同特点在于:允许你在运行数据流代码时,将任务分配到一系列具有容错能力的计算机上并行运行。此外,它们都提供了简单的API来简化底层实现的复杂程度,并可以与批处理和交互式处理相结合。
(3)Spark Streaming
Spark Streaming是基于Spark Core的,是Spark Core API的扩展,可以对实时数据流进行可扩展的、高吞吐量的、容错的准实时的微观操作的流式处理。
Spark Streaming是按照批次进行执行的,一个一个批次执行,一个批次处理的数据就是对应时间段收集得到的数据,只有当上一个批次执行完成后,下一个批次才会开始执行。(Spark Core是批量处理,Spark SQL是交互式处理,Spark Streaming是小块小块处理。)
(4)Storm/JStorm
Storm是完全实时的流式数据处理平台,JStorm是Java语言改写的Storm平台。Storm来一条数据就处理一条数据,对机器性能要求比较高。
Spark Streaming相比于Storm的缺点:Spark Streaming平台中数据的延迟性在高并发、大数据量的情况下比Storm高。
(5)Spark Streaming的数据处理过程
1)数据收集/数据输入
指定从哪儿读取数据,常用的有kafka、flume等。
2)数据处理
使用DStream的相关API进行数据处理操作。
3)结果输出
将结果保存到外部的存储系统中,有如下几类:
a)redis、mongodb
b)RDBMS
c)hbase、hdfs、hive
d)kafka
企业中的实时处理应用结构:[Flume ->] Kafka -> Streaming/Storm -> Kafka/HBase
(6)常用的应用场景
1)活跃访客的数量
a)每个小时的访客数量
b)最近十五分钟的访客数量
c)到现在为止当天的访客数量(五分钟统计一次)
d)访客的地域数量统计
2)广告的点击量统计
3)黑名单的统计
(7)Spark Streaming的程序入口
Spark Streaming的程序入口是StreamingContext,它依赖SparkContext对象,其核心抽象是DStream,可以当做RDD来进行操作。
SparkSQL的程序入口是SQLContext。

2、Spark Streaming运行WordCount实例

(1)启动服务

[beifeng@bigdata-senior ~]$ which nc
/usr/bin/nc
[beifeng@bigdata-senior ~]$ nc -lk 9999

~]$ cd /opt/cdh-5.3.6/hadoop-2.5.0-cdh5.3.6/
hadoop-2.5.0-cdh5.3.6]$ sbin/hadoop-daemon.sh start namenode
hadoop-2.5.0-cdh5.3.6]$ sbin/hadoop-daemon.sh start datanode
~]$ cd /opt/modules/zookeeper-3.4.5/
zookeeper-3.4.5]$ bin/zkServer.sh start
~]$ cd /opt/cdh-5.3.6/kafka_2.10-0.8.2.1/
kafka_2.10-0.8.2.1]$ bin/kafka-server-start.sh config/server.properties
~]$ cd /opt/cdh-5.3.6/hive-0.13.1-cdh5.3.6/
hive-0.13.1-cdh5.3.6]$ bin/hive --service metastore &
~]$ service mysql start
Starting MySQL                                             [  OK  ]

[beifeng@bigdata-senior ~]$ jps
3149 Jps
2599 DataNode
2931 RunJar
2719 QuorumPeerMain
2797 Kafka
2538 NameNode

(2)运行Spark Streaming自带的WordCount程序

~] cd /opt/cdh-5.3.6/spark-1.6.1-bin-2.5.0-cdh5.3.6
spark-1.6.1-bin-2.5.0-cdh5.3.6]$ bin/run-example streaming.NetworkWordCount bigdata-senior.ibeifeng.com 9999

(3)在Spark Shell手写WordCount程序
注意:运行spark-shell的时候master至少给定两个线程,一个做数据收集,一个做数据处理。

spark-1.6.1-bin-2.5.0-cdh5.3.6]$ bin/spark-shell --master local[2]
20/01/31 18:31:06 INFO repl.SparkILoop: Created spark context..
Spark context available as sc.
20/01/31 18:31:26 INFO hive.metastore: Trying to connect to metastore with URI thrift://bigdata-senior.ibeifeng.com:9083
20/01/31 18:31:26 INFO hive.metastore: Connected to metastore.
20/01/31 18:31:27 INFO repl.SparkILoop: Created sql context (with Hive support)..
SQL context available as sqlContext.

scala> sc
res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@67565668
scala> import org.apache.spark.streaming._
import org.apache.spark.streaming._
scala> import org.apache.spark.streaming.StreamingContext._
import org.apache.spark.streaming.StreamingContext._
scala> val ssc = new StreamingContext(sc, Seconds(10))
ssc: org.apache.spark.streaming.StreamingContext = org.apache.spark.streaming.StreamingContext@5483020a
scala> val dstream = ssc.socketTextStream("bigdata-senior.ibeifeng.com", 9999)
dstream: org.apache.spark.streaming.dstream.ReceiverInputDStream[String] = org.apache.spark.streaming.dstream.SocketInputDStream@60f5b1db
scala> val resultDStream = dstream.flatMap(_.split(" ")).map((_,1)).reduceByKey(_ + _)
resultDStream: org.apache.spark.streaming.dstream.DStream[(String, Int)] = org.apache.spark.streaming.dstream.ShuffledDStream@2b155889
scala> resultDStream.print()

scala> ssc.start()
scala> ssc.awaitTermination()

(4)关闭服务

[beifeng@bigdata-senior ~]$ jps
2599 DataNode
2931 RunJar
2719 QuorumPeerMain
2797 Kafka
2538 NameNode
4500 Jps
[beifeng@bigdata-senior ~]$ kill -9 2931
[beifeng@bigdata-senior ~]$ jps
2599 DataNode
2719 QuorumPeerMain
2797 Kafka
2538 NameNode
4512 Jps
[beifeng@bigdata-senior ~]$ su root
Password: 
[root@bigdata-senior beifeng]# service mysql stop
Shutting down MySQL..                                      [  OK  ]
[root@bigdata-senior beifeng]# exit
exit
[beifeng@bigdata-senior ~]$ cd /opt/cdh-5.3.6/kafka_2.10-0.8.2.1/
[beifeng@bigdata-senior kafka_2.10-0.8.2.1]$ bin/kafka-server-stop.sh 
[beifeng@bigdata-senior ~]$ cd /opt/modules/zookeeper-3.4.5/
[beifeng@bigdata-senior zookeeper-3.4.5]$ bin/zkServer.sh stop
JMX enabled by default
Using config: /opt/modules/zookeeper-3.4.5/bin/../conf/zoo.cfg
Stopping zookeeper ... STOPPED
[beifeng@bigdata-senior ~]$ cd /opt/cdh-5.3.6/hadoop-2.5.0-cdh5.3.6/
[beifeng@bigdata-senior hadoop-2.5.0-cdh5.3.6]$ sbin/hadoop-daemon.sh stop namenode
stopping namenode
[beifeng@bigdata-senior hadoop-2.5.0-cdh5.3.6]$ sbin/hadoop-daemon.sh stop datanode
stopping datanode
[beifeng@bigdata-senior hadoop-2.5.0-cdh5.3.6]$ jps
4654 Jps

(5)代码实现WordCount程序

package com.ibeifeng.bigdata.spark.app.streaming

import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

object StreamingWordCount {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("streaming-wordcount")
    val sc = SparkContext.getOrCreate(conf)
    /**
      * batchDuration:
      * 给定产生批次的间隔时间,每隔给定的batchDuration就会产生一个批次,产生的批次会先放到一个队列中
      * 后台有一个线程会专门进行批次的执行(每次只执行一个批次)
      * 一般情况下batchDuration设置的时间要比一个批次的执行时间稍微大一点,以避免阻塞
      * 时间类型有:Seconds(),Minutes(),Milliseconds()
      */
    val ssc = new StreamingContext(sc, Seconds(10))
    val dstream = ssc.socketTextStream("bigdata-senior.ibeifeng.com", 9999)
    val resultDStream = dstream.flatMap(_.split(" ")).map(word => {
      (word, 1)
    }).reduceByKey(_ + _)
    resultDStream.print()

    ssc.start()
    ssc.awaitTermination()
  }
}

3、Spark Streaming程序运行原理

(1)数据接收器(Receiver)
Receiver接收数据输入,并将输入的数据形成一个block块存储到内存或磁盘中,并进行备份,设置block形成的间隔时间:

spark.streaming.blockInterval:200ms

一般情况建议将该参数设置为1-2s。
(2)batch批次的产生
每隔batchDuration指定的时间后,产生一个执行批次,这个批次包含了在这个批次时间间隔中接收到的所有数据形成的block块,一般要求batchDuration是blockInterval的整数倍,实质是将这些block块形成一个RDD。
(3)批次对应的RDD Job的执行
一个Job就是一个RDD的Action类型的API触发,一个DStream的执行其实就是RDD的执行,一个Job可以包含多个批次。
(4)DStream
DStream底层是由一系列的RDD和时间组成的集合,每个RDD包含了对应批次的数据,DStream的API的调用实际上底层都是RDD的调用。
一个DStream依赖于其他的DStream,DStream存在批次的间隔时间,每隔time interval产生对应批次的RDD,每个DStream中有一个compute的函数供该批次执行。
(5)RDD的销毁
在下下一个批次执行的时候,当前批次的RDD会被销毁,条件是该RDD已经执行过,而且StreamingContext中没有对该RDD有任何依赖,其它DStream对当前RDD也没有任何依赖。
可以考虑通过StreamingContext的remember函数更改RDD的生命周期长度,要求参数比原始的batchDuration大:

ssc.remember(Seconds(60))

(6)Streaming的数据读取
1)Basic Sources
基于StreamingContext的API读取数据。
数据的接收方式只有一种:基于Receiver的数据接收方式,即push的数据接收方式。
2)Advanced Sources
基于外部API读取数据,比如Kafka/Flume等。
数据接收方式有两种(一般都有两种,或者说kafka和flume有两种):
a)Use Receiver(使用数据接收器,push方式):
在正常的业务Job之外,启动一个数据接收Job,专门负责将数据保存到当前执行的内存或磁盘中,RDD中保存的其实是block的id。
b)Direct Approach(直接连接方式,poll方式):
StreamingContext形成RDD的过程中,RDD中保存的是数据存储的位置信息以及相关参数,直到job被真正运行的时候,会直接从数据产生方根据保存的相关参数获取数据。

4、Spark Streaming和Kafka的集成

Spark Streaming可以和Flume、Kafka、Kinesis等进行集成。
Spark Streaming和Kafka的集成:
(1)Use Receiver
基于Kafka的High Level Consumer API进行开发和数据读取,最终执行RDD的Task数量实质上和形成的block数量一致。

KafkaUtils.createStream[String, String, StringDecoder, StringDecoder](
      ssc, kafkaParams, topics, StorageLevel.MEMORY_AND_DISK_SER_2)

kafkaParams:Kafka High Level Consumer API的相关配置参数,比如Group Id、Zookeeper的连接信息等等
topics:指定Spark Streaming(Kafka的消费者)获取哪些Topic的数据,以及获取这些数据的线程数量

(2)Direct Approach
基于Simple Consumer API进行开发和数据读取,最终执行RDD的Task数量实质上和Kafka对应分区数量一致。

KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)

kafkaParams:指定使用simple consumer api的时候需要使用到的相关参数,主要是metadata.broker.list和auto.offset.reset
topics:指定streaming消费的kafka的topic名称

KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder, String](ssc, kafkaParams, fromOffsets, messageHandler)

kafkaParams:指定使用simple consumer api的时候需要使用到的相关参数,主要是metadata.broker.list
fromOffsets:指定stremaing消费哪些topic的哪些partiton的偏移量是多少
messageHandler:对kafka的数据进行具体的操作,可以从中获取offset、partition、topic、key、message,需要给定一个匿名函数

(3)Spark Streaming和Kafka的优化方式
1)将spark.streaming.blockInterval参数进行调整(最小要求大于50ms),以适应RDD的Task数量
2)对于使用数据接收器的形式,可以考虑使用多个数据接收器,然后使用union API合并dstream
3)Direct形式下,将:
a)spark.streaming.backpressure.enabled:false,改成true,表示开启输入数据量动态调整
b)spark.streaming.receiver.maxRate:none,指定每个receiver每一个执行批次中能够接收的数据量大小
c)spark.streaming.kafka.maxRatePerPartition:none, 指定direct模式下,每个partition(也就是每个RDD的Task)最多读取的数据量条数。
(4)Spark Streaming和Kafka集成的Consumer偏移量管理方式
为了当失败或异常产生时,修复bug后,进行恢复机制
1)Use Receiver
只能基于Kafka自带的offset管理机制来管理offset偏移量(间隔性的将offset上传到zk中)(存在着重复消费的问题)。
2)Direct Approach
a)在自定义的messageHandler中将获取的偏移量保存到其它第三方的存储系统中,下次恢复的时候,再读取第三方的存储数据进行恢复操作(存在着数据不消费的问题)。
b)使用Spark Streaming的HA恢复机制,会将DStream的相关元数据保存到给定的checkpointdir文件夹中,一般存储位置为hdfs,在下次进行恢复的时候,会自动从checkpointdir文件夹中进行数据恢复操作,一般使用该方式管理direct模式下与kafka集成的offset偏移量。
(5)Spark Streaming HA功能
提供了一种元数据恢复的功能,方便解决一些应用宕机后的恢复问题。

5、Spark Streaming的常用API

(1)Transform API
直接操作DStream中的当前Job或当前批次对应的RDD,来替换DStream的操作。
(2)数据输出
1)直接调用DStream的相关API进行数据输出。

dstream.saveAs####

2)通过foreachRDD API将DStream当前批次的数据操作转换为RDD的数据操作,和transform API类似,区别在于foreachRDD API没有数据返回。
a)调用rdd的saveAsXXX相关API输出数据。
b)调用rdd的foreachPartition API自定义数据输出代码进行数据输出。
c)将rdd转换为dataframe进行dataframe数据输出。
(3)updateStateByKey
updateStateByKey一般情况下和Spark Streaming的HA一起使用,应用于需要累加数据的场景。updateStateByKey必须给定checkpoint的文件夹路径。
(4)reduceByKeyAndWindow 窗口函数
对每三秒钟的数据执行一次滑动窗口计算,这3秒内的3个RDD会被聚合起来进行处理,然后过了两秒钟,又会对最近三秒内的数据执行滑动窗口计算。所以每个滑动窗口操作,都必须指定两个参数,窗口长度以及滑动间隔,而且这两个参数值都必须是batch间隔的整数倍。

val windowedWordCounts = pairs.reduceByKeyAndWindow((a:Int, b:Int) => (a+b), Seconds(30), Seconds(10))

应用场景:计算最近一段时间的数据。
窗口函数相关API必须给定checkpoint的文件夹路径。

  1. Spark Streaming用于实时统计,基本的API或者RDD相关的API就可以实现。
  2. updateStateByKey用于实时累加统计。
  3. reduceByKeyAndWindow窗口函数用于最近一段时间的统计。

你可能感兴趣的:(BigData,BigData,Components)