一、Flink CDC同步数据时的延迟监控

很多做数据同步的朋友都会遇到一个头疼的问题:本来以为数据能实时同步,结果实际用的时候,上游数据库改了数据,下游要等好几秒甚至好几分钟才看到变化,这就是常说的“延迟”。延迟大了,做实时报表、实时风控这类对时效性要求高的业务就会出问题。那怎么知道自己的Flink CDC同步到底有没有延迟?延迟有多大?接下来就给大家说清楚。

1.1 延迟监控的核心指标

首先得明白,我们要监控的“延迟”到底是什么意思。其实就是上游数据产生的时间,到下游拿到这条数据的时间差。比如上游数据库10点整插入了一条用户订单数据,下游的数仓10点0分5秒才拿到这条数据,那这条数据的延迟就是5秒。

要监控这个指标,Flink CDC本身自带了一些方法,也可以结合其他工具。先给大家说最基础的,不用额外装工具的方法。

1.2 基于Flink内置指标的监控

Flink运行的时候会产生很多内置的监控指标,里面就有和延迟相关的。比如有个指标叫record-latency,专门用来记录每条数据的延迟。

这里给大家举个完整的示例,技术栈统一用Flink 1.17.0 + MySQL 8.0(Flink CDC同步MySQL的场景),代码是用Java写的:

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.cdc.connectors.mysql.source.MySqlSource;
import org.apache.flink.cdc.connectors.mysql.table.StartupOptions;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;

public class CdcLatencyMonitorDemo {
    public static void main(String[] args) throws Exception {
        // 1. 初始化Flink执行环境,设置并行度为2(根据实际资源调整)
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);

        // 2. 配置MySQL CDC源,连接到上游的订单数据库
        MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
                .hostname("127.0.0.1") // 上游MySQL的地址
                .port(3306) // MySQL端口
                .databaseList("order_db") // 要同步的数据库名
                .tableList("order_db.order_table") // 要同步的表名
                .username("root") // MySQL用户名
                .password("123456") // MySQL密码
                .startupOptions(StartupOptions.initial()) // 启动选项:全量同步+增量同步
                .deserializer(new org.apache.flink.cdc.debezium.JsonDebeziumDeserializationSchema()) // 把数据转成JSON格式
                .build();

        // 3. 读取CDC源数据,并且开启延迟监控
        env.fromSource(
                mySqlSource,
                WatermarkStrategy.noWatermarks(), // 这里不需要水位线,所以用无水位线策略
                "mysql-cdc-source"
        )
        // 打印数据(实际场景可以写到下游的Kafka、数仓等)
        .print();

        // 4. 执行任务
        env.execute("Flink CDC Latency Monitor Demo");
    }
}

写完这个代码运行起来后,怎么看延迟指标呢?Flink有个Web UI,默认端口是8081,比如你本地运行的话,打开http://localhost:8081,找到正在运行的这个任务,点进去后找到“Metrics”(指标)页面,搜索record-latency,就能看到当前的平均延迟、最大延迟这些数据了。

1.3 自定义埋点监控更精准

内置指标虽然方便,但有时候不够灵活。比如我们想知道某一条具体的订单数据从上游到下游的延迟,或者想把延迟数据存到自己的监控系统里,这时候就可以自己加埋点。

具体怎么做呢?其实就是在数据里加两个时间:一个是上游数据产生的时间(可以从MySQL的binlog里拿,或者自己在表的设计里加一个create_time字段,代表数据产生的时间),另一个是Flink拿到这条数据的时间。两个时间一减,就是这条数据的延迟。

