Flink每日一考

已于 2023-07-03 18:50:00 修改
阅读量243 收藏
点赞数
分类专栏： Flink 文章标签： flink 大数据
于 2023-06-15 17:32:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40382400/article/details/131232159
版权
本文介绍了ApacheFlink的基本概念，包括Flink是一个有状态的流式计算框架，给出了一个简单的WordCount程序示例，讨论了Flink的三种部署模式（会话、单作业和应用模式）以及并行度的设置。此外，还涉及了算子链、作业并行度的确定、Yarn应用模式作业提交流程、Flink与Kafka的集成以及Flink中的时间语义、Watermark策略等核心概念。
摘要由CSDN通过智能技术生成

1. 一句话描述Flink

有状态的流式计算框架

 2. 手写Wordcount程序

package com.atguigu.flink.wordcount;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

/**
 * @author WEIYUNHUI
 * @date 2023/6/10 11:15
 *
 * Lambda表达式写法
 *
 * 泛型擦除问题:
 *   The generic type parameters of 'Collector' are missing.
 *   In many cases lambda methods don't provide enough information for automatic type extraction when Java generics are involved.
 *
 *   The return type of function 'main(Flink05_LambdaWordCount.java:34)' could not be determined automatically,due to type erasure.
 *   You can give type information hints by using the returns(...) method on the result of the transformation call,
 *   or by letting your function implement the 'ResultTypeQueryable' interface.
 *
 *
 * 解决方案：
 *   在调用完转换算子后， 如果存在泛型擦除问题， 可以通过调用returns()方法， 明确指定类型即可。
 *   returns(Class<T> typeClass)  : 明确指定类型。通过Class来指定。一般适用于明确的类(类中不包含泛型)
 *   returns(TypeHint<T> typeHint): 适用于任何情况。 通过TypeHit来明确指定类型。
 *   returns(TypeInformation<T> typeInfo) : 适用于任何情况，通过TypeInformation来明确类型。
 *
 *
 */
public class Flink05_LambdaWordCount {
    public static void main(String[] args) throws Exception {
        // 1. 创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //设置并行度
        env.setParallelism(1) ;

        // 2.读取数据
        // DataStreamSource => DataStream
        DataStreamSource<String> ds = env.socketTextStream("hadoop102", 8888) ;

        // 3.转换处理
        // 3.1 切分数据， 处理成(word, 1)
        SingleOutputStreamOperator<Tuple2<String, Integer>> flatMapDs = ds.flatMap(
                //lambda写法
                (String line, Collector<Tuple2<String, Integer>> out) -> {
                    String[] words = line.split(" ");
                    for (String word : words) {
                        out.collect(Tuple2.of(word, 1));
                    }
                }
        ).returns(Types.TUPLE(Types.STRING , Types.INT));
         /*
         .returns(new TypeHint<Tuple2<String, Integer>>() {
            @Override
            public TypeInformation<Tuple2<String, Integer>> getTypeInfo() {
                return super.getTypeInfo();
            }
        });

         */
        // 3.2 按照单词分组
        KeyedStream<Tuple2<String, Integer>, String> keyByDs = flatMapDs.keyBy(
                tuple -> tuple.f0
        );
        // 3.3 汇总
        // 使用Tuple中的第二个元素进行汇总
        SingleOutputStreamOperator<Tuple2<String, Integer>> sumDs = keyByDs.sum(1);

        // 4. 输出结果
        sumDs.print();

        // 5. 启动执行
        env.execute();
    }

}

3. 简述Flink的三种部署模式及区别

 1. 会话模式
     可以提交多个job到集群，要求每个job执行时间短
 2. 单作业模式
     1个job对应一个集群，main方法在client端执行
 3. 应用模式
     1个job对应一个集群，main方法在jobManager执行
 区别：单作业模式已经不用了，在生产中，需要根据实际情况选择模式，如果job比较大，运行时间长，选择应用模式，如果job比较多，运行时间短，选择会话模式

4. 简述并行度的概念及设置方式

并行度是指算子的并行程度

 1. 可以在算子后面设置
 2. 在代码中，全局设置
 3. 在提交job时设置
 4. 在配置文件中设置

5. 简述算子链的概念、合并算子链的条件、如何禁用算子链

