SparkStreaming整合KafkaCDH6.3.2版本（Offset保存在zookeeper上，Spark2.4 + kafka0.10.X）

最新推荐文章于 2022-08-10 17:04:28 发布
最新推荐文章于 2022-08-10 17:04:28 发布
阅读量552 收藏
点赞数
分类专栏： kafka 文章标签： 保存kafka的offset
原文链接：https://www.cnblogs.com/mlxx9527/p/9376202.html
版权

依赖

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <java.version>1.8</java.version>
        <scala.binary.version>2.11</scala.binary.version>
        <scala.version>2.11.8</scala.version>
        <spark.version>2.4.0-cdh6.3.2</spark.version>
        <hadoop.version>3.0.0-cdh6.3.2</hadoop.version>
        <kafka.version>2.2.1-cdh6.3.2</kafka.version>
    </properties>

 

    <dependencies>

        <dependency>
            <groupId>com.emg</groupId>
            <artifactId>etp-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
            <scope>${jar.scope}</scope>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-compiler</artifactId>
            <version>${scala.version}</version>
            <scope>${jar.scope}</scope>
        </dependency>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-reflect</artifactId>
            <version>${scala.version}</version>
            <scope>${jar.scope}</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>${jar.scope}</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>${jar.scope}</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql-kafka-0-10_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
            <scope>${jar.scope}</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-streams-test-utils -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams-test-utils</artifactId>
            <version>${kafka.version}</version>
         <!--   <scope>test</scope>-->
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>${kafka.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.12</artifactId>
            <version>2.2.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.70</version>
        </dependency>

        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9.2</version>
        </dependency>


        <dependency>
            <groupId>com.jolbox</groupId>
            <artifactId>bonecp</artifactId>
            <version>0.8.0.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.postgresql/postgresql -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.2.12</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>

        <dependency>
            <groupId>org.locationtech.jts</groupId>
            <artifactId>jts-core</artifactId>
            <version>1.16.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>


        <dependency>
            <groupId>com.uber</groupId>
            <artifactId>h3</artifactId>
            <version>3.6.3</version>
        </dependency>

        <dependency>
            <groupId>org.apache.parquet</groupId>
            <artifactId>parquet-common</artifactId>
            <version>1.11.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.parquet</groupId>
            <artifactId>parquet-encoding</artifactId>
            <version>1.11.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.parquet</groupId>
            <artifactId>parquet-column</artifactId>
            <version>1.11.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.parquet</groupId>
            <artifactId>parquet-hadoop</artifactId>
            <version>1.11.0</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
<!--

        <dependency>
            　　<groupId>org.gavaghan</groupId>
            　　<artifactId>geodesy</artifactId>
            　　<version>1.1.3</version>
        </dependency>
-->

    </dependencies>

代码

import scala.collection.JavaConversions._
import org.apache.curator.framework.CuratorFrameworkFactory
import org.apache.curator.retry.ExponentialBackoffRetry
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.kafka.common.TopicPartition
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010._
import org.apache.spark.streaming.{Seconds, StreamingContext}
 
import scala.collection.mutable
 
object KafkaZookeeperCheckPoint {
 
 
  // ZK client
  val client = {
    val client = CuratorFrameworkFactory
      .builder
      .connectString("bigdata:2181,bigdata:2182,bigdata:2183")
      .retryPolicy(new ExponentialBackoffRetry(1000, 3))
      .namespace("mykafka")
      .build()
    client.start()
    client
  }
 
  // offset 路径起始位置
  val Globe_kafkaOffsetPath = "/kafka/offsets"
 
  // 路径确认函数  确认ZK中路径存在，不存在则创建该路径
  def ensureZKPathExists(path: String)={
 
    if (client.checkExists().forPath(path) == null) {
      client.create().creatingParentsIfNeeded().forPath(path)
    }
 
  }
 
 
  // 保存 新的 offset
  def storeOffsets(offsetRange: Array[OffsetRange], groupName:String) = {
 
    for (o <- offsetRange){
      val zkPath = s"${Globe_kafkaOffsetPath}/${groupName}/${o.topic}/${o.partition}"
       //检查路径
      ensureZKPathExists(zkPath)
      // 向对应分区第一次写入或者更新Offset 信息
      println("---Offset写入ZK------\nTopic：" + o.topic +", Partition:" + o.partition + ", Offset:" + o.untilOffset)
      client.setData().forPath(zkPath, o.untilOffset.toString.getBytes())
    }
  }
 
  def getFromOffset(topic: Array[String], groupName:String):(Map[TopicPartition, Long], Int) = {
 
    // Kafka 0.8和0.10的版本差别，0.10 为 TopicPartition   0.8 TopicAndPartition
    var fromOffset: Map[TopicPartition, Long] = Map()
 
    val topic1 = topic(0).toString
 
    // 读取ZK中保存的Offset，作为Dstrem的起始位置。如果没有则创建该路径，并从 0 开始Dstream
    val zkTopicPath = s"${Globe_kafkaOffsetPath}/${groupName}/${topic1}"
 
    // 检查路径是否存在
    ensureZKPathExists(zkTopicPath)
 
    // 获取topic的子节点，即 分区
    val childrens = client.getChildren().forPath(zkTopicPath)
 
    // 遍历分区
    val offSets: mutable.Buffer[(TopicPartition, Long)] = for {
      p <- childrens
    }
      yield {
 
        // 遍历读取子节点中的数据：即 offset
        val offsetData = client.getData().forPath(s"$zkTopicPath/$p")
        // 将offset转为Long
        val offSet = java.lang.Long.valueOf(new String(offsetData)).toLong
        // 返回  (TopicPartition, Long)
        (new TopicPartition(topic1, Integer.parseInt(p)), offSet)
      }
    println(offSets.toMap)
 
    if(offSets.isEmpty){
      (offSets.toMap, 0)
    } else {
      (offSets.toMap, 1)
    }
 
 
  }
 
//    if (client.checkExists().forPath(zkTopicPath) == null){
//
//      (null, 0)
//    }
//    else {
//      val data = client.getData.forPath(zkTopicPath)
//      println("----------offset info")
//      println(data)
//      println(data(0))
//      println(data(1))
//      val offSets = Map(new TopicPartition(topic1, 0) -> 7332.toLong)
//      println(offSets)
//      (offSets, 1)
//    }
//
//  }
 
  def createMyZookeeperDirectKafkaStream(ssc:StreamingContext, kafkaParams:Map[String, Object], topic:Array[String],
                                         groupName:String ):InputDStream[ConsumerRecord[String, String]] = {
 
    // get offset  flag = 1  表示基于已有的offset计算  flag = 表示从头开始(最早或者最新，根据Kafka配置)
    val (fromOffsets, flag) = getFromOffset(topic, groupName)
    var kafkaStream:InputDStream[ConsumerRecord[String, String]] = null
    if (flag == 1){
      // 加上消息头
      //val messageHandler = (mmd:MessageAndMetadata[String, String]) => (mmd.topic, mmd.message())
      println(fromOffsets)
      kafkaStream = KafkaUtils.createDirectStream(ssc, LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe(topic, kafkaParams, fromOffsets))
println(fromOffsets)
      println("中断后 Streaming 成功！")
 
    } else {
      kafkaStream = KafkaUtils.createDirectStream(ssc, LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe(topic, kafkaParams))
 
      println("首次 Streaming 成功！")
 
    }
    kafkaStream
  }
 
  def main(args: Array[String]): Unit = {
 
    val processInterval = 5
    val brokers = "bigdata:9092,bigdata:9093,bigdata:9094"
    val topics = Array("zkKafka")
    val conf = new SparkConf().setMaster("local[2]").setAppName("kafka checkpoint zookeeper")
    // kafka params
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> brokers,
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "zk_group",
      "auto.offset.reset" -> "latest",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
 
    val ssc = new StreamingContext(conf, Seconds(processInterval))
 
    val messages = createMyZookeeperDirectKafkaStream(ssc, kafkaParams, topics, "zk_group")
 
      messages.foreachRDD((rdd) => {
        if (!rdd.isEmpty()){
 
          println("###################:"+rdd.count())
        }
 
        // 存储新的offset
        storeOffsets(rdd.asInstanceOf[HasOffsetRanges].offsetRanges, "zk_group")
      })
 
    ssc.start()
    ssc.awaitTermination()
 
  }
 
}

 

风是外衣衣衣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark第十篇：Spark与Kafka整合
weixin_34309543的博客
11-20 689
spark与kafka整合需要引入spark-streaming-kafka.jar，该jar根据kafka版本有2个分支，分别是spark-streaming-kafka-0-8和spark-streaming-kafka-0-10。 jar包分支选择原则：0.10.0>kafka版本>=0.8.2.1，选择spark-streaming-kafka-0-8；kafka版本>...
kafka tool2.1连接kerberos的kafka（cdh6.3.2）集群
A07110433的博客
01-19 472
转载：https://blog.csdn.net/weixin_40004348/article/details/115343407
Spark Streaming和Kafka整合之路（最新版本）
weixin_33851177的博客
09-19 207
2019独角兽企业重金招聘Python工程师标准>>> ...
SparkStreaming2.4整合kafka_010
shufangreal的博客
02-29 1095
SparkStreaming2.4整合kafka_010 maven依赖如下: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance...
CDH6.3.2之Kafka配置和命令
ArYe
08-10 3061
如图示，每5分钟，日志清理程序 会根据日志保留策略 来清理符合删除条件的日志。：每个主题分区保留在日志中的数据量，设-1时无限制。创建，则消费者偏移量保存在ZooKeeper中。：点击具有Kafka服务的主机，然后点击组件。：日志保留时长，设-1时无限制，建议3天。创建，则消费者偏移量保存在Kafka中。会把主题以往所有数据都读取出来）建议给4~6G每个Broker。如果不知道CDH装哪，就把。可接收的单个消息的最大值（...
spark-streaming-kafka-0-10_2.11-2.4.0-cdh6.1.1.jar
05-14
spark-streaming-kafka-0-10_2.11-2.4.0-cdh6.1.1.jar
适配CDH6.3.2的Spark3.2.2
08-16
Spark3.2.2是Apache Spark的一个重要版本，它提供了许多新特性和性能优化，而适配CDH6.3.2则意味着该版本的Spark已经经过了与Cloudera Data Hub (CDH) 6.3.2的兼容性验证。CDH是一个流行的Hadoop发行版，包含了...
cdh6.3.2+cm6.3.1.zip下载
07-07
在提供的压缩包`cdh6.3.2+cm6.3.1.zip`中，有一个名为`cdh6.3.2+cm6.3.1下载地址.txt`的文件。这个文件可能包含了CDH6.3.2和CM6.3.1的下载链接或者安装指南，因为官方网站现在需要登录才能获取这些文件。用户可能...
spark-3.3.1-bin-3.0.0-cdh6.3.2.tgz
11-23
spark 3.3.1 使用 cdh 6.3.2 的hadoop版本。可以直接兼容并配合文档进行cdh spark-sql的使用。 具体查看https://editor.csdn.net/md/?articleId=127997188
CDH6.3.2之升级spark-3.3.1.doc
最新发布
03-06
在CDH6.3.2中，默认的Spark版本为2.4.0。为了满足更高的性能需求及功能扩展，本文将详细介绍如何将Spark升级至3.3.1版本的过程。此次升级的主要原因是团队对Hive进行了版本升级，从较低版本升级到了3.1.3。然而，在...
Spark 2.4.0 cdh6.3.2连接 Hive 2.1.1 cdh6.3.2
SuCicada 小米的蝉
01-06 1104
以下maven配置能正确读取hive. 不该加的不要加. spark版本用cdh的. <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <spark.version>2.4.0-cdh6.3.2</spark.ve
spark-streaming-kafka-0-10_2.12 api
Geek_SQ
05-03 1165
因为更新了scala 2.12 版本 老的kafka api 会报错，翻了半天博客记录一下 package com.sq.sparkstreaming import org.apache.kafka.clients.consumer.ConsumerRecord import org.apache.kafka.common.TopicPartition import org.apache.k...
kafka安装以及与spark集成与测试
ImezZ
03-30 2124
一、Zookeeper安装 参考上篇写的zookeeper安装文章。 ZooKeeper安装与配置_IMezZ的博客-CSDN博客一、ZooKeeper安装和配置1、zookeeper下载ZooKeeper官网https://zookeeper.apache.org/本文用的是zookeeper-3.4.8.tar.gz，下载 zookeeper-3.4.8.tar.gz。上传至主机/opt目录下2、安装和配置安装模式有单机和集群两种，这是采用集群模式，单机模式这里不再赘述。解压tar -zxvf zo
CDH6.2.0 kafka安装
weixin_38655836的博客
05-11 4390
开篇回顾：安装过程中，刚开始的时候安装只选择了一个节点，然后测试，使用终端界面生产者消费者，发现生产者发送的消息，消费者都没有收到，最终添加节点为3个之后，就可以消费了。定位原因，可能由于zookpeer是集群模式。部署单个kafka，造成配置存在问题，最终不能消费成功。（个人简介） 由于是CDH安装的，启动的脚本目录为： /opt/cloudera/parcels/CDH/lib/kafka ...
CDH6.3.2 组件版本和Maven依赖版本
星辰大数据的博客
05-20 7724
目录 remoterepository component version dependencytemplate artifact version remoterepository <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM...
Spark Streaming-2.4.3整合Kafka-0.10
u011563666的博客
11-15 1388
1.依赖准备 添加spark-streaming整合kafka的依赖，将依赖添加到pom.xml中，如下： <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-streaming-kafka-0-10_2.11</artifactId> &...
CDH6.3.2添加spark-sql
丰耳的博客
02-18 5046
前言 众所周知，CDH为了推自家的Impala，阉割掉了Spark的spark-sql工具，虽然很多时候我们并不需要spark-sql,但是架不住特殊情况下有使用它的时候，这个根据项目或者团队（个人）情况而异。我这边就是因为项目原因，需要使用spark-sql，因此从网上各种查资料，折腾了好几天，最终在CDH集群上集成了spark-sql，以下操作并不能保证百分百适配你的环境，但思路可供借鉴。 集成步骤 下载Apache-spark2.4.0 因为CDH6.3.2使用的Spark版本是2.4.0,为了避免使
CDH6.3 集群安装Kafka服务步骤以及问题解决方法
一尘在心的博客
01-03 2314
https://blog.csdn.net/weixin_40040107/article/details/103242611
Maven中使用本地JAR包（scope 属性说明）
chengqi5964的博客
08-22 591
Maven查找Jar平台 Maven 依赖中 scope 详解 Maven中使用本地JAR包 前言 Maven 的哲学思想是，约定优于配置（Convention Over Configuration），Maven 依赖中 scope 的默认值是compile Scope 指定了依赖（第三方ja...
CDH6.3.2 Spark SQL开发与Windows本地环境配置手册
"该资源是关于在CDH6.3.2环境下进行Spark SQL的本地开发手册，包括了Hadoop Windows本地开发环境的配置指南，以及如何修改Maven的settings配置文件以使用Cloudera仓库下载依赖。" Spark是大数据处理领域的一个重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值