Spark Streaming消费Kafka直连(Direct)方式实现数据零丢失

date: 2018-08-16 22:24:26

DStream的理解

Dstream是Spark Streaming中的一个最基本的抽象，代表了一系列连续的数据，本质上是一系列连续的RDD，对DStream进行操作，就是对RDD进行操作。

DStream可以认为是一个RDD的工厂，该DStream中生产的都是相同业务逻辑的RDD，只不过是RDD里面要读取的数据是不同的。

DStream每隔一段时间生个一个RDD，对DStream进行操作，本质上是对里面的对应时间的RDD进行操作。

DStream和DStream之间存在依赖关系，在一个固定时间点，多个存在依赖关系的DStream，对应的RDD存在依赖关系，每隔一个固定时间，其实生成一个小的DAG，周期性的将小DAG提交到集群中运行。

Spark Streaming消费Kafka的两种方式

官网：Spark Streaming + Kafka Integration Guide

基于 Receiver-based 的 createStream 方法

Receiver接收固定时间间隔的数据（放在内存中），达到固定的时间才进行处理，使用Kafka高级API：createStream，自动维护偏移量，效率低并且容易丢数据。
（Kafka broker version 0.10.0 or higher 已废弃Receiver方式）

Direct Approach 方式的 createDirectStream 方法

Direct直连方式，相当于直接连接到Kafka的分区上，使用Kafka底层API：createDirectStream，效率高，需要我们自己维护偏移量。

直连方式的Scala实现

在单机模式下做的小实验，Zookeeper、Kafka和Spark都是单机模式。

启动Zookeeper（这里使用的是Kafka里自带的Zookeeper服务）

$ bin/zookeeper-server-start.sh config/zookeeper.properties

启动Kafka Server

$ bin/kafka-server-start.sh config/server.properties

创建Topic

$ bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partition 1 --topic wordcount

往Topic中写数据

$ bin/kafka-console-producer.sh --broker-list localhost:9092 --topic wordcount

hello world
hello yz hello zeno
...

KafkaDirectWordCountV2.scala

package cn.yz0515.streaming

import kafka.common.TopicAndPartition
import kafka.message.MessageAndMetadata
import kafka.serializer.StringDecoder
import kafka.utils.{ZKGroupTopicDirs, ZkUtils}
import org.I0Itec.zkclient.ZkClient
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.{HasOffsetRanges, KafkaUtils, OffsetRange}
import org.apache.spark.streaming.{Duration, StreamingContext}

object KafkaDirectWordCountV2 {
  def main(args: Array[String]): Unit = {
    // 指定组名
    val group = "g001"
    // 创建SparkConf
    val conf = new SparkConf().setAppName("KafkaDirectWordCount").setMaster("local[*]")
    // 创建StringContext，并设置时间间隔
    val ssc = new StreamingContext(conf, Duration(5000))
    // 指定消费者的topic名字
    val topic = "wordcount"
    // 指定Kafka的broker地址（sparkStream的Task直连到Kafka的分区上，用更加底层的API消费，效率更高）
    val brokerList = "localhost:9092"
    // 指定zk地址，后期更新消费的偏移量时使用，以后可以使用redis或者MySQL来记录偏移量
    val zkQuorum = "localhost:2181"
    // 创建stream时使用的topic名字集合，SparkStreaming可以从多个topic中同时消费
    val topics = Set(topic)
    // 创建一个ZKGroupTopicDirs对象，其实是指定往zk中写入数据的目录，用于保存偏移量
    val topicDirs = new ZKGroupTopicDirs(group, topic)
    // 获取zookeeper中的路径 "/g001/offsets/wordcount"
    val zkTopicPath = s"${topicDirs.consumerOffsetDir}"

    // 准备Kafka的参数
    val kafkaParams = Map(
      "metadata.broker.list" -> brokerList,
      "group.id" -> group,
      //"zookeeper.connect" -> zkQuorum,
      // 从头开始读数据
      "auto.offset.reset" -> kafka.api.OffsetRequest.SmallestTimeString
    )

    // zookeeper的host和ip，创建一个client，用于更新偏移量的
    // 是zookeeper的客户端，可以从zk中读取偏移量数据，并更新偏移量
    val zkClient = new ZkClient(zkQuorum)

    // 查询该路径下是否子节点（默认有字节点为我们自己保存不同Partition时生成的）
    // /g001/offsets/wordcount/0/10001
    // /g001/offsets/wordcount/1/30001
    // /g001/offsets/wordcount/2/10001
    val children = zkClient.countChildren(zkTopicPath)

    var kafkaStream: InputDStream[(String, String)] = null

    var fromOffsets: Map[TopicAndPartition, Long] = Map()

    // 如果保存过 offset
    if (children > 0) {
      for (i <- 0 until children) {
        // /g001/offsets/wordcount/0
        val partitionOffset = zkClient.readData[String](s"$zkTopicPath/${i}")
        // wordcount/0
        val tp = TopicAndPartition(topic, i)
        // 将不同partition对应的offset增加到fromOffsets
        // wordcount/0 -> 10001
        fromOffsets += (tp -> partitionOffset.toLong)
      }

      // Key: kafka的Key values: "hello tom hello jerry"
      // 这个会将Kafka的消息进行transform，最终Kafka的数据都会变成（KafkaKey， message）这样的tuple
      val messageHandler = (mmd: MessageAndMetadata[String, String]) => (mmd.key(), mmd.message())

      // 通过KafkaUtils创建直连的DStream（fromOffsets参数的作用：按照前面计算好了的偏移量继续消费数据）
      // [String, String, StringDecoder, StringDecoder, (String, String)]
      // key value key的解码方式 value的解码方式
      kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder, (String, String)](ssc, kafkaParams, fromOffsets, messageHandler)
    } else {
      // 如果未保存，根据KafkaParam的配置使用最新（largest）或者最旧的（smallest）offset
      kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)
    }

    // 偏移量的范围
    var offsetRanges = Array[OffsetRange]()

    // V1版本
    /*// 从Kafka读取的消息，DStream的Transform方法可以将当前批次的RDD获取出来
    // 该transform方法计算获取到当前批次RDD，然后将RDD的偏移量取出来，然后再将RDD返回到DStream中
    val transform = kafkaStream.transform{rdd =>
      offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      rdd
    }

    val message: DStream[String] = transform.map(_._2)*/

    // V2版本
    // 直连方式只有在KafkaDStream的RDD中才能获取偏移量，那么就不能调用DStream的Transformation
    // 所以只能在KafkaDStream调用foreachRDD，获取RDD的偏移量，然后就是对RDD进行操作
    // 依次迭代KafkaDStream中的KafkaRDD
    kafkaStream.foreachRDD { kafkaRDD =>
      if (!kafkaRDD.isEmpty()) {

        // 只有KafkaRDD可以强转成HasOffsetRanges，并获取偏移量
        offsetRanges = kafkaRDD.asInstanceOf[HasOffsetRanges].offsetRanges
    
        val lines: RDD[String] = kafkaRDD.map(_._2)
    
        // 业务逻辑
        // 对RDD进行操作，触发Action
        lines.foreachPartition(partition =>
          partition.foreach(x => {
            println(x)
          })
        )

        // 更新偏移量到Zookeeper
        for (o <- offsetRanges) {
          // /g001/offsets/wordcount/0
          val zkPath = s"${topicDirs.consumerOffsetDir}/${o.partition}"
          // 将该partition的offset保存到zookeeper
          // /g001/offsets/wordcount/0/20000
          ZkUtils.updatePersistentPath(zkClient, zkPath, o.untilOffset.toString)
        }
      }  
    }

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

Maven依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>2.2.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-client -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-client</artifactId>
      <version>2.7.6</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.scala-lang/scala-library -->
    <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>2.11.11</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>2.2.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.11</artifactId>
      <version>2.2.0</version>
    </dependency>
     <!--https://mvnrepository.com/artifact/org.apache.spark/spark-streaming-kafka-->
    <!--<dependency>-->
      <!--<groupId>org.apache.spark</groupId>-->
      <!--<artifactId>spark-streaming-kafka-0-10_2.11</artifactId>-->
      <!--<version>2.2.0</version>-->
    <!--</dependency>-->

    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming-kafka -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
      <version>2.2.0</version>
    </dependency>
  </dependencies>