Spark -- spark on kafka Receiver & Direct Kafka手動維護偏移量

kafka回顧！！！上圖完事！

常用命令
#啓動kafka
/export/servers/kafka/bin/kafka-server-start.sh -daemon /export/servers/kafka/config/server.properties

#停止kafka
/export/servers/kafka/bin/kafka-server-stop.sh

#查看topic信息
/export/servers/kafka/bin/kafka-topics.sh --list --zookeeper node01:2181

#創建topic
/export/servers/kafka/bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 3 --partitions 3 --topic test

#查看某個topic信息
/export/servers/kafka/bin/kafka-topics.sh --describe --zookeeper node01:2181 --topic test

#刪除topic
/export/servers/kafka/bin/kafka-topics.sh --zookeeper node01:2181 --delete --topic test

#啓動生產者--控制檯的生產者一般用於測試
/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092 --topic spark_kafka

#啓動消費者--控制檯的消費者一般用於測試
/export/servers/kafka/bin/kafka-console-consumer.sh --zookeeper node01:2181 --topic spark_kafka--from-beginning

# 消費者連接到borker的地址
/export/servers/kafka/bin/kafka-console-consumer.sh --bootstrap-server node01:9092,node02:9092,node03:9092 --topic spark_kafka --from-beginning

spark整合Kafka兩種模式說明

★面試題：Receiver & Direct

開發中我們經常會利用SparkStreaming實時地讀取kafka中的數據然後進行處理，在spark1.3版本後，kafkaUtils裏面提供了兩種創建DStream的方法:

1.Receiver接收方式：

KafkaUtils.createDstream(開發中不用，瞭解即可，但是面試可能會問)

Receiver作爲常駐的Task運行在Executor等待數據，但是一個Receiver效率低，需要開啓多個，再手動合併數據(union)，再進行處理，很麻煩

Receiver哪臺機器掛了，可能會丟失數據，所以需要開啓WAL(預寫日誌)保證數據安全，那麼效率又會降低!

Receiver方式是通過zookeeper來連接kafka隊列，調用Kafka高階API，offset存儲在zookeeper，由Receiver維護，

spark在消費的時候爲了保證數據不丟也會在Checkpoint中存一份offset，可能會出現數據不一致

所以不管從何種角度來說，Receiver模式都不適合在開發中使用了,已經淘汰了

2.Direct直連方式：

KafkaUtils.createDirectStream(開發中使用，要求掌握)

Direct方式是直接連接kafka分區來獲取數據，從每個分區直接讀取數據大大提高了並行能力

Direct方式調用Kafka低階API(底層API)，offset自己存儲和維護，默認由Spark維護在checkpoint中，消除了與zk不一致的情況

當然也可以自己手動維護，把offset存在mysql、redis中

所以基於Direct模式可以在開發中使用，且藉助Direct模式的特點+手動操作可以保證數據的Exactly once 精準一次

總結：

Receiver接收方式

多個Receiver接受數據效率高，但有丟失數據的風險。
開啓日誌（WAL）可防止數據丟失，但寫兩遍數據效率低。
Zookeeper維護offset有重複消費數據可能。
使用高層次的API

Direct直連方式

不使用Receiver，直接到kafka分區中讀取數據
不使用日誌（WAL）機制。
Spark自己維護offset
使用低層次的API

實現方式	消息語義	存在的問題
Receiver	at most once 最多被處理一次	會丟失數據
Receiver+WAL	at least once 最少被處理一次	不會丟失數據，但可能會重複消費，且效率低
Direct+手動操作	exactly once 只被處理一次/精準一次	不會丟失數據，也不會重複消費，且效率高

●注意:

開發中SparkStreaming和kafka集成有兩個版本：0.8及0.10+

0.8版本有Receiver和Direct模式(但是0.8版本生產環境問題較多，在Spark2.3之後不支持0.8版本了)

0.10以後只保留了direct模式(Reveiver模式不適合生產環境)，並且0.10版本API有變化(更加強大)

●結論：

我們學習和開發都直接使用0.10版本中的direct模式

但是關於Receiver和Direct的區別面試的時候要能夠答得上來

spark-streaming-kafka-0-10

●說明

spark-streaming-kafka-0-10版本中，API有一定的變化，操作更加靈活，開發中使用

●pom.xml

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>${spark.version}</version>
</dependency>

●API

http://spark.apache.org/docs/latest/streaming-kafka-0-10-integration.html

●創建topic

