Question

我正在写一个案例来测试flink两步提交，下面是概述。

sink kafka曾经是kafka的制作人。 sink step是mysql接收器扩展two step commit。 sink compare是mysql接收器扩展two step commit，该接收器有时会抛出一个异常来模拟检查点失败。

当检查点失败并恢复时，我发现mysql两步提交可以正常工作，但是kafka使用者将读取上次成功的偏移量，kafka生产者即使在此检查点失败之前就已经完成了，也会产生消息 。

在这种情况下如何避免重复消息？

感谢帮助。

环境：

链接1.9.1
java 1.8
kafka 2.11

kafka生产者代码：

        dataStreamReduce.addSink(new FlinkKafkaProducer<>(
                "flink_output",
                new KafkaSerializationSchema<Tuple4<String, String, String, Long>>() {
                    @Override
                    public ProducerRecord<byte[], byte[]> serialize(Tuple4<String, String, String, Long> element, @Nullable Long timestamp) {
                        UUID uuid = UUID.randomUUID();
                        JSONObject jsonObject = new JSONObject();
                        jsonObject.put("uuid", uuid.toString());
                        jsonObject.put("key1", element.f0);
                        jsonObject.put("key2", element.f1);
                        jsonObject.put("key3", element.f2);
                        jsonObject.put("indicate", element.f3);
                        return new ProducerRecord<>("flink_output", jsonObject.toJSONString().getBytes(StandardCharsets.UTF_8));
                    }
                },
                kafkaProps,
                FlinkKafkaProducer.Semantic.EXACTLY_ONCE
        )).name("sink kafka");

检查点设置：

        StreamExecutionEnvironment executionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment();
        executionEnvironment.enableCheckpointing(10000);
        executionEnvironment.getCheckpointConfig().setTolerableCheckpointFailureNumber(0);
        executionEnvironment.getCheckpointConfig().setPreferCheckpointForRecovery(true);

mysql接收器：

dataStreamReduce.addSink(
                new TwoPhaseCommitSinkFunction<Tuple4<String, String, String, Long>,
                        Connection, Void>
                        (new KryoSerializer<>(Connection.class, new ExecutionConfig()), VoidSerializer.INSTANCE) {

                    int count = 0;
                    Connection connection;

                    @Override
                    protected void invoke(Connection transaction, Tuple4<String, String, String, Long> value, Context context) throws Exception {
                        if (count > 10) {
                            throw new Exception("compare test exception.");
                        }
                        PreparedStatement ps = transaction.prepareStatement(
                                " insert into test_two_step_compare(slot_time, key1, key2, key3, indicate) " +
                                        " values(?, ?, ?, ?, ?) " +
                                        " ON DUPLICATE KEY UPDATE indicate = indicate + values(indicate) "
                        );
                        ps.setString(1, context.timestamp().toString());
                        ps.setString(2, value.f0);
                        ps.setString(3, value.f1);
                        ps.setString(4, value.f1);
                        ps.setLong(5, value.f3);
                        ps.execute();
                        ps.close();
                        count += 1;
                    }

                    @Override
                    protected Connection beginTransaction() throws Exception {
                        LOGGER.error("compare in begin transaction");
                        try {
                            if (connection.isClosed()) {
                                throw new Exception("mysql connection closed");
                            }
                        }catch (Exception e) {
                            LOGGER.error("mysql connection is error: " + e.toString());
                            LOGGER.error("reconnect mysql connection");
                            String jdbcURI = "jdbc:mysql://";
                            Class.forName("com.mysql.jdbc.Driver");
                            Connection connection = DriverManager.getConnection(jdbcURI);
                            connection.setAutoCommit(false);
                            this.connection = connection;
                        }
                        return this.connection;
                    }

                    @Override
                    protected void preCommit(Connection transaction) throws Exception {
                        LOGGER.error("compare in pre Commit");
                    }

                    @Override
                    protected void commit(Connection transaction) {
                        LOGGER.error("compare in commit");
                        try {
                            transaction.commit();
                        } catch (Exception e) {
                            LOGGER.error("compare Commit error: " + e.toString());
                        }
                    }

                    @Override
                    protected void abort(Connection transaction) {
                        LOGGER.error("compare in abort");
                        try {
                            transaction.rollback();
                        } catch (Exception e) {
                            LOGGER.error("compare abort error." + e.toString());
                        }
                    }

                    @Override
                    protected void recoverAndCommit(Connection transaction) {
                        super.recoverAndCommit(transaction);
                        LOGGER.error("compare in recover And Commit");
                    }

                    @Override
                    protected void recoverAndAbort(Connection transaction) {
                        super.recoverAndAbort(transaction);
                        LOGGER.error("compare in recover And Abort");
                    }
                })
                .setParallelism(1).name("sink compare");

Answer 1

我不太确定我是否正确理解了这个问题：

当检查点失败并恢复时，我发现mysql两步提交可以正常工作，但是kafka生产者将读取上次成功的偏移量，并产生消息，即使他在此检查点失败之前完成了操作。

Kafka生产者未读取任何数据。因此，我假设您的整个管道会重新读取旧的偏移量并产生重复项。如果是这样，您需要了解Flink如何确保准确地执行一次。

创建定期检查点以在发生故障的情况下具有一致的状态。
这些检查点包含检查点时最后一次成功读取的记录的偏移量。
恢复时，Flink将从存储在最后一个成功检查点中的偏移量中重新读取所有记录。因此，将重播在最后一个检查点与故障之间生成的相同记录。
重播的记录将在故障发生之前立即恢复状态。
它将产生来自重复输入记录的重复输出。
接收器的责任是确保没有重复项被有效地写入目标系统。

最后一点，有两个选择：

仅在写入检查点后才输出数据，从而使目标中永远不会出现有效的重复项。这种幼稚的方法非常普遍（与接收器无关），但是会增加检查点间隔到延迟中。
让接收器对输出进行重复数据删除。

后一个选项用于Kafka接收器。它使用Kafka事务进行重复数据删除。为了避免在用户端出现重复，您需要确保它没有读取uncommitted data as mentioned in the documentation。另外，还要确保事务超时足够大，以免在故障和恢复之间不会丢弃数据。

在检查点还原时，flink kafkaproducer以完全一次的模式发送重复消息

1 个答案: