flink学习及案例实战

集群模型和角色

• JobManager：它扮演的是集群管理者的角色，负责调度任务、协调 checkpoints、协调故障恢复、收集 Job 的状态信息，并管理 Flink 集群中的从节点
• TaskManager。 TaskManager：实际负责执行计算的 Worker，在其上执行 Flink Job 的一组 Task；TaskManager 还是所在节点的管理员，它负责把该节点上的服务器信息比如内存、磁盘、任务运行情况等向 JobManager 汇报。
• Client：用户在提交编写好的 Flink 工程时，会先创建一个客户端再进行提交，这个客户端就是 Client，Client 会根据用户传入的参数选择使用 yarn per job 模式、stand-alone 模式还是 yarn-session 模式将 Flink 程序提交到集群。

资源和资源组

在 Flink 集群中，一个 TaskManger 就是一个 JVM 进程，并且会用独立的线程来执行 task，为了控制一个 TaskManger 能接受多少个 task，Flink 提出了 Task Slot 的概念。

假如一个 TaskManager 拥有 5 个 slot，那么该 TaskManager 的计算资源会被平均分为 5 份，不同的 task 在不同的 slot 中执行，避免资源竞争。需要注意的是，slot 仅仅用来做内存的隔离，对 CPU 不起作用。那么运行在同一个 JVM 的 task 可以共享 TCP 连接，减少网络传输，在一定程度上提高了程序的运行效率，降低了资源消耗。

分布式缓存

目的是为了在分布式环境中让每一个 TaskManager 节点保存一份相同的数据或者文件，当前计算节点的 task 就像读取本地文件一样拉取这些配置。

步骤：
第一步：首先需要在 env 环境中注册一个文件，该文件可以来源于本地，也可以来源于 HDFS ，并且为该文件取一个名字。
第二步：在使用分布式缓存时，可根据注册的名字直接获取。

注意事项：

1. 缓存文件在运行期间最好是只读状态，保证数据的一致性；
2. 缓存的内容不宜过大，否则会影响 task 的执行效率，严重的情况下还会造成 OOM 。

public static void main(String[] args) throws Exception {

final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

   env.registerCachedFile("/Users/wangzhiwu/WorkSpace/quickstart/distributedcache.txt", "distributedCache");

       //1：注册一个文件,可以使用hdfs上的文件 也可以是本地文件进行测试

       DataSource<String> data = env.fromElements("Linea", "Lineb", "Linec", "Lined");



       DataSet<String> result = data.map(new RichMapFunction<String, String>() {

           private ArrayList<String> dataList = new ArrayList<String>();



           @Override

           public void open(Configuration parameters) throws Exception {

               super.open(parameters);

               //2：使用该缓存文件

               File myFile = getRuntimeContext().getDistributedCache().getFile("distributedCache");

               List<String> lines = FileUtils.readLines(myFile);

               for (String line : lines) {

                   this.dataList.add(line);

                   System.err.println("分布式缓存为:" + line);

               }

           }



           @Override

           public String map(String value) throws Exception {

               //在这里就可以使用dataList

               System.err.println("使用datalist：" + dataList + "-------" +value);

               //业务逻辑

               return dataList +"：" +  value;

           }

       });



       result.printToErr();

   }

故障恢复和重启策略

故障恢复

有 full 和 region 两种，配置项是 jobmanager.execution.failover-strategy 。

full

当我们配置的故障恢复策略为 full 时，集群中的 Task 发生故障，那么该任务的所有 Task 都会发生重启。

region

集群中某一个或几个 Task 发生了故障，只需要重启有问题的一部分即可。
Flink 在判断需要重启的 Region 时，采用了以下的判断逻辑：

1. 发生错误的 Task 所在的 Region 需要重启；
2. 如果当前 Region 的依赖数据出现损坏或者部分丢失，那么生产数据的
   Region 也需要重启；
3. 为了保证数据一致性，当前 Region 的下游 Region 也需要重启。

重启策略

1. 固定延迟重启策略模式；
2. 失败率重启策略模式；
3. 无重启策略模式。

Exactly-once

在 Flink 中两阶段提交的实现方法被封装到了 TwoPhaseCommitSinkFunction 这个抽象类中，我们只需要实现其中的beginTransaction、preCommit、commit、abort 四个方法就可以实现“精确一次”的处理语义，实现的方式我们可以在官网中查到：

beginTransaction，在开启事务之前，我们在目标文件系统的临时目录中创建一个临时文件，后面在处理数据时将数据写入此文件；

preCommit，在预提交阶段，刷写（flush）文件，然后关闭文件，之后就不能写入到文件了，我们还将为属于下一个检查点的任何后续写入启动新事务；

