大数据-SparkStreaming

Posted 2020-12-01 小布大佬

SparkStreaming

SparkStreaming是一种微批处理，准实时的流式框架。数据来源包括：Kafka， Flume，TCP sockets，Twitter，ZeroMQ等

• SparkStreaming与storm的区别：

  • SparkStreaming微批处理数据，storm按条处理数据

  • SparkStreaming支持稍复杂的逻辑

  • SparkStreaming与storm都支持资源动态调整和事务机制

SparkStreaming的处理架构：采用recevier task持续拉取数据，拉取时间间隔为batch Interval，每次来去的数据封装为batch，batch被封装到RDD中，RDD被封装进DStream中。SparkStreaming对DStream进程处理。

数据处理与数据拉取同时进行，数据处理的速度需要与数据拉取量均衡，数据存储方式为memory_only，若数据处理速度慢于拉取速度会产生数据堆积，进而导致OOM。若数据存储方式包含disk，会加大延迟

代码实现

使用TCP sockets实现测试，liunx中命令：nc -lk 9999 实现模拟向9999端口发数据。

• 数据拉取的间隔时长 + sparkconf/sparkcontext => JavaStreamingContext (stream上下文)

• 数据源配置 + stream上下文 => JavaStreamingContext(首个DStream)

SparkConf sparkConf = new SparkConf();
//配置参数中需要至少2个线程，一条接收数据，一条执行job任务，否则无法打印数据，格式为：主机名[2]
sparkConf.setMaster("local[2]").setAppName("s01");
JavaSparkContext sparkContext = new JavaSparkContext(sparkConf);
?
//通过sc上下文和指定间隔获取stream的上下文
JavaStreamingContext jsc = new JavaStreamingContext(sparkContext, Durations.seconds(5));
//通过conf 和指定间隔获取stream的上下文
//JavaStreamingContext jsc2 = new JavaStreamingContext(sparkConf,Durations.seconds(5));
?
//设置checkpoint路径
//jsc.checkpoint("hdfs://node1:9000/spark/checkpoint");
jsc.checkpoint("/checkpoint");
?
//使用socket监听作为数据源，获取DStream
JavaReceiverInputDStream<String> data = jsc.socketTextStream("node1", 9999);
?
/* 此处写入 DStream 逻辑*/
?
//使用 输出算子，触发DStream逻辑代码
data.print();
?
//通过JavaStreamingContext触发代码执行
jsc.start();
?
//阻塞线程，不断执行任务
try {
    streamingContext.awaitTermination();
} catch (InterruptedException e) {
    e.printStackTrace();
}
?
//结束任务并关闭sparkContext
//若不需要关闭sparkContext加参数false
//stop之后无法再通过start启动任务
jsc.stop();
//jsc.stip(false);

算子

DStream能够使用RDD的算子，以下列举DStream的专属算子

对于DStream可以转为RDD的执行的操作，RDD算子内的代码在exector进程执行，RDD外代码在driver进程执行

转换算子

transform

将DStream在算子内部转为RDD运算，最后还是返回DStream。实现对DStream执行任意RDD操作

JavaDStream<String> resultDStream = DStream.transform(new Function<JavaRDD<String>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<String> value) throws Exception {
        //转换算子
        JavaRDD<String> map = value.map(x->{return x+"1";});
        //触发算子
        map.foreach(x-> System.out.println(x));
        return map;
    }
});

updateStateByKey（状态）

• 实现修改DStream的key的状态值。

  • sparkstream中为每个key维护一个static值，static可以为任意类型

  • 每有一个新的batch数据计算，若数据中的key值对应的static执行更新

