SparkStreaming与Kafka整合及相关案例

目录

 

1、SparkStreaming与Kafka-0-8整合

1.1、Receiver-based Approach（不推荐使用）

1.2、Direct Approach (No Receivers)

1.3、SparkStreaming与Kafka0.8版本整合数据不丢失方案（自己管理offset）

2、SparkStreaming与Kafka-0-10整合

2.1、只有Direct Approach (No Receivers)

2.2、SparkStreaming与Kafka0.10版本整合数据不丢失方案（自己管理offset）

2.3、SparkStreaming应用程序如何保证Exactly-Once

---

1、SparkStreaming与Kafka-0-8整合

1.1、Receiver-based Approach（不推荐使用）

（1）使用Receiver接收数据。

Receiver是使用Kafka高级消费者API实现的。

从Kafka通过Receiver接收的数据存储在Spark执行器中，然后由Spark Streaming启动的作业处理数据。但是，在默认配置下，此方法可能会在失败时丢失数据（接收器可靠性，如图）。

为确保零数据丢失，必须在Spark Streaming中另外启用Write Ahead Logs（在Spark 1.2中引入）。这将同步保存所有收到的Kafka将数据写入分布式文件系统（例如HDFS）上的预写日志，以便在发生故障时可以恢复所有数据，但是性能不好。

（2）相关代码说明：

 val kafkaStream = KafkaUtils.createStream(streamingContext,
     [ZK quorum], [consumer group id], [per-topic number of Kafka partitions to consume])

（3）相关案例展示

导入pom依赖包：

     org.apache.spark
      spark-streaming-kafka-0-8_2.11
     ${spark.version}
 

scala代码：

import kafka.serializer.StringDecoder
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**StreamingContext
 * 基于receiver
 * 0.8版本
 *
 * 简单知道就可以，因为这个在工作不用
 */
object ReceiverKafkaWordCount {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.ERROR)
    //步骤一：初始化程序入口
    val sparkConf = new SparkConf().setMaster("local[2]").setAppName("ReceiverKafkaWordCount")
    val ssc = new StreamingContext(sparkConf, Seconds(5))

    val kafkaParams =  Map[String, String](
      "zookeeper.connect"->"hadoop2:2181,hadoop3:2181,hadoop1:2181",
      "group.id" -> "testflink"
    )

    val topics = "flink".split(",").map((_,1)).toMap
    //步骤二：获取数据源
    //默认只会有一个receiver（3 consumer）
//
//    val lines = KafkaUtils.createStream[String,String,StringDecoder,StringDecoder](
//     ssc,kafkaParams,topics, StorageLevel.MEMORY_AND_DISK_SER_2)

    val kafkaStreams = (1 to 20).map(_ => {
      KafkaUtils.createStream[String, String, StringDecoder, StringDecoder](
        ssc, kafkaParams, topics, StorageLevel.MEMORY_AND_DISK_SER)
    })

    val lines = ssc.union(kafkaStreams)

    //步骤三：业务代码处理
    lines.map(_._2).flatMap(_.split(",")).map((_,1)).reduceByKey(_+_).print()
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }
}

1.2、Direct Approach (No Receivers)

这种方式会周期性地查询Kafka，来获得每个topic+partition的最新的offset，从而定义每个batch的offset的范围。当处理数据的job启动时，就会使用Kafka的简单consumer api来获取Kafka指定offset范围的数据。
（1）这种方式有的优点：

• 1、简化并行度：如果要读取多个partition，不需要创建多个输入DStream然后对它们进行union操作。Spark会创建跟Kafka partition一样多的RDD partition，并且会并行从Kafka中读取数据。所以在Kafka partition和RDD partition之间，有一个一对一的映射关系。
• 2、高性能：如果要保证零数据丢失，在基于receiver的方式中，需要开启WAL机制。这种方式其实效率低下，因为数据实际上被复制了两份，Kafka自己本身就有高可靠的机制，会对数据复制一份，而这里又会复制一份到WAL中。而基于direct的方式，不依赖Receiver，不需要开启WAL机制，只要Kafka中作了数据的复制，那么就可以通过Kafka的副本进行恢复。
• 3、一次且仅一次的事务机制：
• 基于receiver的方式，是使用Kafka的高阶API来在ZooKeeper中保存消费过的offset的。这是消费Kafka数据的传统方式。这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是却无法保证数据被处理一次且仅一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。
• 4、降低资源。
• Direct不需要Receivers，其申请的Executors全部参与到计算任务中；而Receiver-based则需要专门的Receivers来读取Kafka数据且不参与计算。因此相同的资源申请，Direct 能够支持更大的业务。
• 5、降低内存。
• Receiver-based的Receiver与其他Exectuor是异步的，并持续不断接收数据，对于小业务量的场景还好，如果遇到大业务量时，需要提高Receiver的内存，但是参与计算的Executor并无需那么多的内存。而Direct 因为没有Receiver，而是在计算时读取数据，然后直接计算，所以对内存的要求很低。实际应用中我们可以把原先的10G降至现在的2-4G左右。
• 6、鲁棒性更好。
• Receiver-based方法需要Receivers来异步持续不断的读取数据，因此遇到网络、存储负载等因素，导致实时任务出现堆积，但Receivers却还在持续读取数据，此种情况很容易导致计算崩溃。Direct 则没有这种顾虑，其Driver在触发batch 计算任务时，才会读取数据并计算。队列出现堆积并不会引起程序的失败。

