Spark Streaming整合Kafka

Spark Streaming整合Kafka：

0)摘要

　　主要介绍了Spark Streaming整合Kafka，两种整合方式：Receiver-based和Direct方式。这里使用的是Kafka broker version 0.8.2.1，官方文档地址：（http://spark.apache.org/docs/2.2.0/streaming-kafka-0-8-integration.html），kafka介绍（https://www.cnblogs.com/truekai/p/11774847.html）

1）Kafka准备

• 启动zookeeper
  ./zkServer.sh start
• 启动kafka
  ./kafka-server-start.sh -daemon ../config/server.properties //后台启动
• 创建topic
  ./kafka-topics.sh --create --zookeeper hadoop:2181 --replication-factor 1 --partitions 1 --topic test
• 通过控制台测试topic能否正常的生产和消费

     　　启动生产者脚本：
         ./kafka-console-producer.sh --broker-list hadoop:9092 --topic test

　　　启动消费者脚本：

　　  ./kafka-console-consumer.sh --zookeeper hadoop:2181 --topic test --from-beginning

　　准备工作已经就绪。

2）Receiver-based方式整合

注意：这种方式为了保证数据不会丢失，需要开启Write Ahead Logs机制，开启后，接收数据的正确性只有被预写到日志以后Receive才会确认，可以从日志中恢复数据，会增加额外的开销。如何开启？设置SparkConf的“Spark Streaming writeAheadLog.enable”属性为“true”，这种模式基本被淘汰

1 添加kafka依赖

        <!--        kafka依赖-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
            <version>2.2.0</version>
        </dependency>

2 本地代码编写

package flume_streaming

import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka._
import org.apache.spark.streaming.{Durations, StreamingContext}

/**
 * @Author: SmallWild
 * @Date: 2019/10/30 10:00
 * @Desc:
 */

object kafkaReceiveWordCount {
  def main(args: Array[String]): Unit = {
    if (args.length != 4) {
      System.err.println("错误参数")
      System.exit(1)
    }
    //接收参数
    //numPartitions 线程数
    val Array(zkQuorum, groupId, topics, numPartitions) = args
    //一定不能使用local[1]
    val sparkConf = new SparkConf().setMaster("local[2]").setAppName("kafkaReceiveWordCount")
    val ssc = new StreamingContext(sparkConf, Durations.seconds(5))
    //设置日志级别
    ssc.sparkContext.setLogLevel("WARN")
    //多个topic用,分开
    val topicMap = topics.split(",").map((_, numPartitions.toInt)).toMap
    //TODO 业务逻辑，简单进行wordcount，输出到控制台
    /**
     * * @param ssc       StreamingContext object
     * * @param zkQuorum  Zookeeper quorum (hostname:port,hostname:port,..)
     * * @param groupId   The group id for this consumer topic所在的组，可以设置为自己想要的名称
     * * @param topics    Map of (topic_name to numPartitions) to consume. Each partition is consumed
     * *                  in its own thread
     * * @param storageLevel  Storage level to use for storing the received objects
     * *                      (default: StorageLevel.MEMORY_AND_DISK_SER_2)
     */
    val lineMap = KafkaUtils.createStream(ssc, zkQuorum, groupId, topicMap)
    lineMap.map(_._2).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).print()
    ssc.start()
    ssc.awaitTermination()
  }
}

3 提交到服器上运行

　　如果生产中没有联网，需要使用  --jars 传入kafka的jar包

• 把项目达成jar包
• 使用local模式提交，提交的脚本：

提交到服务器上运行
 ./spark-submit --master local[2] /
 --packages org.apache.spark:spark-streaming-kafka-0-8_2.11:2.2.0 /
 --class flume_streaming.kafkaReceiveWordCount /
 /smallwild/app/SparkStreaming-1.0.jar /
 hadoop:2181 1 sparkStreaming 1

4 运行结果

　　首先在控制台，启动kafka生产者，输入一些单词，然后，启动SparkStreaming程序。

 　

3）Direct方式整合

使用的是：Simple Consumer API,自己管理offset，把kfka看成存储数据的地方，根据offset去读。没有使用zk管理消费者的offset，spark自己管理，默认的offset在内存中，如果设置了checkpoint,那么也也有一份，一般要设置。Direct模式生成的Dstream中的RDD的并行度与读取的topic中的partition一致（增加topic的partition个数）

注意点：

• 没有使用receive,直接查询的kafka偏移量

1 添加kafka依赖

        <!--        kafka依赖-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
            <version>2.2.0</version>
        </dependency>

2 代码编写

package kafka_streaming

import kafka.serializer.StringDecoder
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.streaming.kafka.KafkaUtils

/**
 * @Author: SmallWild
 * @Date: 2019/10/31 21:21
 * @Desc:
 */
object kafkaDirectWordCount {

  def main(args: Array[String]): Unit = {
    if (args.length != 2) {
      System.err.println("错误参数")
      System.exit(1)
    }
    //接收参数
    //numPartitions 线程数
    val Array(brokers, topics) = args
    //一定不能使用local[1]
    val sparkConf = new SparkConf().setMaster("local[2]").setAppName("kafkaDirectWordCount")
    val ssc = new StreamingContext(sparkConf, Durations.seconds(5))
    //设置日志级别
    ssc.sparkContext.setLogLevel("WARN")
    //多个topic用,分开
    val kafkaParams = Map[String, String]("metadata.broker.list" -> brokers
    )
    val topicsa = topics.split(",").toSet
    /**
     *
     */
    val lineMap = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topicsa)
    //TODO 业务逻辑，简单进行wordcount，输出到控制台
    lineMap.map(_._2).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).print()
    ssc.start()
    ssc.awaitTermination()
  }

}

3 提交到服务器上运行和第一种方式是上面一样

4 自己管理offset

　　使用spark自己管理offset方便，但是当业务逻辑改变的时候，恢复就难了，需要自己手动编写代码管理offset

4)总结

　　注意两种模式差别，receive模式几乎被淘汰，可以扩展的地方，1）使程序具备高可用的能力，挂掉之后，能否从上次的状态恢复过来，2）手动管理offset，改变了业务逻辑也能从上次的状态恢复过来