使用SparkStreaming获取Kafka中的流式数据并指定手动提交offset

最新推荐文章于 2023-02-20 17:25:30 发布

大数据面壁者

最新推荐文章于 2023-02-20 17:25:30 发布

阅读量1.8k

点赞数 2

分类专栏：代码 spark kafka 文章标签：大数据 spark kafka 数据流

本文链接：https://blog.csdn.net/weixin_42796403/article/details/113315272

版权

代码同时被 3 个专栏收录

73 篇文章 2 订阅

订阅专栏

spark

30 篇文章 1 订阅

订阅专栏

kafka

5 篇文章 1 订阅

订阅专栏

概述

本篇文章主要有三个示例代码，第一个是基础版使用SparkStreaming读取kafka中的流式数据，但是此种方式使用的是自动提交offset的方式，可能会出现offset已提交，但是数据处理过程中出错，导致数据丢失的情况，所以进行了改进，当数据处理完毕后使用手动提交offset的方法。

第二个代码示例是使用指定checkpoint的方式保存offset，此种方式代码会有点复杂，而且有个大问题，会生成很多小文件，需要自己在编写程序去定期处理，所以也不是很建议。第三个代码示例是调用官方api将offset保存到_consumer_offset主题中，所以建议读者直接使用此种方式。此外还可以将offset保存到指定位置，例如musql，redis。

题外话：sparkstreaming毕竟不是真正的实时计算，而是原理是将数据流离散化为一个一个的微分段，在精准一致的消费流式数据上远没有flink方便！！！所以sparkstreamign只建议使用在对实时性要求在秒级查询得场景！！！

一，连接kafak获取数据

1.1 创建kafkaStream的方法

  def createDirectStream[K, V](
      ssc: StreamingContext,   //应用上下文
      locationStrategy:  LocationStrategy,
      consumerStrategy: ConsumerStrategies[K, V]
  ): InputDStream[ConsumerRecord]

1.2 locationStrategy:kafka分区消费的策略

 LocationStrategies.PreferConsistent：
       大部分情况下都是传入此方法,适用于YARN集群和Kafka集群各自独立的情况！
       尽量在所有的executor上负载均衡的分配Kafka的分区！
       
 LocationStrategies.PreferBrokers:
       仅仅在kafka和Yarn使用同一集群的情况下！每个节点都有NM，Broker时使用！
       （但是NM和Broker都是大量消耗磁盘IO的进程，不建议安装在同一台服务器上）
       
  LocationStrategies.PreferFixed:
       在负载不均衡时，自己指定那些host的executor消费那些特定的分区！！！

1.3 consumerStrategy: kafka中数据的消费策略

大部分情况下传入   ConsumerStrategies.Subscribe
 
kafka中的消费策略：
    独立消费者：不依赖于kafak集群！！！
               消费的offset不需要借助kafka集群进行存储，自动存储到consumer_offsets主题中
               不需要kafak集群分配分区，直接在线程中指定，要消费那个主题的那个分区！！！
               
    非独立消费者：依赖于kafka集群！！！
               消费的offset，需要借助于kafka集群自动存储到consumer_offsets
               需要kafka集群为一个消费者组中的多个消费者线程分配分区

1.4 代码

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}

object StreamingKafak {
  
  def main(args: Array[String]): Unit = {
  
    //每三秒采集一次数据
    val streaming: StreamingContext = new StreamingContext("local[*]","kafak_test",Seconds(3))
    
    //设置采集kafka数据的相关参数
    val kafkaParams:Map[String,String]=Map[String,String](
      "group.id"->"testKafka",
      "bootstrap.servers"->"hadoop102:9092,hadoop103:9092",
      "enable.auto.commit"->"true",
      "auto.commit.interval.ms"->"500",
      "auto.offset.reset"->"earliest",
      "client.id"->"client1",
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
    )
  
    //从kafka中消费数据，获取DStream
    val ds: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      streaming,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe[String, String](List("spark"), kafkaParams)
    )
    
   //获取所有value的集合
    val result1 = ds.map(_.value())
  
    result1.print(1000)
   
    
    //启动应用
    streaming.start()
    
    //一直阻塞进程，直到手动调用stop或者异常终止
    streaming.awaitTermination()
  
  } 
}

1.5 pom文件依赖

    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.12</artifactId>
            <version>3.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.12</artifactId>
            <version>3.0.0</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.10.1</version>
        </dependency>
    </dependencies>

二、使用Checkpoint方式手动提交offset

基础版中kafka消费的的offset是自动提交的，可能出现已经提交了offset，但是消费到的数据在没有及时处理完成时，出现程序崩溃的情况！！！会造成数据丢失！！！

2.1 解决方案：

不能在数据处理完成之前提交offset！只能解决不丢数据（at least once），不能保证 精准一致性消费（exectly once）！！如果需要实现exactly once，需要在at least once的基础上借助 幂等操作|事务 实现

保证at least once核心在于不能在数据处理完成之前提交offset！！！
取消offset的自动提交，改为手动提交！！！