• API

  • 指定checkpoint目录，实现static存储

  • 对于数据拉取间隔小于10s的操作，使用10秒一次的static更新，避免反复写磁盘

  • 数据由Optional对象封装

  //指定checkpoint路径，若加载了hdfs配置则为hdfs中的路径
  jsc.checkpoint("/checkpoint");
  JavaReceiverInputDStream<String> DStream = jsc.socketTextStream("node1", 9999);
  //数据转为KV结构
  JavaPairDStream<String, Integer> pair = data.mapToPair(new PairFunction<String, String, Integer>() {
      @Override
      public Tuple2<String, Integer> call(String s) throws Exception {
          return new Tuple2(s, 1);
      }
  });
  //执行updateStateByKey
  JavaPairDStream<String, Integer> result = pair.updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
      //内部call方法入参：本批次相同key的value集合，key对应static的值;
      //出参为新的static的值，为了数据安全使用Optional进行封装
      @Override
      public Optional<Integer> call(List<Integer> v1, Optional<Integer> v2) throws Exception {
          Integer value = 0;
          //对本次的key的value进行处理
          for (Integer i : v1) { value += i; }
          //对static非空判断，并逻辑处理
          if(v2.isPresent()){ value += v2.get(); }
  ?
          return Optional.of(value);
      }
  });
  result.print();

reduceByKeyAndWindow(窗口)

• 以若干时间间隔，一次性处理一段时间的数据

  • 滑动间隔：每隔多少时间处理一次数据（取值间隔时间的倍数）

  • 窗口：一次处理多少时间的数据（取值间隔时间的倍数）

//DStream为KV格式的数据
JavaPairDStream<String, Integer> result = DStream.reduceByKeyAndWindow(
    //对当前DStream中相同key的value进行reduce操作
    new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
            return v1 + v2;
        }
    },
    //指定窗口时间长度
    Durations.seconds(15),
    //指定滑动间隔的时间长度
    Durations.seconds(20));

优化

由于窗口函数需要对一段时间的数据进行计算，可能与前后一次的计算存在重复计算

设置checkpoint存储已经计算好DStream数据，在窗口调用数据减去旧的数据，加上新的数据。

//预先设置checkpoint路径
jsc.checkpoint("/checkpoint");
?
//DStream已经处理为kV结构
JavaPairDStream<String, Integer> result = DStream.reduceByKeyAndWindow(
    //以下逻辑用于对当前分区内，DStream内，窗口内，相同的key的value执行的操作
    对当前DStream中相同key的value进行reduce操作
    new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
        //v1为已累计的数据值，v2为新加入的数据值
            return v1 + v2;
        }
    },
    //对前一窗口中相同的key的value执行数据剔除的操作逻辑
    new Function2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer v1, Integer v2) throws Exception {
            //v1为窗口中的数据值，v2为需要去除的数据值
            return v1 - v2;
        }
    },
    //指定窗口时间长度
    Durations.seconds(15),
    //指定滑动间隔的时间长度
    Durations.seconds(20));

 

 

输出算子

output operator：业务逻辑完成后需要至少一个output operator触发代码执行

foreachRDD

将DStream转为RDD进行算子运算，注意：内部RDD必须使用触发算子，否则代码不执行

//RStream使用foreachRDD转换为RDD，通过RDD执行逻辑
DStream.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> stringJavaRDD) throws Exception {
        //RDD转换算子
        JavaRDD<String> result1 = stringJavaRDD.map(x->x);
        //RDD触发算子
        result1.foreach(x->{ System.out.println(x); });
    }
});

print

DStream.print() 实现对内部的数据的打印

Driver高可用

由于Driver需要不间断获取数据，Driver宕机重启需要借助checkpoint恢复原先的是数据，

• 启动层面，设置Driver宕机重启

  • standalone模式与Mesos 在启动任务时加入参数： --supervise

  • yarn模式具备自动重启能力

• 代码层面，设置基于checkpoint恢复

  • 设置checkpoint路径

  • 设置启动方式，使用JavaStreamingContext的getOrCreate方法创建DStream上下文

SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("HA");
//指定逻辑恢复的路径
JavaStreamingContext jsc0 = JavaStreamingContext.getOrCreate(
    "/checkpoint",
    new Function0<JavaStreamingContext>() {
        @Override
        public JavaStreamingContext call() throws Exception {
            JavaStreamingContext ssc = new JavaStreamingContext(
                sparkConf, Durations.seconds(5));
            //设置checkpoint路径
            ssc.checkpoint("/checkpoint");
            return ssc;
        }
    });

 

整合kafka

Spark2.2+kafka0.8

receiver模式

1. executor进程中的receiver task线程定时从kafka上拉取数据

2. receiver task将数据备份到各executor进程中，默认持久化级别MEMORY_AND_DISK_SER_2

3. receiver task将偏移量写入zk，并将备份情况汇报给driver进程

4. driver根据备份所在节点向executor进程分发task

   若driver宕机重启后从zk读取偏移量，重启receiver task进程。

   使用High Level Consumer API ，由zookeeper维护偏移量

   zk是投票机制更新数据消耗大，不利于大量数据吞吐

并行度修改

问题：对于数据量较大的场景，由于处理速度低于数据拉取速度，存在数据堆积的问题。

方案：修改并行度，增加task的数量，但该措施需控制在机器性能允许的范围内。

原理及实现：job的并行度由spark.streaming.blockInterval参数控制，该参数默认200ms对一批数据切分为若干数据块，每个数据块就是一个分区，分区数也就对应了并行度。该参数可修改的最小值为50ms

数据丢失问题

• 原因：dirver宕机，任务未执行完毕，但偏移量在zk中已经更新，dirver重启后丢失偏移量之前的任务数据

• 解决：WAL机制(日志)：在偏移量提交zk前hdfs保存一份数据，driver先从hdfs上读取备份数据，再从zk中取偏移量。

  • 问题1：性能低，优化：可将持久化级别修改为MEMORY_AND_DISK_SER

  • 问题2：导致数据重复消费问题

SparkConf conf = new SparkConf().setAppName("ccc").setMaster("local[2]");
//设置启动WAL机制
conf.set("spark.streaming.receiver.writeAheadLog.enable","true");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
//设置checkpoint的路径
jsc.checkpoint("/rec");
?
//通过map设置读取的topic及线程数
HashMap<String, Integer> topics = new HashMap<>();
topics.put("topic1",1);
topics.put("topic2",1);
?
//通过KafkaUtils的createStream方法创建DStream
//参数：上下文，zk，所属消费者组，读取的topic，持久化级别
JavaPairReceiverInputDStream<String,String> lines = KafkaUtils.createStream(
        jsc,
        "node03:2181,node02:2181,node01:2181",
        "ConsumerGroup",
        topics,
        StorageLevel.MEMORY_AND_DISK());

 

direct模式

• task直接从kafka的分区上拉取数据，task并行度与kafka的分区数一致

• 偏移量

  1. 默认使用内存维护偏移量（会有数据丢失），底层使用Simple Consumer API

  2. 可以添加checkpoint来维护偏移量，checkpoint也用于实现dirver宕机恢复

     • direct模式下的checkpoint中存储了代码逻辑+偏移量

     • 存在问题：在HA机制中，无法在运行过程中改变逻辑。若将新逻辑存入checkpoint，则会导致原有偏移量读取异常。同时存在driver宕机恢复时数据重复输出

  3. 可以自定义维护偏移量

     • 使用外部数据库存取更新偏移量，并实现手动提交偏移量，获取偏移量

     • 流程：构建DStream时手动获取并传入原有偏移量，从首个RDD中获取新的偏移量，在数据输出时将新的偏移量存入外部数据库。

     • 存在问题：只能保证转换1次，无法保证输出只有一次，需要通过输出幂等性或事务处理来解决

默认/checkpoint方式自动维护偏移量

//设置上下文
SparkConf conf = new SparkConf().setAppName("direct").setMaster("local[2]");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(10));