（2）相关代码说明：

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

（3）相关案例展示：

import kafka.serializer.StringDecoder
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}

object DirectKafkaWordCount {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.ERROR)
    //步骤一：初始化程序入口
    val sparkConf = new SparkConf().setMaster("local[2]").setAppName("DirectKafkaWordCount")
    val ssc = new StreamingContext(sparkConf, Seconds(5))
    /**
     *
     * 0.8 API  -> 消费  1.0集群的数据 的
     *
     *
     */
    val kafkaParams =  Map[String, String](
      "bootstrap.servers"->"node01:9092",
      "group.id" -> "testsparkstreaming",
      "enable.auto.commit" -> "false"   //自动提交关闭
    )
    val topics = "flink".split(",").toSet
    /**
     *
     * ssc: StreamingContext,
     * kafkaParams: Map[String, String],
     * topics: Set[String]
     * StringDecoder：反序列化器
     */
    val lines = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
              ssc,
              kafkaParams,
              topics).map(_._2)

    val result = lines.flatMap(_.split(",")).map((_, 1))
      .reduceByKey(_ + _)

    result.print()
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()

  }
}

在节点node01启动socket server 服务器：nc –lk 9999，输入相关消息数据，观察控制台。

要想保证数据不丢失，最简单的就是靠checkpoint的机制，但是checkpoint机制有个特点，以后代码升级了，checkpoint机制就失效了。所以如果想实现数据不丢失，那么就需要自己管理offset。

1.3、SparkStreaming与Kafka0.8版本整合数据不丢失方案（自己管理offset）

0.8版，offset偏移量存储在zookeeper中。

代码步骤：

• 1）编写类继承Serializable类；
• 2）创建数据流createDirectStream方法；
• 3）调用setOrUpdateOffsets方法先根据实际情况更新offsets；（在zookeeper读取offsets之前操作）
• 4）编写更新方法setOrUpdateOffsets；
•              1、遍历topic，获取分区；（对分区的判断）
•              2、根据groupId和分区，获取消费者消费者offsetsE
•              3、判断是否消费过。如果消费过，则更新；如果没有消费，则获取消费者offserts
• 5）从zookeeper上读取offsets，开始消费message（利用kafka工具类调用createDirectStream方法）
• 6）创建createDirectStream的java对象
• 7）更新zookeeper上的offsets；
• 8）写监听类，用于判断任务是否失败，若失败，则终止offsets提交；若正常，则将offsets存入zookeeper中

import kafka.common.TopicAndPartition
import kafka.message.MessageAndMetadata
import kafka.serializer.Decoder
import org.apache.spark.{SparkContext, SparkException}
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.StreamingContext
import org.apache.spark.streaming.api.java.{JavaPairInputDStream, JavaStreamingContext}
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka.{HasOffsetRanges, KafkaCluster, KafkaUtils}
import org.apache.spark.streaming.kafka.KafkaCluster.LeaderOffset
import java.util.{Map => JMap, Set => JSet}

import scala.collection.JavaConverters._

import scala.reflect.ClassTag


/**
  * 自己管理offset
  * 0.8版偏移量存储在zookeeper中
  * @param kafkaParams
  */
class KafkaManager (val kafkaParams:Map[String,String]) extends Serializable {
  private val kc = new KafkaCluster(kafkaParams) //创建kafka集群对象