2.2 自己维护offset

根据存储位置的不同，分为以下三类：

将offset存储到文件系统中：spark提供了checkpoint机制！！！

    调用checkpoint，会检查ck目录是否设置，之后会创建ReliableRDDCheckpointData，顺便将Driver的状态也保存到文件
 系统，发生故障时Driver通过读取之前保存的状态来恢复，重建状态，继续运行！  (如果一个saprkstreaming消费kafka程序，
 状态将含有offset)
 
 
  checkpoint的作用：
         a) 将RDD中数据，持久化到文件系统
         b） 用于故障恢复！
                    
  采用checkpoint的弊端：每个采集周期都会向ck目录保存状态，因此会生成大量小文件！！！

将offset提交到_consumer_offset主题中，需要调用官方的api
将offset维护到任意位置，例如mysql，redis

SparkStreaming获取kafka数据官网配置： http://spark.apache.org/docs/latest/streaming-kafka-0-10-integration.html

2.3 代码

package com.saprkstreaming.kafka

import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object KafkaStreamingExection {
  
  def main(args: Array[String]): Unit = {
    
    //要求在重建StreamingContext的函数中，必须包含重建的所有逻辑
    def createStreamingContext()= {
  
      //每三秒采集一批数据
      val context = new StreamingContext("local[*]", "testPark", Seconds(3))
  
      //设置ck目录
      context.checkpoint("ck")
      
      //设置kafak连接属性
      val kafkaParam= Map[String, String](
        "group.id" -> "testKafka",
        "bootstrap.servers" -> "hadoop102:9092,hadoop103:9092",
        "enable.auto.commit" -> "false",
        "auto.commit.interval.ms" -> "500",
        "auto.offset.reset" -> "earliest",
        "client.id" -> "client1",
        "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
        "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
      )
  
      //从kafka中获取DStream
      val ds = KafkaUtils.createDirectStream(
        context,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](List("spark"), kafkaParam)
      )
  
      //获取所有的value集合
      val ds1= ds.map(record => {
        val value: String = record.value()
        //模拟故障，抛出异常
        if (value.equals("d")) {
          //模拟故障
          //throw new RuntimeException("异常")
          //throw new UnknownError("错误")
        }
        value
      })
      
      //程序的处理逻辑
      ds1.print(1000)
      
      context
    }
    
    //创建StreamingContext环境上下文
    val streamContext = StreamingContext.getActiveOrCreate("ck",createStreamingContext)
    
    //应用启动
    streamContext.start()
    
    //一直阻塞当前进程，直到手动调用stop或者由于异常终止
    streamContext.awaitTermination() 
  } 
}

三、调用官方api手动提交offset保存到_consumer_offset主题中

package com.saprkstreaming.kafka

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{CanCommitOffsets, ConsumerStrategies, HasOffsetRanges, KafkaUtils, LocationStrategies, OffsetRange}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object KafkaStreamingExection2 {
  
  def main(args: Array[String]): Unit = {
    
   //每三秒采集一批数据
    val context: StreamingContext = new StreamingContext("local[*]","testkafka",Seconds(3))
  
    //配置kafka连接属性
    val kafkaParams: Map[String, String] = Map[String, String](
      "group.id" -> "testKafka",
      "bootstrap.servers" -> "hadoop102:9092,hadoop103:9092",
      "enable.auto.commit" -> "false",
      "auto.offset.reset" -> "earliest",
      "client.id" -> "client1",
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
    )
  
    //从kafka中获取DStream
    val ds: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      context,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe[String, String](List("spark"), kafkaParams)
    )
        
    ds.foreachRDD(rdd=>{
      //获取此批数据的offset的范围
      val offsetRange: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      
      //进行业务处理
      rdd.foreach(record=>{
        val value: String = record.value()
        if (value.equals("d")){
          //模拟故障，抛出异常
          //throw new RuntimeException("异常！！！")
        }
          println(value)
      })
      
      //业务处理完成后，手动提交offset！
      ds.asInstanceOf[CanCommitOffsets].commitAsync(offsetRange)  
    })
        
    //启动应用
    context.start()
    
    //阻塞当前进程，直到手动调用stop或者由于异常终止
    context.awaitTermination() 
  } 
}

大数据面壁者

关注

2
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
使用SparkStreaming获取Kafka中的流式数据并指定手动提交offset

概述本篇文章主要有三个示例代码，第一个主要功能是使用sparkstreaming获取kafka中的流式数据，第二个主要解决自动提交偏移量的解决方法：指定检查点，第三个示例是使用手动提交的方式解决自动提交过程中可能出错的问题。还可以指定存储器实现精准一一致性，后续再补上！题外话：sparkstreaming毕竟不是真正的实时计算，底层原理是将数据流离散化为一个一个的微批次，在精准一致消费流式数据上远没有flink方便！！！所以sparkstreamign只建议使用在对实时性要求在秒级查询得场景！！！一、
复制链接

扫一扫