//设置checkpoint路径
jsc.checkpoint("./ck");

//设置kafka各节点路径
HashMap<String, String> parms = new HashMap<>();
parms.put("metadata.broker.list", "node01:9092,node02:9092,node03:9092");
//设置读取的topic
HashSet<String> topics = new HashSet<>();
topics.add("topic1");topics.add("topic2");

/*
通过KafkaUtils创建DStream.参数为：
    上下文，kafka中key类型，value类型，key解码方式,vlaue解码方式，kafka参数，topic
*/
JavaPairInputDStream<String, String> ds = KafkaUtils.createDirectStream(
        jsc,
        String.class,
        String.class,
        StringDecoder.class,
        StringDecoder.class,
        parms,
        topics
);

 

自定义维护offsets的代码示例：

//设置上下文与传统方式一致，不再设置checkpoint路径   jsc.checkpoint("./ck");
SparkConf conf = new SparkConf().setAppName("direct").setMaster("local[2]");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(10));
HashMap<String, String> parms = new HashMap<>();
parms.put("metadata.broker.list", "node01:9092,node02:9092,node03:9092");

//读取偏移量数据，本示例中直接指定了偏移量，生产环境中从数据度读取偏移量
//使用Map容器临时存储，key为TopicAndPartition对象，value为偏移量

Map<TopicAndPartition, Long> offsets = new HashMap<>();
TopicAndPartition tp1 = new TopicAndPartition("topic1", 0);
TopicAndPartition tp2 = new TopicAndPartition("topic1", 1);
offsets.put(tp1, 123L);
offsets.put(tp2, 456L);

//创建DStream，参数为：
//    上下文，kafka中key类型，value类型，key解码方式,vlaue解码方式，DStream的数据类型,kafka参数，存储偏移量的map容器，获取消息的value作为DStream的数据
JavaInputDStream<String> ds = KafkaUtils.createDirectStream(
        jsc,
        String.class,
        String.class,
        StringDecoder.class,
        StringDecoder.class,
        String.class,
        parms,
        offsets,
        new Function<MessageAndMetadata<String, String>, String>() {
            @Override
            public String call(MessageAndMetadata<String, String> v1) throws Exception {
                return v1.message();
            }
        }
);

//设置新的偏移量封装容器
AtomicReference<OffsetRange[]> offsetRanges = new AtomicReference();

//必须在第一个DStream中通过RDD，获取当前的偏移量
JavaDStream<String> ds1 = ds.transform(new Function<JavaRDD<String>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<String> rdd) throws Exception {
        //通过RDD获取当前偏移量
        OffsetRange[] offsets = ((HasOffsetRanges) rdd.rdd()).offsetRanges();
        //将偏移量存入偏移量封装容器中，返回出去
        offsetRanges.set(offsets);
        return rdd;
    }
});

//通过output算子触发逻辑，在执行完成时，将偏移量提交到数据库
//这一过程中为了避免数据重复消费，输出操作应当是幂等输出，或者使用事务，目的都是保证偏移量提交与输出操作的一致性

ds1.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> RDD) throws Exception {
        //以下触发算子的输出操作和偏移量向外存储，写在一个事务中（建议使用异常机制）
        
        //触发算子
        RDD.foreach(x -> System.out.println(x));

        //将偏移量封装容器转换为数组，每个元素就是一个OffsetRange对象。
        //OffsetRange对象存储了一个topic分区的偏移量信息，可以对OffsetRange解析后存入数据库
        OffsetRange[] offsets = offsetRanges.get();
        for (OffsetRange x : offsets) {
            //解析
            String topic = x.topic();
            int partition = x.partition();
            long offset = x.untilOffset();
        }
    }
});

 

Spark2.3+kafka0.10+

• 只有direct模式

• 偏移量维护策略：

  1. 使用kafka维护，kafka中使用特殊的topic(_consumer_offsets)实现

  2. 若设置了checkpoint，则偏移量会存在checkpoint中维护。

  3. 使用自定义方式维护偏移量

