Flink-CDC-PostgreSQL 之 自定义检查点

在Spring Boot集成Flink CDC监听PostgreSQL数据变更时，若需自定义检查点存储到PostgreSQL数据库（而非默认的HDFS/RocksDB），并实现检查点的恢复机制，需通过Flink的StateBackend和CheckpointStorage接口扩展。以下是完整实现方案：

---

一、核心思路

1. 检查点存储：

   • 自定义CheckpointStorage，将检查点元数据（如状态快照、偏移量）序列化后存入PostgreSQL。
   • 使用PostgreSQL的BLOB或BYTEA类型存储序列化的状态数据。

2. 检查点恢复：

   • 在任务启动时，从PostgreSQL读取最新的检查点数据并恢复状态。
   • 需处理Flink CDC的偏移量（如LSN）与自定义状态的关联。

---

二、实现步骤

1. 创建PostgreSQL检查点表

在PostgreSQL中创建表，用于存储检查点元数据和状态：

CREATE TABLE flink_checkpoints (
    checkpoint_id BIGINT PRIMARY KEY,
    task_name VARCHAR(255) NOT NULL,
    state_data BYTEA NOT NULL,  -- 存储序列化的状态
    create_time TIMESTAMP DEFAULT NOW(),
    UNIQUE (task_name, checkpoint_id)
);

2. 自定义PostgreSQL CheckpointStorage

实现Flink的CheckpointStorage接口，将检查点写入PostgreSQL：

import org.apache.flink.core.fs.CheckpointStorage;
import org.apache.flink.core.fs.Path;
import org.apache.flink.runtime.state.CheckpointStorageLocation;
import org.apache.flink.runtime.state.CheckpointStorageLocationReference;
import org.apache.flink.runtime.state.filesystem.FsCheckpointStorageAccess;

import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class PostgresCheckpointStorage implements CheckpointStorage {
    private final JdbcTemplate jdbcTemplate;
    private final String taskName;

    public PostgresCheckpointStorage(JdbcTemplate jdbcTemplate, String taskName) {
        this.jdbcTemplate = jdbcTemplate;
        this.taskName = taskName;
    }

    @Override
    public CheckpointStorageLocation initializeLocationForCheckpoint(long checkpointId) throws IOException {
        return new PostgresCheckpointStorageLocation(checkpointId, taskName, jdbcTemplate);
    }

    @Override
    public CheckpointStorageLocation resolveCheckpointStorageLocation(long checkpointId, String externalPointer) {
        return new PostgresCheckpointStorageLocation(checkpointId, taskName, jdbcTemplate);
    }

    @Override
    public boolean supportsHighlyAvailableStorage() {
        return true;
    }

    @Override
    public Path getDefaultCheckpointPath() {
        return new Path("postgres://checkpoints/" + taskName);
    }
}

class PostgresCheckpointStorageLocation implements CheckpointStorageLocation {
    private final long checkpointId;
    private final String taskName;
    private final JdbcTemplate jdbcTemplate;

    public PostgresCheckpointStorageLocation(long checkpointId, String taskName, JdbcTemplate jdbcTemplate) {
        this.checkpointId = checkpointId;
        this.taskName = taskName;
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Path getCheckpointPath() {
        return new Path("postgres://checkpoints/" + taskName + "/" + checkpointId);
    }

    @Override
    public FsCheckpointStorageAccess createCheckpointStorageAccess() {
        return new PostgresCheckpointStorageAccess(checkpointId, taskName, jdbcTemplate);
    }
}

class PostgresCheckpointStorageAccess implements FsCheckpointStorageAccess {
    private final long checkpointId;
    private final String taskName;
    private final JdbcTemplate jdbcTemplate;