  //（2）先根据实际情况更新offsets
//--------------------------------------------
  private def setOrUpdateOffsets(topics: Set[String], groupId: String): Unit = {
    topics.foreach(topic =>{
      var hasConsumed = true
      val partitionsE = kc.getPartitions(Set(topic))
      if (partitionsE.isLeft){    //Left包含错误或无效值， Right包含正确或有效值。
        throw new SparkException(s"get kafka partition failed:${partitionsE.left.get}")
      }

      val partitions = partitionsE.right.get    //获取正确的值
      val consumerOffsetsE = kc.getConsumerOffsets(groupId,partitions)  //获取消费offsets
      if (consumerOffsetsE.isLeft) hasConsumed = false
      if (hasConsumed){  //消费过
        /**
          * 如果streaming程序执行的时候出现kafka.common.OffsetOutOfRangeException，
          * 说明zk上保存的offsets已经过时了，即kafka的定时清理策略已经将包含该offsets的文件删除。
          * 针对这种情况，只要判断一下zk上的consumerOffsets和earliestLeaderOffsets的大小，
          * 如果consumerOffsets比earliestLeaderOffsets还小的话，说明consumerOffsets已过时,
          * 这时把consumerOffsets更新为earliestLeaderOffsets
          */
        val earlistLeaderOffsetsE = kc.getEarliestLeaderOffsets(partitions)
        if (earlistLeaderOffsetsE.isLeft){
          throw new SparkException(s"get earlist leader offsets failed:${earlistLeaderOffsetsE.left.get}")
        }
        val earlistLeaderOffsets = earlistLeaderOffsetsE.right.get  //获取earlistLeaderOffsets
        val consumerOffsets = consumerOffsetsE.right.get

        //可能只是存在部分分区consumerOffsets过时，所以只更新过时分区的consumerOffsets为earlistLeaderOffsets
        var offsets:Map[TopicAndPartition,Long] = Map()
        consumerOffsets.foreach({ case (tp,n)=>
          val earlistLeaderOffset = earlistLeaderOffsets(tp).offset
          if (n < earlistLeaderOffset){         //比较
            println("consumer group:"+groupId+",topic:"+tp.topic+",partition:"+tp.partition+"offsets已经过时，更新为"+earlistLeaderOffset)
            offsets +=(tp ->earlistLeaderOffset)    //lambda表达式
          }
        })

        if (!offsets.isEmpty){   //判断offsets是否为空，
          kc.setConsumerOffsets(groupId,offsets)     //设置消费offset
        }
      }else{ //没有消费过
        val reset = kafkaParams.get("auto.offset.reset").map(_.toLowerCase())

        var leaderOffsets:Map[TopicAndPartition,LeaderOffset] = null
        if (reset ==Some("smallest")){
          val leaderOffsetsE = kc.getEarliestLeaderOffsets(partitions)
          if (leaderOffsetsE.isLeft){
            throw new SparkException(s"get earlist leader offsets failed:${leaderOffsetsE.left.get}")

          }
          leaderOffsets = leaderOffsetsE.right.get
        }else{
          val leaderOffsetsE = kc.getLatestLeaderOffsets(partitions)
          if (leaderOffsetsE.isLeft){
            throw new SparkException(s"get latest leader offsets failed:${leaderOffsetsE.left.get}")
          }
          leaderOffsets = leaderOffsetsE.right.get

        }     
          val offsets = leaderOffsets.map{
          case (tp,offset) =>(tp,offset.offset)
        }
        kc.setConsumerOffsets(groupId,offsets)    //设置消费offset
      }
    })
  }
//-------------------------------------------------

  //（1）创建数据流
  def createDirectStream[K:ClassTag,V:ClassTag,KD <: Decoder[K]:ClassTag,VD <: Decoder[V]:ClassTag](
                                                                                                                          ssc:StreamingContext,
                                                                                                       kafkaParams:Map[String,String],
                                                                                                      topics:Set[String]
                                                                                                   ):InputDStream[(K, V)] = {
    val groupId = kafkaParams.get("group.id").get

    //在zookeeper上读取offset前，先根据实际情况更新offsets
    setOrUpdateOffsets(topics, groupId)    //（2）创建更新offsets方法

    //（3）从zookeeper上读取offset开始消费message
    val messages = {
      val partitionsE = kc.getPartitions(topics)   //获取topic
      if (partitionsE.isLeft) {
        throw new SparkException(s"get kafka partition failed: ${partitionsE.left.get}")
      }

      val partitions = partitionsE.right.get
      val consumerOffsetsE = kc.getConsumerOffsets(groupId, partitions)
      if (consumerOffsetsE.isLeft) {
        throw new SparkException(s"get kafka consumer offsets failed:${consumerOffsetsE.left.get}")
      }
      val consumerOffsets = consumerOffsetsE.right.get

      KafkaUtils.createDirectStream[K, V, KD, VD, (K, V)](    //调用kafka工具，创建createDirectStream
        ssc, kafkaParams, consumerOffsets, (mmd: MessageAndMetadata[K, V]) => (mmd.key, mmd.message)
      )
    }
    messages
  }

//（4）创建createDirectStream的java对象
  def createDirectStream[K,V,KD <: Decoder[K],VD <:Decoder[V]](
    jssc:JavaStreamingContext,
    keyClass:Class[K],
    valueClass:Class[V],
    keyDecoderClass:Class[KD],
    valueDecoderClass:Class[VD],
    kafkaParams:JMap[String,String],
    topics:JSet[String]

  ):JavaPairInputDStream[K,V] ={
    implicit val keyCmt: ClassTag[K] = ClassTag(keyClass)
    implicit val valueCmt: ClassTag[V] = ClassTag(valueClass)
    implicit val keyDecoderCmt: ClassTag[KD] = ClassTag(keyDecoderClass)
    implicit val valueDecoderCmt: ClassTag[VD] = ClassTag(valueDecoderClass)
  }