• 任务分配策略

  • LocationStrategies.PreferBrokers：如Executor在kafka 集群中的节点上，该executor 读取当前broker节点的数据（一般用这个）

  • LocationStrategies.PreferFixed：节点之间的分区有明显的分布不均，通过一个map 指定将topic分区分布在哪些节点中

• 缓存策略

  • kafka的数据预先读取到Executor的缓存中再处理，该缓存默认64K，能够加快数据的处理速度

  • spark.streaming.kafka.consumer.cache.maxCapacity 控制缓存大小

  • spark.streaming.kafka.consumer.cache.enabled 控制缓存机制开关

kafka维护偏移量

• 提交时间

  • 自动提交默认5s提交一次偏移量，参数auto.commit.interval.ms控制

  • 手动提交偏移量，底层api也是异步的

• 问题

  • 若一天不访问kafka偏移量数据，kafka会自动清空

  • 使用手动提交偏移量的方式，偏移量提交与结果输出是异步的，也重复输出的问题

本示例中：使用手动向kafka提交偏移量

//创建JavaStreamingContext
SparkConf conf = new SparkConf().setAppName("direct").setMaster("local[2]");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(10));

//创建kafka参数对象
HashMap<String, Object> kafkaParams = new HashMap<>();
//kafka节点
kafkaParams.put("bootstrap.servers", "node1:9092,node2:9092,node3:9092");
//第一次读取的偏移量位置
kafkaParams.put("auto.offset.reset", "earliest");
//消费者组
kafkaParams.put("group.id", "myGroup");
//key序列化方式
kafkaParams.put("key.deserializer", StringDeserializer.class);
//key序列化方式
kafkaParams.put("value.deserializer", StringDeserializer.class);
//设置偏移量手动提交
kafkaParams.put("enable.auto.commit", false);

//设置读取的topics
Collection<String> topics = Arrays.asList("sm3");

//构建初始DStream，其数据元素为一条kafka的消息具备value值与kafuka的相关属性
//传入 上下文，task分配策略 ，kafkfa参数（topic+参数map）
JavaInputDStream<ConsumerRecord<String, String>> stream =
        KafkaUtils.createDirectStream(
                jsc,
                LocationStrategies.PreferBrokers(),
                ConsumerStrategies.Subscribe(topics, kafkaParams)
        );

//偏移量封装类具备原子更新属性
AtomicReference<OffsetRange[]> newoffset = new AtomicReference();

JavaDStream<String> stream1 = stream.transform(new Function<JavaRDD<ConsumerRecord<String, String>>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<ConsumerRecord<String, String>> RDD) throws Exception {
        //获取偏移量，新的偏移量必须从初始DStream的第一个RDD中获取,其他的RDD弃置该信息
        OffsetRange[] offsetRanges = ((HasOffsetRanges) RDD.rdd()).offsetRanges();
        //将偏移量设置在封装对象中
        newoffset.set(offsetRanges);

        //将初始DStream解析为普通的RDD，即取出value值
        return RDD.map(new Function<ConsumerRecord<String, String>, String>() {
            @Override
            public String call(ConsumerRecord<String, String> record) throws Exception {
                //可以从每条记录中取出消息值及其kafka相关信息
                record.key(); record.topic(); record.partition();
                return record.value();
            }
        });
    }
});


//在执行触发算子时提交偏移量
stream1.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> RDD) throws Exception {
        
        /*为了避免数据重复输出，采用以下两种方式解决：
        1.实现输出代码的幂等性
        2.将输出代码与偏移量提交代码写在一个事务中
        */
        
        //触发算子
        RDD.foreach(s->System.out.println(s));

        //通过偏移量封装对象获取偏移量
        OffsetRange[] offsetRanges = newoffset.get();
        //通过初始DStream转换，使用自动提交偏移量
        ((CanCommitOffsets) stream.inputDStream()).commitAsync(offsetRanges);
    }
});

 

