目錄
-
整合Kafka兩種模式說明
Receiver接收方式
KafkaUtils.createDstream(開發中不用),Receiver作爲常駐的Task運行在Executor等待數據,但是一個Receiver效率低,需要開啓多個,再手動合併數據(union),再進行處理,很麻煩。
Receiver哪臺機器掛了,可能會丟失數據,所以需要開啓WAL(預寫日誌)保證數據安全,那麼效率又會降低!
Receiver方式是通過zookeeper來連接kafka隊列,調用Kafka高階API,offset存儲在zookeeper,由Receiver維護,
spark在消費的時候爲了保證數據不丟也會在Checkpoint中存一份offset,可能會出現數據不一致
所以不管從何種角度來說,Receiver模式都不適合在開發中使用了,已經淘汰了
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有變化(更加強大)
-
spark-streaming-kafka-0-8
Receiver
KafkaUtils.createDstream使用了receivers來接收數據,利用的是Kafka高層次的消費者api,偏移量由Receiver維護在zk中,對於所有的receivers接收到的數據將會保存在Spark executors中,然後通過Spark Streaming啓動job來處理這些數據,默認會丟失,可啓用WAL日誌,它同步將接受到數據保存到分佈式文件系統上比如HDFS。保證數據在出錯的情況下可以恢復出來。儘管這種方式配合着WAL機制可以保證數據零丟失的高可靠性,但是啓用了WAL效率會較低,且無法保證數據被處理一次且僅一次,可能會處理兩次。因爲Spark和ZooKeeper之間可能是不同步的。官方現在已經不推薦這種整合方式
Direct
Direct方式會定期地從kafka的topic下對應的partition中查詢最新的偏移量,再根據偏移量範圍在每個batch裏面處理數據,Spark通過調用kafka簡單的消費者API讀取一定範圍的數據。
-
spark-streaming-kafka-0-10
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
代碼
//創建sparkConf
val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("test01")
//創建SparkContext
val sc = new SparkContext(conf)
sc.setLogLevel("WARN")
//創建StreamingContext
var ssc = new StreamingContext(sc, Seconds(5))
//設置臨時數據存放位置
ssc.checkpoint("./tmpCount")
//準備連接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)
)
//接收kafka數據並根據業務進行計算
//LocationStrategies.PreferConsistent 位置策略,源碼強烈推薦使用該策略,會讓Spark的Executor和Kafka的Broker均勻對應
//ConsumerStrategies.Subscribe 消費策略,源碼強烈推薦使用該策略
//kafkaDatas含有key和value
//key:kafka生產數據是指定的key(可能爲空)
//value:kafka生產的數據
val kafkaDatas: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](ssc, LocationStrategies.PreferConsistent, ConsumerStrategies.Subscribe[String, String](Array("test01"), kafkaParams))
//根據業務邏輯進行計算
val kafkaWordAndOne: DStream[(String, Int)] = kafkaDatas.flatMap(z => z.value().split(" ")).map((_, 1))
val wordCount: DStream[(String, Int)] = kafkaWordAndOne.reduceByKeyAndWindow((x: Int, y: Int) => x + y, Seconds(10), Seconds(10))
//打印數據
wordCount.print()
//開啓計算任務
ssc.start()
//等待關閉任務
ssc.awaitTermination()
-
Kafka手動維護偏移量
API:http://spark.apache.org/docs/latest/streaming-kafka-0-10-integration.html
代碼
def main(args: Array[String]): Unit = {
//創建sparkConf
val conf = new SparkConf().setAppName("wc").setMaster("local[*]")
//創建SparkContext
val sc = new SparkContext(conf)
sc.setLogLevel("WARN")
//5表示5秒中對數據進行切分形成一個RDD
val ssc = new StreamingContext(sc,Seconds(5))
//準備連接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")
//使用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開始消費")
KafkaUtils.createDirectStream[String, String](ssc,
LocationStrategies.PreferConsistent,//位置策略,源碼強烈推薦使用該策略,會讓Spark的Executor和Kafka的Broker均勻對應
ConsumerStrategies.Subscribe[String, String](topics, kafkaParams))//消費策略,源碼強烈推薦使用該策略
}
//根據業務邏輯進行計算
//注意:我們的目標是要自己手動維護偏移量,也就意味着,消費了一小批數據就應該提交一次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)
}
})
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/test01?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/test01?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()
}
}