commit，在提交阶段，我们将预提交的文件原子性移动到真正的目标目录中，请注意，这会增加输出数据可见性的延迟；

abort，在中止阶段，我们删除临时文件。

过程

整个过程可以总结为下面四个阶段：
一旦 Flink 开始做 checkpoint 操作，那么就会进入 pre-commit 阶段，同时 Flink JobManager 会将检查点 Barrier 注入数据流中 ；
当所有的 barrier 在算子中成功进行一遍传递，并完成快照后，则 pre-commit 阶段完成；
等所有的算子完成“预提交”，就会发起一个“提交”动作，但是任何一个“预提交”失败都会导致 Flink 回滚到最近的 checkpoint；
pre-commit 完成，必须要确保 commit 也要成功，上图中的 Sink Operators 和 Kafka Sink 会共同来保证。

窗口和时间

窗口

• 滚动窗口，窗口数据有固定的大小，窗口中的数据不会叠加；
• 滑动窗口，窗口数据有固定的大小，并且有生成间隔；
• 会话窗口，窗口数据没有固定的大小，根据用户传入的参数进行划分，窗口数据无叠加。

时间

• 事件时间（Event Time），即事件实际发生的时间；
• 摄入时间（Ingestion Time），事件进入流处理框架的时间；
• 处理时间（Processing Time），事件被处理的时间。

    //设置时间属性为 EventTime
    final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
    
    //设置时间属性为 ProcessingTime
    env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);

反压问题

Flink 的反压设计利用了网络传输和动态限流。Flink 任务的组成由基本的“流”和“算子”构成，那么“流”中的数据在“算子”间进行计算和转换时，会被放入分布式的阻塞队列中。当消费者的阻塞队列满时，则会降低生产者的数据生产速度。

反压指标

outPoolUsage：发送端缓冲池的使用率

inPoolUsage：接收端缓冲池的使用率

floatingBuffersUsage：处理节点缓冲池的使用率

exclusiveBuffersUsage：数据输入方缓冲池的使用率

反压处理

数据倾斜

数据倾斜问题是我们生产环境中出现频率最多的影响任务运行的因素，可以在 Flink 的后台管理页面看到每个 Task 处理数据的大小。当数据倾斜出现时，通常是简单地使用类似 KeyBy 等分组聚合函数导致的，需要用户将热点 Key 进行预处理，降低或者消除热点 Key 的影响。

GC

垃圾回收问题也是造成反压的因素之一。不合理的设置 TaskManager 的垃圾回收参数会导致严重的 GC 问题，我们可以通过 -XX:+PrintGCDetails 参数查看 GC 的日志。

代码本身

开发者错误地使用 Flink 算子，没有深入了解算子的实现机制导致性能问题。我们可以通过查看运行机器节点的 CPU 和内存情况定位问题。

数据倾斜

原因

1. 业务上有严重的数据热点，比如滴滴打车的订单数据中北京、上海等几个城市的订单量远远超过其他地区；
2. 技术上大量使用了 KeyBy、GroupBy 等操作，错误的使用了分组 Key，人为产生数据热点。

两阶段聚合解决 KeyBy 热点

解决方案

1. 首先把分组的 key 打散，比如加随机后缀；
2. 对打散后的数据进行聚合；
3. 把打散的 key 还原为真正的 key；
4. 二次 KeyBy 进行结果统计，然后输出。

    DataStream sourceStream = ...;
    resultStream = sourceStream
         .map(record -> {
            Record record = JSON.parseObject(record, Record.class);
            String type = record.getType();
            record.setType(type + "#" + new Random().nextInt(100));
            return record;
          })
          .keyBy(0)
          .window(TumblingEventTimeWindows.of(Time.minutes(1)))
          .aggregate(new CountAggregate())
          .map(count -> {
            String key = count.getKey.substring(0, count.getKey.indexOf("#"));
            return RecordCount(key,count.getCount);
          })
          //二次聚合
          .keyBy(0)
          .process(new CountProcessFunction);
    
    resultStream.sink()...
    env.execute()...

GroupBy + Aggregation 分组聚合热点问题

解决方案

// 原本的代码
select
      date,
      type,
      sum(count) as pv
from table
      group by
      date,
      type;

// 改进后的代码
// 在上面的 SQL 拆成了内外两层，第一层通过随机打散 100 份的方式减少数据热点
select date,
       type,
       sum(pv) as pv
from(
  select
        date,
        type,
        sum(count) as pv
  from table
        group by
        date,
        type,
        floor(rand()*100) --随机打散成100份 
    )
    group by 
    date,
    type;