给大家举个自定义埋点的代码示例,还是用刚才的技术栈:

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.cdc.connectors.mysql.source.MySqlSource;
import org.apache.flink.cdc.connectors.mysql.table.StartupOptions;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class CustomLatencyMonitorDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);

        MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
                .hostname("127.0.0.1")
                .port(3306)
                .databaseList("order_db")
                .tableList("order_db.order_table")
                .username("root")
                .password("123456")
                .startupOptions(StartupOptions.initial())
                .deserializer(new org.apache.flink.cdc.debezium.JsonDebeziumDeserializationSchema())
                .build();

        env.fromSource(
                mySqlSource,
                WatermarkStrategy.noWatermarks(),
                "mysql-cdc-source"
        )
        // 自定义Map函数,计算每条数据的延迟
        .map(new MapFunction<String, String>() {
            private static final long serialVersionUID = 1L;
            // 用来解析JSON的工具类
            private ObjectMapper objectMapper = new ObjectMapper();

            @Override
            public String map(String jsonData) throws Exception {
                // 1. 解析CDC拿到的JSON数据,拿到上游数据的产生时间(这里假设上游表的create_time是时间戳格式)
                JsonNode rootNode = objectMapper.readTree(jsonData);
                JsonNode afterNode = rootNode.get("after"); // CDC的JSON里,after节点是更新后的数据
                long createTime = afterNode.get("create_time").asLong(); // 拿到上游数据产生的时间戳(毫秒)

                // 2. 拿到Flink当前处理这条数据的时间(毫秒)
                long processTime = System.currentTimeMillis();

                // 3. 计算延迟(毫秒)
                long latency = processTime - createTime;

                // 4. 把延迟加到JSON里,方便后续查看或者存到监控系统
                JsonNode latencyNode = objectMapper.createObjectNode().put("latency_ms", latency);
                // 合并原来的JSON和延迟字段
                JsonNode resultNode = objectMapper.createObjectNode()
                        .set("original_data", rootNode)
                        .set("latency", latencyNode);

                // 把结果转成字符串返回
                return objectMapper.writeValueAsString(resultNode);
            }
        })
        // 打印带延迟的结果,实际场景可以写到Kafka或者数仓
        .print();

        env.execute("Custom Latency Monitor Demo");
    }
}

运行这个代码后,打印出来的每一条数据都会带一个latency_ms字段,就是这条数据的延迟,单位是毫秒。比如打印出来的内容可能是:

{"original_data":{"before":null,"after":{"id":1,"order_no":"ORD001","create_time":1690000000000},"source":{"db":"order_db","table":"order_table"},"op":"c"},"latency":{"latency_ms":123}}

这里的latency_ms:123就代表这条数据的延迟是123毫秒,是不是很直观?

二、Flink CDC同步数据时的延迟调优方法

监控到延迟大了,接下来就是想办法调优。调优不是随便改参数,得先搞清楚延迟是怎么来的。一般来说,延迟大的原因主要有几个:上游数据库的压力大、Flink集群的资源不够、同步的配置不合理、下游系统的写入慢。接下来就针对这些原因,给大家说具体的调优方法。

2.1 上游数据库的调优

很多人调优的时候只盯着Flink,忘了上游数据库才是数据的源头。如果上游数据库本身写数据就慢,或者binlog产生的速度慢,那Flink拿到数据的速度肯定也慢。

2.1.1 给上游数据库开binlog的并行写入

MySQL默认的binlog写入是串行的,也就是一条一条写。如果上游数据库的写入压力大,binlog产生的速度就会跟不上,导致Flink拿到数据的延迟变大。这时候可以给MySQL开并行写入binlog的配置。

怎么配置呢?修改MySQL的配置文件my.cnf(Windows下是my.ini),加下面的配置:

# 开启binlog的并行写入,值为1表示开启,0表示关闭
binlog_group_commit_sync_delay = 1000000
binlog_group_commit_sync_no_delay_count = 10

这里的配置意思是:最多等待1秒,或者最多收集10个事务,就把binlog批量写入一次。这样可以减少binlog写入的次数,提高写入速度。注意这个配置不能随便改,得根据自己的业务场景调整,比如如果业务对binlog的实时性要求极高,就不能等太久,那binlog_group_commit_sync_delay可以设小一点,比如10000(0.01秒)。

改完配置后,重启MySQL,配置就生效了。

2.1.2 给上游的同步表加合适的索引

如果同步的表经常做全量同步(比如Flink CDC启动的时候的全量同步阶段),那全量同步的速度会影响延迟。全量同步的时候,Flink会从上游数据库把表的所有数据都拉过来,如果表没有合适的索引,拉取数据的速度就会很慢。

比如同步的表是order_table,表的主键是id,那拉取数据的时候,Flink会按主键分批拉取,如果主键有索引,拉取的速度就会快很多。所以一定要保证同步的表的主键有索引,最好是主键索引,因为主键索引的效率最高。

2.2 Flink集群的资源调优

Flink是运行在集群上的,集群的资源不够,比如CPU、内存、磁盘不够,都会导致处理数据的速度变慢,延迟变大。

2.2.1 合理设置并行度

并行度是Flink里很重要的一个参数,简单说就是一个任务同时用多少个线程来处理。并行度太小,处理速度慢;并行度太大,会导致集群的资源竞争,反而变慢。

怎么设置合理的并行度呢?一般来说,Flink CDC的源端(也就是读取上游数据的部分)的并行度,不要超过上游数据库的CPU核心数。比如上游数据库是8核的,那Flink CDC源端的并行度最多设为8。