概念：把多个算子合并，就称为算子链
条件：2个算子的并行度相同，分发规则为forword
禁用：

 1. 可以在代码中使用startNewChain，开启一个新链
 2. 可以在算子后面调用禁用方法
 3. 可以在代码中全局禁用
 

6. 一个作业的并行度如何确定？一个作业需要多少个slot如何确定？

 1. 并行度最大的算子的并行度，就是一个作业的并行度
 2. slot，根据并行度最大的算子的并行度确定

7. 手绘Yarn应用模式作业提交流程

点击这里查看

8.Flink StreamExecutionEnvironment的执行模式有几种，分别是什么？

3种

  1. AUTOMATIC
  2. STREAMING
  3. BATCH

9. kafka消费者的相关参数解释

key.deserializer:key的反序列化方式

value.deserializer:value的反序列化方式

bootstrap.servers:集群地址

group.id:消费组id

auto.offset.reset:自动重置偏移量，头或者尾

enable.auto.commit:消费者自动提交

auto.commit.interval.ms:自动提交间隔

10.Flink消费kafka数据的代码

package com.atguigu.flink.datastream.source;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.connector.file.src.FileSource;
import org.apache.flink.connector.file.src.reader.TextLineInputFormat;
import org.apache.flink.connector.kafka.source.KafkaSource;
import org.apache.flink.connector.kafka.source.enumerator.initializer.OffsetsInitializer;
import org.apache.flink.core.fs.Path;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.OffsetResetStrategy;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.internals.Topic;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;

/**
 * @author WEIYUNHUI
 * @date 2023/6/13 9:13
 * <p>
 * Kafka Connector :
 * 1. 从kafka中消费数据
 * 1.1 消费者对象:
 * KafkaConsumer
 * 1.2 消费者相关配置：
 * key/value的反序列化器:
 * key.deserializer => org.apache.kafka.common.serialization.StringDeserializer
 * value.deserializer => org.apache.kafka.common.serialization.StringDeserializer
 * 集群地址:
 * bootstrap.servers  => hadoop102:9092,hadoop103:9092,hadoop104:9092
 * 消费者组:
 * group.id  => 随便
 * offset自动提交:
 * enable.auto.commit  => true / false
 * offset自动提交的间隔:
 * auto.commit.interval.ms => 5000
 * offset重置：
 * auto.offset.reset => latest（尾） | earliest（头）
 * 重置的情况:
 * 1. 新的消费者组 ， 之前没有消费过数据， 也就没有对应的offset
 * 2. 旧的消费者组 ， 之前有消费过数据，但是对应的offset已经在kafka中不存在（可能的原因是Kafka默认7天会清理数据）
 * <p>
 * 1.3 Kafka提供的消费者的配置类 ConsumerConfig
 * <p>
 * 2. 往kafka生产数据
 */