自定义维护偏移量

• 实现从外部数据库读取偏移量，将新的偏移量存入外部数据库

• 这种方式也存在重复输出的问题，需要实现输出幂等或(输出+offset)事务

//kafka参数
HashMap<String, Object> kafkaParams = new HashMap<>();
kafkaParams.put("bootstrap.servers", "node1:9092,node2:9092,node3:9092"); 
kafkaParams.put("auto.offset.reset", "earliest"); 
kafkaParams.put("group.id", "myGroup"); 
kafkaParams.put("key.deserializer", StringDeserializer.class); 
kafkaParams.put("value.deserializer", StringDeserializer.class); 
kafkaParams.put("enable.auto.commit", false);

//本例子中直接给定偏移量，生产环境中偏移量从外部外部数据库读入
//偏移量通过map封装
Map<TopicPartition, Long> offsetdata = new HashMap<>();
offsetdata.put(new TopicPartition("topic1", 0), 123L);
offsetdata.put(new TopicPartition("topic1", 1), 444L);

//构建初始DStream。参数：
// 上下文，task分配策略 ，kafkfa参数（topic+参数map+偏移量map）
JavaInputDStream<ConsumerRecord<String, String>> stream = KafkaUtils.createDirectStream(
        jsc,
        LocationStrategies.PreferBrokers(),
        ConsumerStrategies.Assign(offsetdata.keySet(), kafkaParams, offsetdata));

//获取偏移量方式与上述方式相同，区别在于提交偏移量的方式不同 
AtomicReference<OffsetRange[]> newoffset = new AtomicReference();
JavaDStream<String> stream1 = stream.transform(new Function<JavaRDD<ConsumerRecord<String, String>>, JavaRDD<String>>() {
    @Override
    public JavaRDD<String> call(JavaRDD<ConsumerRecord<String, String>> RDD) throws Exception {
        //获取偏移量
        newoffset.set(((HasOffsetRanges) RDD.rdd()).offsetRanges());
        return RDD.map(x->x.value());
    }
});


stream1.foreachRDD(new VoidFunction<JavaRDD<String>>() {
    @Override
    public void call(JavaRDD<String> RDD) throws Exception {
        /*为了避免数据重复输出，采用以下两种方式解决：
        1.实现输出代码的幂等性
        2.将输出代码与偏移量提交代码写在一个事务中
        */
        //触发算子
        RDD.foreach(s->System.out.println(s));

        //通过偏移量封装对象获取偏移量,遍历偏移量存入数据库
        OffsetRange[] offsetRanges = newoffset.get();
       for(OffsetRange x : offsetRanges ){
           System.out.println(x);
       }

/**
* 开启事务
*/
//1.提交偏移量到redis
//2.提交计算结果到mysql中
//3.做好事务原子性的维护   
    }
});

 

checkpoint维护偏移量

• driver宕机恢复容易产生数据重复消费

• 修改代码逻辑，会导致原checkpoint偏移量丢失

代码实现kafka维护基本一致，只需要指定checkpoint的路径

整合参数

• receiver模式的参数

  • spark.streaming.receiver.writeAheadLog.enable 默认false 是否开启预写日志

  • spark.streaming.blockInterval 默认200ms 对一批数据的切分间隔，用于控制receiver模式下的分区数

  • spark.streaming.receiver.maxRate 无默认值 修改receiver task的最大拉取速率

• Direct模式

  • spark.streaming.kafka.maxRatePerPartition 修改每个分区拉取数据的最大速率

• 反压机制

  • spark.streaming.backpressure.enabled 默认false 微调数据拉取速率，提高运行效率

• 关停任务

  • spark.streaming.stopGracefullyOnShutdown 设置 true

  • kill -15/sigterm driverpid

注：以上参数均可以在conf中设置

 

遗留问题：HA的ck，对direct模式的影响