大数据与流处理 / 系统课时

完成有状态容错综合演练

完成有状态容错综合演练

这次演练把状态、TTL、Checkpoint、故障恢复、Savepoint 扩缩容和 Kafka Exactly-Once 串成一条可验证链路。最终你会得到一个按 key 累加的 DataStream 作业,并用故障注入证明状态与输出都能在恢复后保持一致。

学习目标

  • 实现带 ValueState 与 TTL 的 keyed 聚合作业,并开启 Exactly-Once Checkpoint。
  • 注入一次可恢复故障,验证 Checkpoint 回滚与 Kafka Exactly-Once 输出。
  • 从 Savepoint 将并行度从 2 调整到 4,并确认 keyed state 正确重分配。

明确演练链路与验收口径

准备两个全新的 Kafka topic:输入 topic 每行格式为 user,delta,输出 topic 写入 user,sum。作业按 user 分区,用 ValueState<Long> 保存累计值;TTL 设为 2 分钟,便于在实验环境观察过期;当某个 key 的累计值首次达到 100 时,算子在第一次执行尝试中主动抛异常。

故障恢复后,Kafka Source 从最近一次成功 Checkpoint 的 offset 继续,状态也从同一 Checkpoint 恢复。Kafka Sink 使用事务提交并设置 EXACTLY_ONCE,因此使用 read_committed 读取时,不应看到故障前未提交事务造成的重复记录。

综合演练中的状态、Checkpoint 与 Savepoint 路径

验收时不要只看 Job 状态为 RUNNING,而要检查四个结果:故障后累计值延续而不是从零开始;输出 topic 在 read_committed 下没有重复提交;TTL 到期后的 key 会从空状态重新累计;Savepoint 恢复到并行度 4 后历史 key 仍保持原值。

实现带 TTL 和故障注入的作业

下面是完整主示例。它要求工程已经加入 Flink DataStream 与 Kafka Connector 依赖;checkpointDir 必须是所有 TaskManager 都能访问的持久化 URI。生产环境通常使用对象存储或分布式文件系统,本地单机实验可以使用 file:///...。

java
package com.example;

import java.time.Duration;

import org.apache.flink.api.common.functions.OpenContext;
import org.apache.flink.api.common.restartstrategy.RestartStrategies;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.api.common.state.StateTtlConfig;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.connector.base.DeliveryGuarantee;
import org.apache.flink.connector.kafka.sink.KafkaRecordSerializationSchema;
import org.apache.flink.connector.kafka.sink.KafkaSink;
import org.apache.flink.connector.kafka.source.KafkaSource;
import org.apache.flink.connector.kafka.source.enumerator.initializer.OffsetsInitializer;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class StatefulFaultToleranceJob {

    public static void main(String[] args) throws Exception {
        if (args.length != 4) {
            throw new IllegalArgumentException(
                    "args: <bootstrapServers> <inputTopic> <outputTopic> <checkpointDir>");
        }

        String bootstrapServers = args[0];
        String inputTopic = args[1];
        String outputTopic = args[2];
        String checkpointDir = args[3];

        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.enableCheckpointing(10_000, CheckpointingMode.EXACTLY_ONCE);
        env.getCheckpointConfig().setCheckpointStorage(checkpointDir);
        env.setRestartStrategy(RestartStrategies.fixedDelayRestart(3, 1_000L));

        KafkaSource<String> source = KafkaSource.<String>builder()
                .setBootstrapServers(bootstrapServers)
                .setTopics(inputTopic)
                .setGroupId("state-ft-lab")
                .setStartingOffsets(OffsetsInitializer.earliest())
                .setValueOnlyDeserializer(new SimpleStringSchema())
                .build();

        KafkaSink<String> sink = KafkaSink.<String>builder()
                .setBootstrapServers(bootstrapServers)
                .setRecordSerializer(
                        KafkaRecordSerializationSchema.builder()
                                .setTopic(outputTopic)
                                .setValueSerializationSchema(new SimpleStringSchema())
                                .build())
                .setDeliveryGuarantee(DeliveryGuarantee.EXACTLY_ONCE)
                .setTransactionalIdPrefix("state-ft-lab-")
                .build();

        SingleOutputStreamOperator<Tuple2<String, Long>> parsed = env
                .fromSource(source,
                        org.apache.flink.api.common.eventtime.WatermarkStrategy.noWatermarks(),
                        "kafka-source")
                .uid("kafka-source-v1")
                .map(line -> {
                    String[] parts = line.split(",", 2);
                    return Tuple2.of(parts[0], Long.parseLong(parts[1]));
                })
                .returns(org.apache.flink.api.common.typeinfo.Types.TUPLE(
                        org.apache.flink.api.common.typeinfo.Types.STRING,
                        org.apache.flink.api.common.typeinfo.Types.LONG))
                .name("parse");

        parsed
                .keyBy(value -> value.f0)
                .process(new SumWithTtlAndOneFailure())
                .name("sum-with-ttl")
                .uid("sum-with-ttl-v1")
                .setMaxParallelism(128)
                .sinkTo(sink)
                .name("kafka-exactly-once-sink")
                .uid("kafka-exactly-once-sink-v1");

        env.execute("state-fault-tolerance-lab");
    }

    static final class SumWithTtlAndOneFailure
            extends KeyedProcessFunction<String, Tuple2<String, Long>, String> {

        private transient ValueState<Long> sum;

        @Override
        public void open(OpenContext openContext) throws Exception {
            StateTtlConfig ttl = StateTtlConfig
                    .newBuilder(Duration.ofMinutes(2))
                    .setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite)
                    .setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired)
                    .build();

            ValueStateDescriptor<Long> descriptor =
                    new ValueStateDescriptor<>("sum", Long.class);
            descriptor.enableTimeToLive(ttl);
            sum = getRuntimeContext().getState(descriptor);
        }

        @Override
        public void processElement(
                Tuple2<String, Long> value,
                Context context,
                Collector<String> out) throws Exception {

            Long previous = sum.value();
            long next = (previous == null ? 0L : previous) + value.f1;
            sum.update(next);

            // 只在第一次执行尝试中注入故障,避免重启后再次进入失败循环。
            if (getRuntimeContext().getTaskInfo().getAttemptNumber() == 0
                    && next >= 100L) {
                throw new RuntimeException("injected failure");
            }

            out.collect(value.f0 + "," + next);
        }
    }
}

这段程序的关键不在异常本身,而在三个稳定边界:聚合算子的 UID 固定为 sum-with-ttl-v1;其 maxParallelism 固定为 128,为后续并行度调整保留 key-group 空间;Kafka Sink 使用事务语义,提交结果与 Checkpoint 对齐。

运行并验证故障恢复

先以并行度 2 提交作业,再发送三条输入。将 <PATH> 替换为本机实际目录;Checkpoint 路径应提前创建并具备写权限。

bash
FLINK_HOME="<PATH>"
KAFKA_HOME="<PATH>"
JOB_JAR="<PATH>/state-ft-lab.jar"
CHECKPOINT_URI="file:///tmp/flink-state-ft-checkpoints"

"$FLINK_HOME/bin/flink" run -d -p 2 -c com.example.StatefulFaultToleranceJob "$JOB_JAR" localhost:9092 input-state-ft output-state-ft "$CHECKPOINT_URI"
printf 'alice,40\nalice,30\n' | "$KAFKA_HOME/bin/kafka-console-producer.sh" --bootstrap-server localhost:9092 --topic input-state-ft
sleep 15
printf 'alice,50\n' | "$KAFKA_HOME/bin/kafka-console-producer.sh" --bootstrap-server localhost:9092 --topic input-state-ft

预期输出

text
Job has been submitted with JobID <ID>

示例中的 15 秒用于给 10 秒 Checkpoint 周期留出完成时间;环境较慢时应以实际出现至少一个成功 Checkpoint 为准。第三条记录把 alice 的累计值推到 120,会在第一次 attempt 中触发异常。Flink 重启后应从最近一次成功 Checkpoint 恢复;等待新的 Checkpoint 完成后,用只读已提交事务的消费者检查输出。

bash
KAFKA_HOME="<PATH>"

"$KAFKA_HOME/bin/kafka-console-consumer.sh" --bootstrap-server localhost:9092 --topic output-state-ft --from-beginning --isolation-level read_committed --timeout-ms 20000

预期结果

text
alice,40
alice,70
alice,120

若测试 topic 是全新的,以上三条结果应各出现一次。若看到重复记录,先确认消费者是否使用 read_committed,再检查 Sink 是否仍为 EXACTLY_ONCE、事务 ID 前缀是否与其他并发作业冲突,以及 Checkpoint 是否持续成功。

用 Savepoint 完成扩缩容

在作业稳定运行后先触发 Savepoint。命令完成时会返回真实路径,把它保存为后续恢复使用的 <SAVEPOINT_PATH>。

bash
FLINK_HOME="<PATH>"
JOB_ID="<ID>"
SAVEPOINT_DIR="<PATH>"

"$FLINK_HOME/bin/flink" savepoint "$JOB_ID" "$SAVEPOINT_DIR"

预期输出

text
Savepoint completed. Path: <SAVEPOINT_PATH>

随后取消旧作业,并从该 Savepoint 以并行度 4 启动。扩缩容期间不要修改 sum-with-ttl-v1 的 UID 或 maxParallelism。

bash
FLINK_HOME="<PATH>"
JOB_ID="<ID>"
JOB_JAR="<PATH>/state-ft-lab.jar"
SAVEPOINT_PATH="<PATH>/savepoint-<ID>"

"$FLINK_HOME/bin/flink" cancel "$JOB_ID"
"$FLINK_HOME/bin/flink" run -d -p 4 -s "$SAVEPOINT_PATH" -c com.example.StatefulFaultToleranceJob "$JOB_JAR" localhost:9092 input-state-ft output-state-ft file:///tmp/flink-state-ft-checkpoints

预期结果

text
旧作业进入 CANCELED。
新作业提交成功,JobID 为 <ID>。

恢复后继续向 alice 和其他 key 写入数据。如果 alice 在 TTL 到期前继续写入,新的累计值应接着 120 增长;如果超过 2 分钟没有写入导致状态过期,下一条 alice 事件会从空状态重新累计。至此,Checkpoint 负责故障恢复,Savepoint 负责受控迁移,稳定 UID 与 max parallelism 负责状态映射,而 Kafka 事务 Sink 负责把端到端 Exactly-Once 落到可观察结果上。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

完成有状态容错综合演练

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通