给大家举个设置并行度的代码示例:

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.cdc.connectors.mysql.source.MySqlSource;
import org.apache.flink.cdc.connectors.mysql.table.StartupOptions;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;

public class ParallelismDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 1. 设置整个任务的全局并行度为4(根据集群资源调整)
        env.setParallelism(4);

        MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
                .hostname("127.0.0.1")
                .port(3306)
                .databaseList("order_db")
                .tableList("order_db.order_table")
                .username("root")
                .password("123456")
                .startupOptions(StartupOptions.initial())
                .deserializer(new org.apache.flink.cdc.debezium.JsonDebeziumDeserializationSchema())
                .build();

        env.fromSource(
                mySqlSource,
                WatermarkStrategy.noWatermarks(),
                "mysql-cdc-source"
        )
        // 2. 也可以单独给某个算子设置并行度,比如打印算子的并行度设为2
        .setParallelism(2)
        .print();

        env.execute("Parallelism Demo");
    }
}

除了代码里设置,也可以在提交任务的时候通过命令行设置,比如:

# 提交Flink任务的时候,设置全局并行度为4
flink run -p 4 -c com.example.ParallelismDemo your-jar-file.jar

2.2.2 给Flink分配足够的内存

Flink处理数据的时候会用到很多内存,比如缓存数据、序列化数据都需要内存。如果内存不够,Flink会频繁地把数据写到磁盘(也就是常说的“换页”),导致处理速度变慢。

怎么给Flink分配内存呢?如果是本地运行,代码里可以设置:

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class MemoryDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置任务的堆内存为4G(根据实际情况调整)
        env.getConfig().setTaskManagerMemoryMB(4096);
        // 其他代码...
    }
}

如果是集群运行,比如用YARN部署的Flink,提交任务的时候可以加参数:

# 给每个TaskManager分配4G内存,每个Slot分配1G内存
flink run -p 4 -yjm 1024 -ytm 4096 -c com.example.YourClass your-jar-file.jar

这里的-yjm是给JobManager分配的内存,-ytm是给每个TaskManager分配的内存。

2.3 Flink CDC的配置调优

Flink CDC本身有很多配置参数,合理调整这些参数,也能有效降低延迟。

2.3.1 调整批量拉取的大小

Flink CDC在全量同步阶段,会分批从上游数据库拉取数据,每批拉取的大小是可以配置的。如果每批拉取的太小,拉取的次数就会变多,导致全量同步的速度变慢;如果每批拉取的太大,会给上游数据库造成太大的压力。

怎么配置呢?在创建MySqlSource的时候加参数:

MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
        .hostname("127.0.0.1")
        .port(3306)
        .databaseList("order_db")
        .tableList("order_db.order_table")
        .username("root")
        .password("123456")
        .startupOptions(StartupOptions.initial())
        // 配置每批拉取的大小为1000条(默认是1000,根据实际调整)
        .scanIncrementalSnapshotChunkSize(1000)
        .deserializer(new org.apache.flink.cdc.debezium.JsonDebeziumDeserializationSchema())
        .build();

这里的scanIncrementalSnapshotChunkSize参数就是每批拉取的大小,一般可以设为1000到10000之间,根据上游数据库的性能调整。

2.3.2 关闭不需要的功能

Flink CDC默认会开启一些功能,比如数据的校验、异常重试等,如果这些功能对自己的业务来说不是必须的,可以关闭,减少不必要的开销。

比如关闭数据的校验:

MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
        .hostname("127.0.0.1")
        .port(3306)
        .databaseList("order_db")
        .tableList("order_db.order_table")
        .username("root")
        .password("123456")
        .startupOptions(StartupOptions.initial())
        // 关闭数据校验,减少开销
        .debeziumProperties("database.history.skip.unparseable.ddl", "true")
        .deserializer(new org.apache.flink.cdc.debezium.JsonDebeziumDeserializationSchema())
        .build();

2.4 下游系统的调优

有时候延迟大不是Flink的问题,而是下游系统的写入速度慢。比如下游是Kafka,Kafka的分区数不够,或者Kafka的配置不合理,导致Flink往Kafka写数据的速度慢,也会导致整体的延迟变大。

2.4.1 给下游Kafka增加分区数

Kafka的分区数决定了写入的并行度,如果下游Kafka的分区数太少,Flink往Kafka写数据的速度就会慢。一般来说,Kafka的分区数要和Flink任务的并行度匹配,比如Flink任务的并行度是4,那Kafka的分区数最好也设为4。

