Flink_Flink 的容错

1. Checkpoint 介绍

2. 持久化存储

目前，Checkpoint 持久化存储可以使用如下三种:

2.1 MemStateBackend（默认）

2.2 FsStateBackend（建议使用）

2.3 RocksDBStateBackend

2.4 语法

val env = StreamExecutionEnvironment.getExecutionEnvironment() 
// start a checkpoint every 1000 ms 
env.enableCheckpointing(1000) 
// advanced options: 
// 设置 checkpoint 的执行模式，最多执行一次或者至少执行一次 
env.getCheckpointConfig.setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE) 
// 设置 checkpoint 的超时时间 
env.getCheckpointConfig.setCheckpointTimeout(60000) 
// 如果在只做快照过程中出现错误，是否让整体任务失败：true 是 false 不是 
env.getCheckpointConfig.setFailTasksOnCheckpointingErrors(false) 
//设置同一时间有多少 个 checkpoint 可以同时执行 
env.getCheckpointConfig.setMaxConcurrentCheckpoints(1)

2.5 修改 State Backend 的两种方式

• 第一种：单任务调整

//修改当前任务代码
env.setStateBackend(new FsStateBackend("hdfs://node01:8020/flink/checkpoints")); 
或者 new MemoryStateBackend() 
或者 new RocksDBStateBackend(filebackend, true);
【需要添加第三方依赖】

• 第二种：全局调整

//修改 flink-conf.yaml 
state.backend: filesystem 
state.checkpoints.dir: hdfs://namenode:9000/flink/checkpoints 
//注 意 ： state.backend 的 值 可 以 是 下 面 几 种 ： 
jobmanager(MemoryStateBackend), 
filesystem(FsStateBackend), 
rocksdb(RocksDBStateBackend)

导入依赖

<dependency> 
<groupId>org.apache.flink</groupId> 
<artifactId>flink-statebackend-rocksdb_2.11</artifactId> 
<version>1.7.2</version> 
</dependency>

3 Checkpoint 的高级选项

4 Flink 的重启策略

4.1 固定延迟重启策略(Fixed Delay Restart Strategy)

固定延迟重启策略会尝试一个给定的次数来重启 Job， 如果超过了最大的重启次数，
Job 最终将失败。 在连续的两次重启尝试之间， 重启策略会等待一个固定的时间。

4.2 失败率重启策略

失败率重启策略在 Job 失败后会重启， 但是超过失败率后， Job 会最终被认定失败。 在两个连续的重启尝 试之间， 重启策略会等待一个固定的时间。 失败率重启策略可以在 flink-conf.yaml 中设置下面的配置参数来启用:

restart-strategy:failure-rate

第一种： 全局配置 flink-conf.yaml

restart-strategy: failure-rate 
restart-strategy.failure-rate.max-failures-per-interval: 3 
restart-strategy.failure-rate.failure-rate-interval: 5 min 
restart-strategy.failure-rate.delay: 10 s

第二种： 应用代码设置

val env = ExecutionEnvironment.getExecutionEnvironment() 
env.setRestartStrategy(RestartStrategies.failureRateRestart( 3, 
// 每个测量时间间隔最大失败次数 
Time.of(5, TimeUnit.MINUTES), 
//失败率测量的时间间隔 
Time.of(10, TimeUnit.SECONDS) 
// 两次连续重启尝试的时间间隔
))

4.3 无重启策略

Job 直接失败，不会尝试进行重启

第一种： 全局配置 flink-conf.yaml

restart-strategy: none

第二种： 应用代码设置

ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment(); 

env.setRestartStrategy(RestartStrategies.noRestart());

代码示例：

package com.czxy.flink.stream.checkpoint

import java.util.concurrent.TimeUnit

import org.apache.flink.api.common.restartstrategy.RestartStrategies
import org.apache.flink.runtime.state.filesystem.FsStateBackend
import org.apache.flink.streaming.api.environment.CheckpointConfig.ExternalizedCheckpointCleanup
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.api.scala._
//单词统计测试checkpoint
object StreamCheckpointDemo {
  /**
   * 单词统计测试checkpoint
   * 执行步骤：
   * 1.创建执行环境
   * 2.开启checkpoint,并设置周期时间， 每5秒钟做一次checkpoint
   * 3.制定快照保存的方式， 默认是内存， 建议不使用,这里设置为磁盘文件的方式或者是hdfs中
   * 4.如果程序被 cancel， 保留以前做的 checkpoint
   * 5.程序出现异常是会重启， 重启五次， 每次延迟 5 秒， 如果超过了 5 次， 程序退出
   * 6.构建数据源
   * 7.数据处理
   * 8.打印输出
   * 9.执行任务
   */

  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    
    //2.开启checkpoint,并设置周期时间
    env.enableCheckpointing(5000)
    
    //3.制定快照保存的方式， 默认是内存， 建议不使用,这里设置为磁盘文件的方式或者是hdfs中
    env.setStateBackend(new FsStateBackend(args(0)))
    
    //4.如果程序被 cancel， 保留以前做的 checkpoint
    env.getCheckpointConfig.enableExternalizedCheckpoints(ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION)
    
    //5.程序出现异常是会重启， 重启五次， 每次延迟 5 秒， 如果超过了 5 次， 程序退出
    env.setRestartStrategy(RestartStrategies.fixedDelayRestart(5, 5000))
    
    //6.构建数据源
    val socketSource: DataStream[String] = env.socketTextStream(args(1), args(2).toInt)
    
    //7.数据处理
    val groupStream: KeyedStream[(String, Int), String] = socketSource
      .flatMap(x => x.split(" "))
      .map(
        x => {
          if (x.equals("laowang")) {
            throw new RuntimeException("老王来了， 重启程序！ ")
          }
          (x, 1)
        }).keyBy(_._1)
    val result: DataStream[(String, Int)] = groupStream.sum(1)

    //8.打印输出
    result.print()
    //9.执行程序
    env.execute("StreamCheckpointDemo")
  }
}