Flink 消费 Kafka 上下游并行度不一致导致的数据倾斜

解决方案

dataStream
    .setParallelism(2)
    // 采用REBALANCE分区策略重分区
    .rebalance() //.rescale()
    .print()
    .setParallelism(4);

Flink 维表关联

实时查询维表

public class Order {

    private Integer cityId;
    private String userName;
    private String items;

    public Integer getCityId() {
        return cityId;
    }

    public void setCityId(Integer cityId) {
        this.cityId = cityId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getItems() {
        return items;
    }

    public void setItems(String items) {
        this.items = items;
    }

    @Override
    public String toString() {
        return "Order{" +
                "cityId=" + cityId +
                ", userName='" + userName + '\'' +
                ", items='" + items + '\'' +
                '}';
    }
}

public class DimSync extends RichMapFunction<String,Order> {

    private static final Logger LOGGER = LoggerFactory.getLogger(DimSync.class);
    private Connection conn = null;

    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/dim?characterEncoding=UTF-8", "admin", "admin");
    }

    public Order map(String in) throws Exception {

        JSONObject jsonObject = JSONObject.parseObject(in);
        Integer cityId = jsonObject.getInteger("city_id");
        String userName = jsonObject.getString("user_name");
        String items = jsonObject.getString("items");

        //根据city_id 查询 city_name
        PreparedStatement pst = conn.prepareStatement("select city_name from info where city_id = ?");
        pst.setInt(1,cityId);
        ResultSet resultSet = pst.executeQuery();
        String cityName = null;

        while (resultSet.next()){
            cityName = resultSet.getString(1);
        }
        pst.close();
        return new Order(cityId,userName,items,cityName);
    }

    public void close() throws Exception {
        super.close();
        conn.close();
    }
}

预加载全量数据

public class WholeLoad extends RichMapFunction<String,Order> {

    private static final Logger LOGGER = LoggerFactory.getLogger(WholeLoad.class);
    ScheduledExecutorService executor = null;
    private Map<String,String> cache;

    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
        executor.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                try {
                    load();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },5,5, TimeUnit.MINUTES);
    }

    @Override
    public Order map(String value) throws Exception {
        JSONObject jsonObject = JSONObject.parseObject(value);
        Integer cityId = jsonObject.getInteger("city_id");
        String userName = jsonObject.getString("user_name");
        String items = jsonObject.getString("items");
        String cityName = cache.get(cityId);
        return new Order(cityId,userName,items,cityName);
    }

    public void load() throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/dim?characterEncoding=UTF-8", "admin", "admin");
        PreparedStatement statement = con.prepareStatement("select city_id,city_name from info");
        ResultSet rs = statement.executeQuery();

        while (rs.next()) {
            String cityId = rs.getString("city_id");
            String cityName = rs.getString("city_name");
            cache.put(cityId, cityName);
        }
        con.close();
    }
}

LRU 缓存

<!-- 添加依赖 -->
<dependency>
    <groupId>org.hbase</groupId>
    <artifactId>asynchbase</artifactId>
    <version>1.8.2</version>
</dependency>


public class LRU extends RichAsyncFunction<String,Order> {

    private static final Logger LOGGER = LoggerFactory.getLogger(LRU.class);
    String table = "info";
    Cache<String, String> cache = null;
    private HBaseClient client = null;

    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);

        //创建hbase客户端
        client = new HBaseClient("127.0.0.1","7071");
        cache = CacheBuilder.newBuilder()
                //最多存储10000条
                .maximumSize(10000)
                //过期时间为1分钟
                .expireAfterWrite(60, TimeUnit.SECONDS)
                .build();
    }

    @Override
    public void asyncInvoke(String input, ResultFuture<Order> resultFuture) throws Exception {
        JSONObject jsonObject = JSONObject.parseObject(input);
        Integer cityId = jsonObject.getInteger("city_id");
        String userName = jsonObject.getString("user_name");
        String items = jsonObject.getString("items");

        //读缓存
        String cacheCityName = cache.getIfPresent(cityId);

        //如果缓存获取失败再从hbase获取维度数据
        if(cacheCityName != null){
            Order order = new Order();
            order.setCityId(cityId);
            order.setItems(items);
            order.setUserName(userName);
            order.setCityName(cacheCityName);
            resultFuture.complete(Collections.singleton(order));
        }else {
            client.get(new GetRequest(table,String.valueOf(cityId))).addCallback((Callback<String, ArrayList<KeyValue>>) arg -> {
                for (KeyValue kv : arg) {
                    String value = new St