  createDirectStream[K, V, KD, VD](jssc.ssc,  Map(kafkaParams.asScala.toSeq: _*),
    Set(topics.asScala.toSeq: _*));


  /**
    * （5）更新zookeeper上的消费offsets
    */
  def updateZKOffsets[K,V](rdd:RDD[(K,V)]):Unit={
    val groupId = kafkaParams.get("group.id").get
    val offsetsList = rdd.asInstanceOf[HasOffsetRanges].offsetRanges

    for (offsets <- offsetsList){
      val topicAndPartition = TopicAndPartition(offsets.topic,offsets.partition)
      val o = kc.setConsumerOffsets(groupId,Map((topicAndPartition,offsets.untilOffset)))
      if (o.isLeft){
        println(s"Error updating the offset to kafka cluster:${o.left.get}")
      }
    }
  }

}

（6）写一个监听类，继承StreamingListener类，防止任务失败的时候偏移量提交。

import kafka.common.TopicAndPartition;
import org.apache.spark.streaming.kafka.KafkaCluster;
import org.apache.spark.streaming.kafka.OffsetRange;
import org.apache.spark.streaming.scheduler.*;
import scala.Option;
import scala.collection.JavaConversions;
import scala.collection.immutable.List;
import java.util.HashMap;
import java.util.Map;

public class MyListener implements StreamingListener {
    private KafkaCluster kc;
    public scala.collection.immutable.Map  kafkaParams;
    public MyListener(scala.collection.immutable.Map kafkaParams){
        this.kafkaParams=kafkaParams;
        kc = new KafkaCluster(kafkaParams);
    }


    @Override
    public void onReceiverStarted(StreamingListenerReceiverStarted receiverStarted) {

    }

    @Override
    public void onReceiverError(StreamingListenerReceiverError receiverError) {

    }

    @Override
    public void onReceiverStopped(StreamingListenerReceiverStopped receiverStopped) {

    }

    @Override
    public void onBatchSubmitted(StreamingListenerBatchSubmitted batchSubmitted) {

    }

    @Override
    public void onBatchStarted(StreamingListenerBatchStarted batchStarted) {

    }

    /**
     * 批次完成时调用的方法
     * @param batchCompleted
     */
    @Override
    public void onBatchCompleted(StreamingListenerBatchCompleted batchCompleted) {

        //如果本批次里面有任务失败了，那么就终止偏移量提交
        scala.collection.immutable.Map opsMap = batchCompleted.batchInfo().outputOperationInfos();
        Map javaOpsMap = JavaConversions.mapAsJavaMap(opsMap);
        for (Map.Entry entry : javaOpsMap.entrySet()) {
            //failureReason不等于None(是scala中的None),说明有异常，不保存offset
            if (!"None".equalsIgnoreCase(entry.getValue().failureReason().toString())) {
                return;
            }
        }

        long batchTime = batchCompleted.batchInfo().batchTime().milliseconds();

        /**
         * topic，分区，偏移量
         */
        Map> offset = getOffset(batchCompleted);

        for (Map.Entry> entry : offset.entrySet()) {
            String topic = entry.getKey();
            Map paritionToOffset = entry.getValue();

            //把偏移信息放入到zookeeper就可以了。
            for(Map.Entry p2o : paritionToOffset.entrySet()){
                Map map = new HashMap();

                TopicAndPartition topicAndPartition = new TopicAndPartition(topic,p2o.getKey());

                map.put(topicAndPartition,p2o.getValue());

                scala.collection.immutable.Map
                        topicAndPartitionObjectMap = TypeHelper.toScalaImmutableMap(map);   //调用TypeHelper类

                kc.setConsumerOffsets(kafkaParams.get("group.id").get(), topicAndPartitionObjectMap);
            }

        }
    }

    @Override
    public void onOutputOperationStarted(StreamingListenerOutputOperationStarted outputOperationStarted) {

    }

    @Override
    public void onOutputOperationCompleted(StreamingListenerOutputOperationCompleted outputOperationCompleted) {

    }

    private Map> getOffset(StreamingListenerBatchCompleted batchCompleted) {
        Map> map = new HashMap<>();

        scala.collection.immutable.Map inputInfoMap =
                batchCompleted.batchInfo().streamIdToInputInfo();
        Map infos = JavaConversions.mapAsJavaMap(inputInfoMap);

        infos.forEach((k, v) -> {
            Option