public class Flink03_KafkaSource {
    public static void main(String[] args) {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        /*
                封装要从哪个主题那个分区的offset进行消费
                TopicPartition topicPartition = new TopicPartition("topicA", 3);
                HashMap<TopicPartition, Long> offsets = new HashMap<>();
                offsets.put(topicPartition , 40L) ;
         */

        KafkaSource<String> kafkaSource =
                KafkaSource.<String>builder()
                        .setBootstrapServers("hadoop102:9092,hadoop103:9092")
                        .setGroupId("flink1")
                        .setTopics("topicA")
                        .setValueOnlyDeserializer(new SimpleStringSchema()) //仅针对于没有key的消息
                        //.setDeserializer() //针对于key和value
                        // 默认使用记录的offset进行消费 ，如果涉及到重置offset， 选择重置到尾
                        //.setStartingOffsets(OffsetsInitializer.committedOffsets(OffsetResetStrategy.LATEST))
                        // 默认使用记录的offset进行消费 ，如果涉及到重置offset， 选择重置到头
                        .setStartingOffsets(OffsetsInitializer.committedOffsets(OffsetResetStrategy.EARLIEST))
                        // 指定Offset消费
                        //.setStartingOffsets(OffsetsInitializer.offsets(offsets))
                        //如果其他的设置没有对应的方法， 统一使用.setProperty( 配置项 ， 配置值)
                        // .setProperty("enable.auto.commit" , "true" )
                        .setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true")
                        //.setProperty("auto.commit.interval.ms" , "6000")
                        .setProperty(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "6000")
                        .build();

        DataStreamSource<String> ds = env.fromSource(kafkaSource, WatermarkStrategy.noWatermarks(), "kafkaSource");

        ds.print();
        try {
            env.execute();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

11.Flink提供的基本转换算子有哪些？分别解释每个算子的功能

  1. map：一对一转换
  2. flatmap：扁平化
  3. filter：过滤

12.Flink提供的基本聚合算子有哪些？分别解释每个算子的功能

  1.  keyBy:分组
  2. sum:和
  3. max：最大值，只有一个字段变化
  4. min:最小值，只有一个字段变化
  5. maxBy:最大值，整条数据
  6. minBy:最小值，整条数据
  7. reduce：归约聚合

13.解释reduce算子的聚合原理

两两聚合

14.Flink支持的source有哪些？

  1. kafka
  2. 文件
  3. 集合
  4. 自定义
  5. Socket
  6. 数据生成器

15.Flink提供的分区算子有哪些？分别解释分区的规则

  1. 随机分配（Random）：随机

  2. 轮询分配（Round-Robin）：轮询

  3. 重缩放（Rescale）：

    重缩放分区和轮询分区非常相似。当调用rescale()方法时，其实底层也是使用Round-Robin算法进行轮询，但是只会将数据轮询发送到下游并行任务的一部分中。rescale的做法是分成小团体，发牌人只给自己团体内的所有人轮流发牌。

  4. 广播（Broadcast）：将输入数据复制并发送到下游算子的所有并行任务中去。

16.简述RichFunction的功能

算子的生命周期，上下文对象

17.Flink如何实现分流

使用侧输出流

18.Flink如何使用侧输出流

定义一个OutputTag,调用context.output()方法

19.Flink合流的union和connect如何用，区别是什么？

区别：union要求两个流的数据类型必须相同，connect可以不同

20.kafka生产者相关参数解释

key.serializer:key的序列化方式

value.serializer:value的序列化方式

bootstrap.servers:集群地址

retries:重试次数

batch.size:缓冲区大小

linger.ms:超过多长时间就发送缓冲区的数据

acks:应答级别

21.kafka生产者分区规则

  1. 如果指定了分区，那么直接存
  2. 如果指定了key，那么用key的hash
  3. 否则用粘性分区

22.Flink中的时间语义有哪些？

  1.  事件时间
  2. 处理时间

23.Watermark的意义是什么?

基于processingTime的语义场景下，Watermark无意义。不需要！
     基于EventTime的语义场景下，Watermark就是当前的时间。
     意义： 通知算子，当前几点了。
                1）基于EventTime的窗口运算
                2）基于EventTime的定时器
                3）CEP(特殊事件处理)

24.Watermark是什么?

watermark是一种特殊的数据。
      可以在源头(source算子)产生，可以在中间环节产生，随着数据向下游流动。
      下游的算子收到watermark时，就知道当前系统时间是多少了(EventTime语义场景)。

25.如何构造WaterMark的生成策略?

系统提供:
            连续： WatermarkStrategy.<Event>forBoundedOutOfOrderness(0)
                     WatermarkStrategy.<WaterSensor>forMonotonousTimestamps()
            乱序: WatermarkStrategy.<Event>forBoundedOutOfOrderness(1)

        自定义:
                自定义类 implements WatermarkGenerator.
                参考Flink01_UserDefineWaterMark

26.多并行度下watermark的推进策略是什么？

上游Task向下游的每一个Task广播水印。
        下游Task收到上游多个Task的水印，取最小的作为当前水印。

27.如果某一个并行度的watermark不推进导致整个下游的watermark无法推进，如何处理?

.withIdleness(Duration.ofSeconds(10))  //10秒没有推进，就取消资格

package com.atguigu.flink.timeAndwindow;

import com.atguigu.flink.func.WaterSensorMapFunction;
import com.atguigu.flink.pojo.WaterSensor;
import com.atguigu.flink.utils.MyUtil;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

import java.time.Duration;

/**
 * Created by 黄凯 on 2023/6/20 0020 21:18
 *
 * @author 黄凯
 * 永远相信美好的事情总会发生.
 * <p>
 * 如果某一个并行度的watermark不推进导致整个下游的watermark无法推荐，如何处理?
 * *
 * *  查看水印?
 * *      WEBUI: 当前看不到，看到下游收到的水印。
 * *
 * *  ------------------------------
 * *      6个MapTask，只有1个能收到数据，但是6个人都要发送水印。
 * *          设置Task发送水印的资格。
 * *              如果一个Task，长期无法收到数据，导致水印无法更新，推进。就取消这个Task的水印发送资格！
 * *
 * *
 * *           Idle: 空闲，赋闲。
 */
public class Flink13_MultiParilismWaterMark {

    public static void main(String[] args) {

        Configuration conf = new Configuration();
        conf.setInteger("rest.port", 3333);
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(conf);

        //修改水印的默认的发送频率
        env.getConfig().setAutoWatermarkInterval(2000);

        //模拟多并行度
        env.setParallelism(6);

        //声明水印策略
        WatermarkStrategy<WaterSensor> watermarkStrategy = WatermarkStrategy
                //第一部分: 水印的特征。 连续，乱序
                .<WaterSensor>forMonotonousTimestamps()
                //第二部分： 如何从数据中提取事件时间
                .withTimestampAssigner((e, ts) -> e.getTs())
                .withIdleness(Duration.ofSeconds(10))  //10秒没有推进，就取消资格
                ;

        env
                .socketTextStream("127.0.0.1", 8888)
                //全局汇总 所有的数据都给下游的第一个Task
                .global()
                .map(new WaterSensorMapFunction())
                .assignTimestampsAndWatermarks(watermarkStrategy)
                /*
                    数据落入哪个窗口不看水印(没有半毛钱关系)。只看 数据的EventTime和窗口的范围。
                    [0,4999):
                    [5000,9999):
                 */
                .windowAll(TumblingEventTimeWindows.of(Time.milliseconds(5000)))
                .process(new ProcessAllWindowFunction<WaterSensor, String, TimeWindow>() {
                    @Override
                    public void process(ProcessAllWindowFunction<WaterSensor, String, TimeWindow>.Context context,
                                        Iterable<WaterSensor> iterable,
                                        Collector<String> collector) throws Exception {

                        //输出窗口中的所有的元素
                        collector.collect(MyUtil.parseToList(iterable).toString());
                    }
                })
                .print();


        try {
            env.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

28.如何处理乱序的场景?

 1)推迟时钟(时间 | 水印)
                WatermarkStrategy.<Event>forBoundedOutOfOrderness(n)
        2)延迟窗口的关闭时间
                Window.allowLateness(Time n)
        3)使用侧流接收数据，之后再酌情处理。

29.什么是flink中的定时器？如何制定定时器?

定时器： 在固定的时间运行的一段程序。

        指定定时器：
                    1）无keyBy不定时。
                        只有KeyedStream才能制定定时器
                    2）获取时钟服务
                        context.getTimeService().registXXXXTimer(时间)

30.什么是状态?

在flink的处理函数中声明的用于供Event读写的变量。

31.Flink中的状态分类？如何声明和使用状态?

    RawState： 用户自己声明的变量。
    ManagedState： flink提供了状态类型
        KeyedState： 对KeyedStream进行处理，生命的状态都是KeyedState，每个key都有自己的状态。
                        各玩各的，互不干扰。

                        单个值： ValueState
                        Map集合： MapState
                        List集合: ListState
                        聚合功能:  输入类型=输出类型 ReducingState
                                 输入类型=输出类型 AggregatingState

                        在处理函数对象中声明属性，在open()方法中从context中获取状态，赋值。


        OperateState：  一个算子的Task上，所有处理的数据共用一个状态。
                        List集合:
                                    ListState
                                        元素的分配方式:  均匀分配
                                    UnionListState
                                        元素的分配方式:  每个Task获取全量

                       用于更新配置信息:  BroadCastState

32.熟练掌握常见状态的API操作。

读:  value()
        写:  add(), addAll(), update()
        清空: clear()

33.Flink中状态的分类，列举每种类型的状态

  1. RawState
    1. 自定义
  2. ManagedState
    1. KeyedState
      1. ValueState
      2. ListState
      3. MapState
      4. ReducingState
      5. AggregatingState
    2. OperateState
      1. ListState
      2. UnionListState
      3. BroadcastState

34.什么是Barrier?Barrier对齐和Barrier不对齐怎么理解？

栅栏，开始备份状态的标记

  1. 对齐

        一个下游对多个上游，需要上游的所有barrier到齐，才能备份

      2.不对齐

        一个下游对多个上游，不需要上游的所有barrier到齐，才能备份，只要有一个到达，就可以备份

35.检查点和保存点的使用场景是什么？

  1. 检查点
    1. 用于系统意外故障恢复
  2. 保存点
    1. 用于系统升级，需要手动备份，通过命令

36.一致性的级别有几种，分别进行解释

  1. 精确一次（Exactly-Once） 
    1. 数据不丢，也不重复
  2. 至少一次（At-Least-Once）
    1. 会重复
  3. 最多一次（At-Most-Once）
    1. 会丢

37.如何保证端到端一致性，从输入端，计算过程，输出端分别说明

  1. 输入端
    1. 数据可重放
  2. 计算过程
    1. Flink开启检查点，精确一次
  3. 输出端
    1. 幂等 或 事务

38.解释动态表和持续查询的概念

  1. 动态表
    1. 表中的数据会发生变化
  2. 持续查询
    1. 来一条数据查询一次

39.创建表处理环境

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
//将流式执行环境转换成表执行环境
StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

40.创建表

package com.atguigu.flink.sql.connector;

import org.apache.flink.table.api.EnvironmentSettings;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.TableEnvironment;

/**
 * Created by  on 2023/6/25 0025 18:22
 *
 * @author 
 * 永远相信美好的事情总会发生.
 *
 * FileConnector :  基于文件读写。
 */
public class Flink02_FileConnector {

    public static void main(String[] args) {

        //1. 创建表环境
        TableEnvironment tableEnv = TableEnvironment.create(EnvironmentSettings.newInstance().build());

        //2. File Connector read
        String readSql=
                " create table t1 (" +
                        " id STRING , " +
                        " vc INT , " +
                        " ts BIGINT, " +
                        //" `file.path` STRING NOT NULL METADATA ," +
                        //" `file.name` STRING NOT NULL METADATA " +
                        " `file.size` BIGINT NOT NULL METADATA " +
                        ") WITH ( " +
                        " 'connector' = 'filesystem' , " +
                        " 'path' = 'input/ws.txt', " +
                        " 'format' = 'csv' " +
                        ")" ;

        tableEnv.executeSql(readSql);

        Table table = tableEnv.sqlQuery("select id ,vc ,ts  , `file.size` as fs from t1  where vc > 200");

        tableEnv.createTemporaryView("t2",table);

        //File Connector write
        String writeSql =
                " create table t3 (" +
                        " id STRING , " +
                        " vc INT , " +
                        " ts BIGINT, " +
                        " fs BIGINT " +
                        ") WITH ( " +
                        " 'connector' = 'filesystem' , " +
                        " 'path' = 'output' ," +
                        " 'format' = 'json' " +
                        ")" ;

        tableEnv.executeSql(writeSql);

        //从t2查询数据，写入到t3表
        tableEnv.executeSql("insert into t3 select * from t2");

    }

}

41.流表转换

//读取数据
DataStreamSource<Event> stream = env.addSource(new ClickSource());    
//将流转换成表
Table table = tableEnv.fromDataStream(stream);

42. hbase-概念解释

  1. rowkey
    1. 一行数据的key，唯一标识
  2. region
    1. 被切分的若干行数据
  3. store
    1. 在切分行的基础上，再对列族进行切分
  4. namespace
    1. 库
  5. table
    1. 表
  6. row
    1. 一行
  7. column
    1. 一列
  8. columnFamily
    1. 列族
  9. timeStamp
    1. 版本
  10. cell
    1. 一个单元格的数据

43.简述master和regionserver的职责

  1. master
    1. 负责通过zk监控Reginaserver进程状态，同时是所有元数据变化的接口。内部启动监控执行region的故障转移和拆分的线程
  2. regionserver
    1. 主要负责数据cell的处理。同时在执行区域的拆分和合并的时候，由regionserver来实际执行。

44.Hbase shell namespace相关命令

  1. create_namespace 'bigdata'

  2. list_namespace

45.Hbase shell table ddl相关命令

  1. create 'bigdata:student', {NAME => 'info', VERSIONS => 5}, {NAME => 'msg'}

  2. create 'student1','info'

  3. list

  4.  describe 'student1'

  5. alter 'student1',  {NAME => 'f1', VERSIONS => 3}

  6. alter 'student1', NAME => 'f1', METHOD => 'delete'

  7. alter 'student1', 'delete' => 'f1'

  8.  disable 'student1'

  9. drop 'student1'

46.Hbase shell table dml相关命令

  1. put 'bigdata:student','1001','info:name','zhangsan'

  2. get 'bigdata:student','1001'

  3.  get 'bigdata:student','1001' , {COLUMN => 'info:name'}

  4. get 'bigdata:student','1001' , {COLUMN => 'info:name', VERSIONS => 6}

  5. scan 'bigdata:student',{STARTROW => '1001',STOPROW => '1002'}

  6. delete 'bigdata:student','1001','info:name'

  7. deleteall 'bigdata:student','1001','info:name'

青云游子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flink读取kafka 提交offset
monsterXZB的博客
10-07 538
【1】配置checkpoint，flink的Barrier数据对齐机制会将sink端的Barrier提交到jobmanager ,jobmanager 提交offset。flink的kafka客户端的cousmer中查询是否存在offset，如果存在，则是使用kafka的offset,不存在则从头开始读取 、 最新地方。【2】配置checkpoint，当chekcpoint完成时【1】会提交offset。flink设置为latest / earliest模式。
Flink1.14新版KafkaSource和KafkaSink实践使用(自定义反序列化器、Topic选择器、序列化器、分区器)
Hushhhh的博客
01-09 9505
Flink1.14新版KafkaSource和KafkaSink实践使用(自定义反序列化器、Topic选择器、序列化器、分区器)
flink kafka offset配置
hzp666的博客
12-22 1332
1.2、如果分区中offset没有找到，则使用kafka properties中的auto.offset.reset配置（比如：latest、earliest）配置：enable.auto.commit / auto.commit.interval.ms。从最早的记录开始，使用此配置，在kafka中已经提交的offset将被忽略，不会被使用。从最新的开始，使用此配置，在kafka中已经提交的offset将被忽略，不会被使用。flink kafka消费依赖于内部kafka客户端自动定期的offset提交。
Flink DataStream Connectors 之 Apache Kafka 连接器
京河小蚁的博客
06-19 1775
Flink 提供了 Apache Kafka 连接器使用精确一次（Exactly-once）的语义在 Kafka topic 中读取和写入数据。Apache Flink 集成了通用的 Kafka 连接器，它会尽力与 Kafka client 的最新版本保持同步。 该连接器使用的 Kafka client 版本可能会在 Flink 版本之间发生变化。 当前 Kafka client 向后兼容 0.10.0 或更高版本的 Kafka broker。 有关 Kafka 兼容性的更多细节，请参考 Kafka 官方文
Flink 之 Kafka连接器
weixin_42454473的博客
10-01 3382
Flink 之 Kafka连接器
【Flink】在算子中使用Tuple出现的bug
Zsigner的博客
07-06 777
在使用map，flatMap 算子的过程中想把pojo 转换成Tuple 类型进行输出，在编码的过程中正常，运行是出现异常
KafkaConsumer实现精确的latest(结尾)开始消费
DRD
08-23 4197
需求 调用某个接口，返回结果包含traceId，然后跟进该traceId去kafka查找debug日志。 分析 因为拿到traceId的时候，对方其实已经把debug信息发送到kafka了，所以我再在拿到traceId，再去kafka查找就要设置auto.offset.reset=earliest, 这就会导致我多查询很多的无效数据。 假如我在调用接口前，先订阅该topic，使用默认auto_offset_reset为latest，在拿到traceId再poll()，结果怎么样呢？不行，因为在poll时发现
Flink CDC MySQL同步MySQL（一）
07-06
jdbc
Flink一线公司经验实战
07-30
Apache Flink 是一款高度活跃的开源大数据计算引擎，专长在于实时计算和流式处理。在过去的几年中，尤其是在2019年，Flink 的发展速度显著，其GitHub Star 数量翻倍，Contributor 数量持续增长，这表明越来越多的...
flink1.18.1安装包
05-29
Flink 1.18.1 是一个高度可扩展的开源流处理框架，适用于实时数据流分析和批处理。在Linux环境下安装Flink 1.18.1，需要遵循以下步骤，确保系统具备必要的环境并正确配置。 首先，确保你的Linux系统上已经安装了...
flink-sql集成rabbitmq
06-29
Flink是一个开源的流处理框架，提供低延迟、高吞吐量的数据处理，而RabbitMQ是一个广泛使用的开源消息中间件，用于解耦应用间的数据通信。 在描述中没有给出具体细节，但我们可以假设这个项目或教程是关于如何使用...
Flink集成hive
02-28
#### 一、Flink与Hive集成概述 Apache Flink 是一个用于处理无界和有界数据流的开源流处理框架，它提供了丰富的API来构建复杂的数据处理管道。而Apache Hive则为用户提供了一种SQL的方式来进行数据查询和管理，尤其...
Flink 1.14.0 全新的 Kafka Connector
JasonLee实时计算
10-12 9034
Apache Kafka Connector#Flink 提供了一个 Apache Kafka 连接器，用于从 Kafka Topic 读取数据和向 Kafka Topic 写入数据，并保...
Flink的api入门案例
默主归沙的博客
04-21 662
超级简单的flink入门案例，一看就会。对初学者友好！
Flink使用lambda表达式报错：InvalidTypesException：could not be determined automatically, due to type erasure.
Aimo_哈撒的博客
11-26 3135
在写Flink程序的时候（以最简单的WordCount案例为例），有时会使用Lambda表达式来简化，如下边程序中的flatMap算子和Map算子处，都是用了Lambda表达式来简写： public static void main(String[] args) throws Exception { StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
flink读取不到文件_Flink开发遇到的问题汇总-
weixin_33344629的博客
01-17 3374
1，提交的离线任务完成之后，在一段时间后web端没有显示或者说自动消失： 原因分析：https://blog.csdn.net/u013076044/article/details/104740792是需要开启historyserver2，Flink读取hdfs的(hive分区)文件，目前已知有三种方式：通过循环union方式，本地可以执行，集群提交报错 通过官方API，可是只支持csv文件格式,...
SubscriptionState分析
happy19870612's blog
06-01 1667
KafkaConsumer从Kafka拉取消息的时候发送的请求时FetchRequest，在其中需要指定消费者希望拉取的起始消息的offset。为了消费者快速获取这个值，KafkaConsumer使用SubscriptionState来追踪TopicPartition与offset的关系： 一 SubscriptionType NONE: 没有状态 AUTO_TOPICS：按照指
Flink 1.10消费kafka topic 设置偏移量的几种方式
马斯特杨的博客
05-29 4017
所以必须配置group.id参数从消费者组提交的偏移量开始读取分区（kafka或zookeeper中）。如果找不到分区的偏移量，auto.offset.reset将使用属性中的设置。如果是默认行为(setStartFromGroupOffsets),那么任务从检查点重启，按照重启前的offset进行消费，如果直接重启不从检查点重启并且group.id不变，程序会按照上次提交的offset的位置继续消费。如果group.id改变了，则程序按照auto.offset.reset设置的属性进行消费。但是如果程序带
畅捷通基于Flink的实时数仓落地实践
最新发布
Ververica的博客
08-09 376
本文整理自畅捷通总架构师、阿里云MVP专家郑芸老师在 Flink Forward Asia 2023 中闭门会上的分享。
flink 每日一考
09-07
引用: Flink SQL 1.11版本引入了CDC机制，CDC全称为Change Data Capture，用于追踪数据库表的增删改查操作，并且是目前非常成熟的同步数据库变更的方案之一。Flink SQL内部完整支持了Changelog功能，可以处理Insert、Delete和Update这几种消息类型。动态表（Dynamic Table）是Flink SQL的基础概念，Flink SQL的各个算子之间传递的就是Changelog消息。对接CDC时，只需要将外部的数据流转换为Flink系统内部的Insert、Delete、Update消息即可，然后可以利用Flink的查询语法进行灵活的数据分析。 引用: 在实际应用中，可以将Debezium Kafka Connect Service注册到Kafka集群，并指定要同步的数据库表信息。Kafka会自动创建topic并监听Binlog，将变更同步到topic中。在Flink端消费带有CDC的数据也很简单，只需要在DDL中声明format = debezium-json即可。 根据引用和引用，Flink SQL的CDC机制可以通过连接Kafka实现数据变更的同步。首先，我们需要将Debezium Kafka Connect Service注册到Kafka集群，并配置要同步的数据库表信息。Kafka会自动创建相应的topic并监听数据库的Binlog，将数据变更同步到topic中。然后，在Flink中，我们可以通过声明相应的DDL语句，并设置format为debezium-json来消费带有CDC的数据。这样，我们就可以利用Flink的强大查询语法对同步的数据进行灵活的分析了。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值