一、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的延迟监控和调优,主要用在对数据时效性要求高的业务场景,比如:
- 实时报表:比如电商的实时销售报表,需要实时统计每一分钟的订单金额、订单量,如果延迟大,报表的数据就会不及时,影响业务决策。
- 实时风控:比如金融行业的实时风控系统,需要实时判断用户的交易是否有风险,如果延迟大,等判断结果出来的时候,用户的交易已经完成了,就起不到风控的作用。
- 实时推荐:比如短视频平台的实时推荐系统,需要根据用户的实时行为(比如点赞、评论)实时调整推荐内容,如果延迟大,推荐的内容就会过时,影响用户体验。
3.2 技术优缺点
3.2.1 优点
- 监控方式灵活:既可以用Flink的内置指标,也可以自定义埋点,满足不同的监控需求。
- 调优维度多:可以从上游数据库、Flink集群、Flink CDC配置、下游系统多个维度调优,总有适合自己业务的调优方法。
- 适配性强:可以同步多种数据库(比如MySQL、PostgreSQL、Oracle等),也可以同步到多种下游系统(比如Kafka、数仓、Redis等)。
3.2.2 缺点
- 调优复杂度高:调优需要对上游数据库、Flink、下游系统都有一定的了解,对新手来说门槛比较高。
- 依赖资源多:延迟调优需要足够的集群资源,如果资源不够,调优的效果会打折扣。
- 没有通用的调优方案:不同的业务场景、不同的集群环境,调优的参数都不一样,没有一个通用的调优方案,需要根据实际情况调整。
3.3 注意事项
- 调优前一定要先监控:不能盲目调优,一定要先监控找到延迟的原因,再针对性地调优。比如如果延迟是因为上游数据库的压力大,那调优Flink的配置是没用的。
- 调优要循序渐进:不要一次性改很多参数,最好是一次改一个参数,观察效果,再决定要不要改回来或者继续调整。
- 要考虑业务的可接受延迟:不是所有的业务都需要零延迟,比如有些业务可以接受1秒的延迟,那调优的时候就不用追求极致的延迟,避免浪费资源。
- 要注意调优对其他业务的影响:比如调整上游数据库的binlog配置,可能会影响其他使用binlog的业务,一定要先测试再上线。
四、文章总结
Flink CDC同步数据的延迟监控和调优,是一个系统性的工作,需要从监控入手,找到延迟的具体原因,再针对性地从上游数据库、Flink集群、Flink CDC配置、下游系统多个维度进行调优。
监控的时候,可以先用Flink的内置指标快速了解整体的延迟情况,再根据需要自定义埋点,获取更精准的延迟数据。调优的时候,一定要先分析延迟的原因,再选择合适的调优方法,避免盲目调优。
同时,调优的时候要考虑业务的实际需求,不要追求极致的延迟,要平衡延迟和资源成本。最后,调优后的配置一定要经过充分的测试,确保不会对其他业务造成影响,再上线使用。
评论
围绕“Flink CDC同步数据时的延迟监控与调优方法总结”参与讨论