/export/servers/kafka/bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 3 --partitions 3 --topic spark_kafka

●啓動生產者

/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092,node01:9092,node01:9092 --topic spark_kafka

代碼他來咯

package cn.itcast.streaming

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

object SparkKafkaDemo {
  def main(args: Array[String]): Unit = {
    //1.創建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)3
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中對數據進行切分形成一個RDD
    //準備連接Kafka的參數
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "node01:9092,node02:9092,node03:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "SparkKafkaDemo",
      //earliest:當各分區下有已提交的offset時，從提交的offset開始消費；無提交的offset時，從頭開始消費
      //latest:當各分區下有已提交的offset時，從提交的offset開始消費；無提交的offset時，消費新產生的該分區下的數據
      //none:topic各分區都存在已提交的offset時，從offset後開始消費；只要有一個分區不存在已提交的offset，則拋出異常
      //這裏配置latest自動重置偏移量爲最新的偏移量,即如果有偏移量從偏移量位置開始消費,沒有偏移量從新來的數據開始消費
      "auto.offset.reset" -> "latest",
      //false表示關閉自動提交.由spark幫你提交到Checkpoint或程序員手動維護
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
    val topics = Array("spark_kafka")
    //2.使用KafkaUtil連接Kafak獲取數據
    val recordDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](ssc,
      LocationStrategies.PreferConsistent,//位置策略,源碼強烈推薦使用該策略,會讓Spark的Executor和Kafka的Broker均勻對應
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams))//消費策略,源碼強烈推薦使用該策略
    //3.獲取VALUE數據
    val lineDStream: DStream[String] = recordDStream.map(_.value())//_指的是ConsumerRecord
    val wrodDStream: DStream[String] = lineDStream.flatMap(_.split(" ")) //_指的是發過來的value,即一行數據
    val wordAndOneDStream: DStream[(String, Int)] = wrodDStream.map((_,1))
    val result: DStream[(String, Int)] = wordAndOneDStream.reduceByKey(_+_)
    result.print()
    ssc.start()//開啓
    ssc.awaitTermination()//等待優雅停止
  }
}

Kafka手動維護偏移量

●API

http://spark.apache.org/docs/latest/streaming-kafka-0-10-integration.html

●啓動生產者

/export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092,node01:9092,node01:9092 --topic spark_kafka

package cn.itcast.streaming

import java.sql.{DriverManager, ResultSet}

import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.TopicPartition
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{OffsetRange, _}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}
import scala.collection.mutable

object SparkKafkaDemo2 {
  def main(args: Array[String]): Unit = {
    //1.創建StreamingContext
    //spark.master should be set as local[n], n > 1
    val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")
    val ssc = new StreamingContext(sc,Seconds(5))//5表示5秒中對數據進行切分形成一個RDD
    //準備連接Kafka的參數
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "node01:9092,node02:9092,node03:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "SparkKafkaDemo",
      "auto.offset.reset" -> "latest",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
    val topics = Array("spark_kafka")
    //2.使用KafkaUtil連接Kafak獲取數據
    //注意:
    //如果MySQL中沒有記錄offset,則直接連接,從latest開始消費
    //如果MySQL中有記錄offset,則應該從該offset處開始消費
    val offsetMap: mutable.Map[TopicPartition, Long] = OffsetUtil.getOffsetMap("SparkKafkaDemo","spark_kafka")
    val recordDStream: InputDStream[ConsumerRecord[String, String]] = if(offsetMap.size > 0){//有記錄offset
      println("MySQL中記錄了offset,則從該offset處開始消費")
      KafkaUtils.createDirectStream[String, String](ssc,
      LocationStrategies.PreferConsistent,//位置策略,源碼強烈推薦使用該策略,會讓Spark的Executor和Kafka的Broker均勻對應
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams,offsetMap))//消費策略,源碼強烈推薦使用該策略
    }else{//沒有記錄offset
      println("沒有記錄offset,則直接連接,從latest開始消費")
      // /export/servers/kafka/bin/kafka-console-producer.sh --broker-list node01:9092 --topic  spark_kafka
      KafkaUtils.createDirectStream[String, String](ssc,
      LocationStrategies.PreferConsistent,//位置策略,源碼強烈推薦使用該策略,會讓Spark的Executor和Kafka的Broker均勻對應
      ConsumerStrategies.Subscribe[String, String](topics, kafkaParams))//消費策略,源碼強烈推薦使用該策略
    }
    //3.操作數據
    //注意:我們的目標是要自己手動維護偏移量,也就意味着,消費了一小批數據就應該提交一次offset
    //而這一小批數據在DStream的表現形式就是RDD,所以我們需要對DStream中的RDD進行操作
    //而對DStream中的RDD進行操作的API有transform(轉換)和foreachRDD(動作)
    recordDStream.foreachRDD(rdd=>{
      if(rdd.count() > 0){//當前這一時間批次有數據
        rdd.foreach(record => println("接收到的Kafk發送過來的數據爲:" + record))
        //接收到的Kafk發送過來的數據爲:ConsumerRecord(topic = spark_kafka, partition = 1, offset = 6, CreateTime = 1565400670211, checksum = 1551891492, serialized key size = -1, serialized value size = 43, key = null, value = hadoop spark ...)
        //注意:通過打印接收到的消息可以看到,裏面有我們需要維護的offset,和要處理的數據
        //接下來可以對數據進行處理....或者使用transform返回和之前一樣處理
        //處理數據的代碼寫完了,就該維護offset了,那麼爲了方便我們對offset的維護/管理,spark提供了一個類,幫我們封裝offset的數據
        val offsetRanges: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
        for (o <- offsetRanges){
          println(s"topic=${o.topic},partition=${o.partition},fromOffset=${o.fromOffset},untilOffset=${o.untilOffset}")
        }
        //手動提交offset,默認提交到Checkpoint中
        //recordDStream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
        //實際中偏移量可以提交到MySQL/Redis中
        OffsetUtil.saveOffsetRanges("SparkKafkaDemo",offsetRanges)
      }
    })