怎么给Kafka增加分区数呢?可以用Kafka的命令行工具:

# 给topic为order_topic的Kafka主题增加分区数到4
kafka-topics.sh --alter --zookeeper localhost:2181 --topic order_topic --partitions 4

2.4.2 调整Kafka的写入配置

Kafka默认的写入配置也可以调整,比如调整批量写入的大小和等待时间,提高写入速度。比如在Flink往Kafka写数据的时候,调整配置:

import org.apache.flink.streaming.api.functions.sink.SinkFunction;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;
import java.util.Properties;

public class KafkaSinkDemo {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "localhost:9092");
        properties.setProperty("acks", "all");
        // 调整批量写入的大小为16KB(默认是16KB,可调整)
        properties.setProperty("batch.size", "16384");
        // 调整批量写入的等待时间为10毫秒(默认是0毫秒,可调整)
        properties.setProperty("linger.ms", "10");

        SinkFunction<String> kafkaSink = new FlinkKafkaProducer<>(
                "order_topic",
                new org.apache.flink.api.common.serialization.SimpleStringSchema(),
                properties
        );

        // 把Flink CDC的结果写到Kafka
        // env.fromSource(...).addSink(kafkaSink);
    }
}

这里的batch.size是批量写入的大小,linger.ms是批量写入的等待时间,合理调整这两个参数,可以提高Kafka的写入速度。

三、应用场景、优缺点与注意事项

3.1 应用场景

Flink CDC的延迟监控和调优,主要用在对数据时效性要求高的业务场景,比如:

  1. 实时报表:比如电商的实时销售报表,需要实时统计每一分钟的订单金额、订单量,如果延迟大,报表的数据就会不及时,影响业务决策。
  2. 实时风控:比如金融行业的实时风控系统,需要实时判断用户的交易是否有风险,如果延迟大,等判断结果出来的时候,用户的交易已经完成了,就起不到风控的作用。
  3. 实时推荐:比如短视频平台的实时推荐系统,需要根据用户的实时行为(比如点赞、评论)实时调整推荐内容,如果延迟大,推荐的内容就会过时,影响用户体验。

3.2 技术优缺点

3.2.1 优点

  1. 监控方式灵活:既可以用Flink的内置指标,也可以自定义埋点,满足不同的监控需求。
  2. 调优维度多:可以从上游数据库、Flink集群、Flink CDC配置、下游系统多个维度调优,总有适合自己业务的调优方法。
  3. 适配性强:可以同步多种数据库(比如MySQL、PostgreSQL、Oracle等),也可以同步到多种下游系统(比如Kafka、数仓、Redis等)。

3.2.2 缺点

  1. 调优复杂度高:调优需要对上游数据库、Flink、下游系统都有一定的了解,对新手来说门槛比较高。
  2. 依赖资源多:延迟调优需要足够的集群资源,如果资源不够,调优的效果会打折扣。
  3. 没有通用的调优方案:不同的业务场景、不同的集群环境,调优的参数都不一样,没有一个通用的调优方案,需要根据实际情况调整。

3.3 注意事项

  1. 调优前一定要先监控:不能盲目调优,一定要先监控找到延迟的原因,再针对性地调优。比如如果延迟是因为上游数据库的压力大,那调优Flink的配置是没用的。
  2. 调优要循序渐进:不要一次性改很多参数,最好是一次改一个参数,观察效果,再决定要不要改回来或者继续调整。
  3. 要考虑业务的可接受延迟:不是所有的业务都需要零延迟,比如有些业务可以接受1秒的延迟,那调优的时候就不用追求极致的延迟,避免浪费资源。
  4. 要注意调优对其他业务的影响:比如调整上游数据库的binlog配置,可能会影响其他使用binlog的业务,一定要先测试再上线。

四、文章总结

Flink CDC同步数据的延迟监控和调优,是一个系统性的工作,需要从监控入手,找到延迟的具体原因,再针对性地从上游数据库、Flink集群、Flink CDC配置、下游系统多个维度进行调优。

监控的时候,可以先用Flink的内置指标快速了解整体的延迟情况,再根据需要自定义埋点,获取更精准的延迟数据。调优的时候,一定要先分析延迟的原因,再选择合适的调优方法,避免盲目调优。

同时,调优的时候要考虑业务的实际需求,不要追求极致的延迟,要平衡延迟和资源成本。最后,调优后的配置一定要经过充分的测试,确保不会对其他业务造成影响,再上线使用。