    public PostgresCheckpointStorageAccess(long checkpointId, String taskName, JdbcTemplate jdbcTemplate) {
        this.checkpointId = checkpointId;
        this.taskName = taskName;
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public void writeCheckpointMetadata(byte[] metadata, int offset, int length) throws IOException {
        // 将检查点元数据写入PostgreSQL
        String sql = "INSERT INTO flink_checkpoints (checkpoint_id, task_name, state_data) VALUES (?, ?, ?) " +
                     "ON CONFLICT (task_name, checkpoint_id) DO UPDATE SET state_data = EXCLUDED.state_data";
        jdbcTemplate.update(sql, checkpointId, taskName, metadata);
    }

    @Override
    public byte[] readCheckpointMetadata(long checkpointId) throws IOException {
        // 从PostgreSQL读取检查点元数据
        String sql = "SELECT state_data FROM flink_checkpoints WHERE task_name = ? AND checkpoint_id = ?";
        return jdbcTemplate.queryForObject(sql, new Object[]{taskName, checkpointId}, byte[].class);
    }
}

3. 配置自定义CheckpointStorage

在Spring Boot中配置Flink使用自定义的PostgresCheckpointStorage：

@Configuration
public class FlinkConfig {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Bean
    public StreamExecutionEnvironment streamExecutionEnvironment() {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        
        // 设置检查点间隔
        env.enableCheckpointing(30000);
        
        // 使用自定义的PostgreSQL CheckpointStorage
        env.setStateBackend(new EmbeddedRocksDBStateBackend());
        env.setCheckpointStorage(new PostgresCheckpointStorage(jdbcTemplate, "flink-cdc-pg-job"));
        
        return env;
    }
}

4. 实现检查点恢复逻辑

在任务启动时，从PostgreSQL读取最新检查点并恢复状态：

@Service
public class FlinkCDCService {
    @Autowired
    private StreamExecutionEnvironment env;
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void startJob() throws Exception {
        // 1. 从PostgreSQL获取最新检查点ID
        Long latestCheckpointId = jdbcTemplate.queryForObject(
            "SELECT MAX(checkpoint_id) FROM flink_checkpoints WHERE task_name = ?",
            Long.class,
            "flink-cdc-pg-job"
        );

        // 2. 配置Flink CDC Source
        PostgresSource<String> source = PostgresSource.<String>builder()
            .hostname("localhost")
            .port(5432)
            .database("your_db")
            .username("flink_user")
            .password("password")
            .schemaList("public")
            .tableList("public.your_table")
            .deserializer(new JsonDebeziumDeserializationSchema())
            .build();

        // 3. 如果存在检查点，从检查点恢复
        if (latestCheckpointId != null) {
            env.getCheckpointConfig().setCheckpointId(latestCheckpointId);
        }

        // 4. 构建并执行任务
        DataStreamSource<String> stream = env.fromSource(
            source,
            WatermarkStrategy.noWatermarks(),
            "Postgres CDC Source"
        );

        stream.print();
        env.execute("Flink CDC PostgreSQL Job with Custom Checkpoint Storage");
    }
}

---

三、关键问题与优化

1. 状态序列化与存储

• 问题：Flink的状态可能很大，直接存入PostgreSQL的BYTEA字段可能影响性能。
• 优化：
  • 对状态数据压缩（如GZIP）。
  • 将大状态拆分到多个表或使用PostgreSQL的Large Object（LO）API。

2. 检查点清理

• 问题：PostgreSQL表可能积累大量旧检查点数据。
• 优化：
  • 定期清理旧检查点（如保留最近5个）：

    DELETE FROM flink_checkpoints 
    WHERE task_name = 'flink-cdc-pg-job' 
    AND checkpoint_id NOT IN (
        SELECT DISTINCT checkpoint_id 
        FROM flink_checkpoints 
        WHERE task_name = 'flink-cdc-pg-job' 
        ORDER BY checkpoint_id DESC 
        LIMIT 5
    );
    

3. 高可用性

• 问题：PostgreSQL单点故障可能导致检查点丢失。
• 优化：
  • 使用PostgreSQL主从复制或Pgpool-II提高可用性。
  • 结合分布式文件系统（如HDFS）存储检查点，PostgreSQL仅存储元数据。

---

四、总结

方案	优点	缺点
自定义PostgreSQL CheckpointStorage	完全控制检查点存储，便于监控	性能可能不如HDFS/RocksDB
结合HDFS/RocksDB + PostgreSQL元数据	平衡性能与可管理性	实现复杂度较高

推荐方案：

• 如果检查点数据量较小，可直接用PostgreSQL存储。
• 如果数据量较大，建议用RocksDB存储状态 + PostgreSQL存储元数据（如偏移量、LSN）。

---

五、完整代码示例

GitHub示例项目（需替换为实际仓库）
包含：

1. 自定义CheckpointStorage实现。
2. Spring Boot集成Flink CDC。
3. PostgreSQL检查点存储与恢复逻辑。

通过以上方案，可实现Flink CDC检查点存储到PostgreSQL，并支持故障恢复。