   /* val lineDStream: DStream[String] = recordDStream.map(_.value())//_指的是ConsumerRecord
    val wrodDStream: DStream[String] = lineDStream.flatMap(_.split(" ")) //_指的是發過來的value,即一行數據
    val wordAndOneDStream: DStream[(String, Int)] = wrodDStream.map((_,1))
    val result: DStream[(String, Int)] = wordAndOneDStream.reduceByKey(_+_)
    result.print()*/
    ssc.start()//開啓
    ssc.awaitTermination()//等待優雅停止
  }

  /*
  手動維護offset的工具類
  首先在MySQL創建如下表
    CREATE TABLE `t_offset` (
      `topic` varchar(255) NOT NULL,
      `partition` int(11) NOT NULL,
      `groupid` varchar(255) NOT NULL,
      `offset` bigint(20) DEFAULT NULL,
      PRIMARY KEY (`topic`,`partition`,`groupid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   */
  object OffsetUtil {

    //從數據庫讀取偏移量
    def getOffsetMap(groupid: String, topic: String) = {
      val connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
      val pstmt = connection.prepareStatement("select * from t_offset where groupid=? and topic=?")
      pstmt.setString(1, groupid)
      pstmt.setString(2, topic)
      val rs: ResultSet = pstmt.executeQuery()
      val offsetMap = mutable.Map[TopicPartition, Long]()
      while (rs.next()) {
        offsetMap += new TopicPartition(rs.getString("topic"), rs.getInt("partition")) -> rs.getLong("offset")
      }
      rs.close()
      pstmt.close()
      connection.close()
      offsetMap
    }

    //將偏移量保存到數據庫
    def saveOffsetRanges(groupid: String, offsetRange: Array[OffsetRange]) = {
      val connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/bigdata?characterEncoding=UTF-8", "root", "root")
      //replace into表示之前有就替換,沒有就插入
      val pstmt = connection.prepareStatement("replace into t_offset (`topic`, `partition`, `groupid`, `offset`) values(?,?,?,?)")
      for (o <- offsetRange) {
        pstmt.setString(1, o.topic)
        pstmt.setInt(2, o.partition)
        pstmt.setString(3, groupid)
        pstmt.setLong(4, o.untilOffset)
        pstmt.executeUpdate()
      }
      pstmt.close()
      connection.close()
    }
  }
}

Spark -- spark on kafka Receiver & Direct Kafka手動維護偏移量

kafka回顧！！！上圖完事！

spark整合Kafka兩種模式說明

spark-streaming-kafka-0-10

代碼他來咯

Kafka手動維護偏移量

機械學習 --客戶價值模型 RFM

機器學習 --基礎入門介紹他來啦！！！

Oozie --oozie的使用

用戶畫像 --運用sqoop導入數據 HBase ImportTSV HBase Bulkload MapReduce導入

用戶畫像 --前提介紹

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結