AI 助理
文档备案控制台
开发者社区 大数据 文章 正文

Flink相关API开发及运行架构和实现原理详解

2023-02-10 764
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Flink相关API开发及运行架构和实现原理详解

一、Flink相关API说明

flinkAPI官网：Apache Flink 1.12 Documentation: Flink DataStream API Programming Guide


Flink提供了多个层次的API供开发者使用，越往上抽象程度越高，使用起来越方便；越往下越底层，使用起来难度越大



注意：我自己使用的是flink 1.7.2版本，但是在Flink1.12时支持流批一体，DataSetAPI已经不推荐使用了，大家最好优先使用DataStream流式API，既支持无界数据处理/流处理，也支持有界数据处理/批处理！



二、Flink运行架构

1、flink的编程模型

Flink程序主要包含三部分：Source/Transformation/Sink（源/转换操作/输出）




2、创建工程，maven依赖准备

properties

    <properties>
        <encoding>UTF-8</encoding>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <java.version>1.8</java.version>
        <!-- Flink的架构中使用了 Akka 来实现底层的分布式通信，而 Akka 是用 Scala 开发的。我们用到的 Scala 版本为 2.12。-->
        <scala.version>2.12</scala.version>
        <flink.version>1.12.0</flink.version>
    </properties>

 

dependencies


build

 <sourceDirectory>src/main/java</sourceDirectory>
        <plugins>
            <!-- 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <!--<encoding>${project.build.sourceEncoding}</encoding>-->
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <useFile>false</useFile>
                    <disableXmlReport>true</disableXmlReport>
                    <includes>
                        <include>**/*Test.*</include>
                        <include>**/*Suite.*</include>
                    </includes>
                </configuration>
            </plugin>
            <!-- 打包插件(会包含所有依赖) -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <!--
                                        zip -d learn_spark.jar META-INF/*.RSA META-INF/*.DSA META-INF/*.SF -->
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <!-- 设置jar包的入口类(可选) -->
                                     <mainClass>com.tjcu.TestDataStreamYarn</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>

3、需求

4、编码步骤

编码步骤参考官网：https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/datastream_api.html



1.准备环境-env
2.准备数据-source
3.处理数据-transformation
4.输出结果-sink
5.触发执行-execute

其中创建环境参考官网：


getExecutionEnvironment() //推荐使用
createLocalEnvironment()
createRemoteEnvironment(String host, int port, String... jarFiles)

5、代码实现

（1）DataSet(了解)

package com.tjcu;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.AggregateOperator;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.operators.FlatMapOperator;
import org.apache.flink.api.java.operators.UnsortedGrouping;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;
/**
 * @author ：王恒杰
 * @date ：Created in 2022/4/20 15:37
 * @description：使用Flink完成WordCount-DataSet
 * 编码步骤
 *  1.准备环境-env
 *  2.准备数据-source
 *  3.处理数据-transformation
 *  4.输出结果-sink
 *  5.触发执行-execute//如果有print,DataSet不需要调用execute,DataStream需要调用execute
 */
public class TestDataSet {
    public static void main(String[] args) throws Exception {
     //老版本的API如下，目前不推荐使用了
        //1.准备环境 env
        ExecutionEnvironment executionEnvironment = ExecutionEnvironment.getExecutionEnvironment();
        //2.准备数据-source
        DataSource<String> stringDataSource = executionEnvironment.fromElements("whj hadoop spark", "whj hadoop spark", "whj hadoop spark");
        //3.处理数据-transformation
        //3.1每一行数据按照空格切分成一个个的单词组成一个集合
        FlatMapOperator<String, String> wordsDS = stringDataSource.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                //value就是一行行的数据
                String[] words = value.split(" ");
                for (String word : words) {
                    out.collect(word);//将切割处理的一个个的单词收集起来并返回
                }
            }
        });
        DataSet<Tuple2<String, Integer>> wordAndOne = wordsDS.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                //value就是每一个单词
                return Tuple2.of(value, 1);
            }
        });
        //分组
        UnsortedGrouping<Tuple2<String, Integer>> grouped = wordAndOne.groupBy(0);
        //聚合
        AggregateOperator<Tuple2<String, Integer>> result = grouped.sum(1);
        //输出结果-sink
        result.print();
    }
}



（2）基于DataStream（匿名内部类-处理流）

package com.tjcu;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.operators.FlatMapOperator;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;;
/**
 * @author ：王恒杰
 * @date ：Created in 2022/4/20 16:07
 * @description：需求:使用Flink完成WordCount-DataStream 批处理
 *  * 编码步骤
 *  * 1.准备环境-env
 *  * 2.准备数据-source
 *  * 3.处理数据-transformation
 *  * 4.输出结果-sink
 *  * 5.触发执行-execute//如果有print,DataSet不需要调用execute,DataStream需要调用execute
 */
public class TestDataStream {
    public static void main(String[] args) throws Exception {
        //新版本的流批统一API,既支持流处理也支持批处理
        //1.准备环境 env
        StreamExecutionEnvironment executionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment();
//         executionEnvironment.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
        executionEnvironment.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
        //executionEnvironment.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批
        //2.准备数据-source
        DataStreamSource<String> stringDataStreamSource = executionEnvironment.fromElements("whj hadoop spark", "whj spark", "whj");
        //3.处理数据-transformation
        //3.1每一行数据按照空格切分成一个个的单词组成一个集合
        DataStream<String> words = stringDataStreamSource.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                //value就是每一行数据
                String[] arr = value.split(" ");
                for (String word : arr) {
                    out.collect(word);
                }
            }
        });
        DataStream<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                //value就是一个个单词
                return Tuple2.of(value, 1);
            }
        });
        //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
        KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
        //聚合
        SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
        //TODO 3.sink
        result.print();
        //启动并等待程序结束
        executionEnvironment.execute();
    }
}



注意:在Flink1.12中DataStream既支持流处理也支持批处理,如何区分?


env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批

（3）代码实现-DataStream-Lambda

package com.tjcu;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;;import java.util.Arrays;
/**
 * @author ：王恒杰
 * @date ：Created in 2022/4/20 16:07
 * @description：需求:使用Flink完成WordCount-DataStream 批处理
 *  * 编码步骤
 *  * 1.准备环境-env
 *  * 2.准备数据-source
 *  * 3.处理数据-transformation
 *  * 4.输出结果-sink
 *  * 5.触发执行-execute//如果有print,DataSet不需要调用execute,DataStream需要调用execute
 */
public class TestDataStream {
    public static void main(String[] args) throws Exception {
        //新版本的流批统一API,既支持流处理也支持批处理
        //1.准备环境 env
        StreamExecutionEnvironment executionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment();
//         executionEnvironment.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
        executionEnvironment.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
        //executionEnvironment.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批
        //2.准备数据-source
        DataStreamSource<String> stringDataStreamSource = executionEnvironment.fromElements("whj hadoop spark", "whj spark", "whj");
        //3.处理数据-transformation
        //3.1每一行数据按照空格切分成一个个的单词组成一个集合
        SingleOutputStreamOperator<String> words = stringDataStreamSource.flatMap(
                (String value, Collector<String> out) -> Arrays.stream(value.split(" ")).forEach(out::collect)
        ).returns(Types.STRING);
        DataStream<Tuple2<String, Integer>> wordAndOne = words.map(
                (String value) -> Tuple2.of(value, 1)
        ).returns(Types.TUPLE(Types.STRING,Types.INT));
        //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
        KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);
        //聚合
        SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);
        //TODO 3.sink
        result.print();
        //启动并等待程序结束
        executionEnvironment.execute();
    }
}



（4）On-Yarn-掌握


  • 注意：写入HDFS如果存在权限问题，进行如下设置:
hadoop fs -chmod -R 777  /

并在代码中添加:

System.setProperty("HADOOP_USER_NAME", "root")

代码实现：


package com.tjcu;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;
import java.util.Arrays;
/**
 * @author ：王恒杰
 * @date ：Created in 2022/4/20 16:28
 * @description：使用Flink完成WordCount-DataStream--使用lambda表达式--修改代码使适合在Yarn上运行 编码步骤
 * * 1.准备环境-env
 * * 2.准备数据-source
 * * 3.处理数据-transformation
 * * 4.输出结果-sink
 * * 5.触发执行-execute//批处理不需要调用!流处理需要
 */
public class TestDataStreamYarn {
    public static void main(String[] args) throws Exception {
        //获取参数
        ParameterTool params = ParameterTool.fromArgs(args);
        String output = null;
        if (params.has("output")) {
            output = params.get("output");
        } else {
            output = "hdfs://node1:8020/wordcount/output_" + System.currentTimeMillis();
        }
        //1.准备环境-env
        StreamExecutionEnvironment executionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment();
        executionEnvironment.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);
        //2.准备数据源-source
        DataStream<String> linesDS = executionEnvironment.fromElements("whj hadoop spark", "whj hadoop spark", "whj hadoop", "whj");
        //3.处理数据-transformation
        DataStream<Tuple2<String, Integer>> result = linesDS
                .flatMap(
                        (String value, Collector<String> out) -> Arrays.stream(value.split(" ")).forEach(out::collect)
                ).returns(Types.STRING)
                .map(
                        (String value) -> Tuple2.of(value, 1)
                ).returns(Types.TUPLE(Types.STRING, Types.INT))
                //.keyBy(0);
                .keyBy((KeySelector<Tuple2<String, Integer>, String>) t -> t.f0)
                .sum(1);
        //4.输出结果-sink
        result.print();
        //如果执行报hdfs权限相关错误,可以执行 hadoop fs -chmod -R 777  /
        System.setProperty("HADOOP_USER_NAME", "root");//设置用户名
        //result.writeAsText("hdfs://node1:8020/wordcount/output_"+System.currentTimeMillis()).setParallelism(1);
        result.writeAsText(output).setParallelism(1);
        //5.触发执行-execute
        executionEnvironment.execute();
    }
}

打包




上传



提交执行


/usr/apps/flink/bin/flink run -Dexecution.runtime-mode=BATCH -m yarn-cluster -yjm 1024 -ytm 1024 
 /usr/apps/words.jar --output hdfs://node1:8020/wordcount/output_xx


在Web页面可以观察到提交的程序：


http://node1:8088/cluster或者http://node1:50070/explorer.html#/



输出结果：http://192.168.43.129:50070/explorer.html#/wordcount



三、Flink原理

1、Flink角色分工

在实际生产中，Flink 都是以集群在运行，在运行的过程中包含了两类进程。


#1. JobManager
   他扮演的是集群管理者的角色，负责调度任务，协调checkpoints、协调故障恢复、
   收集 Job 的状态信息，并管理 Flink 集群中的从节点 TaskManager。
#2.TaskManager
   实际负责执行计算的 Worker，在其上执行 Flink Job 的一组 Task；
   TaskManager 还是所在节点的管理员，
   它负责把该节点上的服务器信息比如内存、磁盘、任务运行情况等向 JobManager 汇报。
#3.Client：
用户在提交编写好的 Flink 工程时，会先创建一个客户端再进行提交，这个客户端就是 Client

上面个案例的运行就是从节点执行的



角色分工



2、Flink执行流程


用户首先提交Flink程序到JobClient，经过JobClient的处理、解析、优化提交到JobManager，最后由TaskManager运行task。



（1）Standalone版本



（2）On Yarn版本实现原理



1. Client向HDFS上传Flink的Jar包和配置
2. Client向Yarn ResourceManager提交任务并申请资源
3. ResourceManager分配Container资源并启动ApplicationMaster,
  然后AppMaster加载Flink的Jar包和配置构建环境,启动JobManager
4. ApplicationMaster向ResourceManager申请工作资源,
  NodeManager加载Flink的Jar包和配置构建环境并启动TaskManager
5. TaskManager启动后向JobManager发送心跳包，并等待JobManager向其分配任务

3、Flink Streaming Dataflow


（1）Dataflow、Operator、Partition、SubTask、Parallelism


1. Dataflow:Flink程序在执行的时候会被映射成一个数据流模型
2. Operator:数据流模型中的每一个操作被称作Operator,Operator分为:Source/Transform/Sink
          准备数据-Source
          处理数据-Transformation
          输出结果-Sink
3. Partition:数据流模型是分布式的和并行的,执行中会形成1~n个分区
4. Subtask:多个分区任务可以并行,每一个都是独立运行在一个线程中的,也就是一个Subtask子任务
5. Parallelism:并行度,就是可以同时真正执行的子任务数/分区数


（2) Operator传递模式


数据在两个operator(算子)之间传递的时候有两种模式：


One to One模式：


两个operator用此模式传递的时候，会保持数据的分区数和数据的排序；如上图中的Source1到Map1，它就保留的Source的分区特性，以及分区元素处理的有序性。--类似于Spark中的窄依赖


Redistributing 模式：


这种模式会改变数据的分区数；每个一个operator subtask会根据选择transformation把数据发送到不同的目标subtasks,比如keyBy()会通过hashcode重新分区,broadcast()和rebalance()方法会随机重新分区。--类似于Spark中的宽依赖


（3）Operator Chain（算子链）


客户端在提交任务的时候会对Operator进行优化操作，能进行合并的Operator会被合并为一个Operator，合并后的Operator称为Operator chain，实际上就是一个执行链，每个执行链会在TaskManager上一个独立的线程中执行--就是SubTask。



（4）TaskSlot（任务槽） And Slot Sharing（槽共享）


任务槽（TaskSlot）


每个TaskManager是一个JVM的进程, 为了控制一个TaskManager(worker)能接收多少个task，Flink通过Task Slot来进行控制。TaskSlot数量是用来限制一个TaskManager工作进程中可以同时运行多少个工作线程，TaskSlot 是一个 TaskManager 中的最小资源分配单位，一个 TaskManager 中有多少个 TaskSlot 就意味着能支持多少并发的Task处理。


Flink将进程的内存进行了划分到多个slot中，内存被划分到不同的slot之后可以获得如下好处:


1.  TaskManager最多能同时并发执行的子任务数是可以通过TaskSolt数量来控制的
2.  TaskSolt有独占的内存空间，这样在一个TaskManager中可以运行多个不同的作业，作业之间不受影响。



槽共享（Slot Sharing）



Flink允许子任务共享插槽，即使它们是不同任务(阶段)的子任务(subTask)，只要它们来自同一个作业。比如图左下角中的map和keyBy和sink 在一个 TaskSlot 里执行以达到资源共享的目的。


允许插槽共享有两个主要好处：

1. 1. 资源分配更加公平，如果有比较空闲的slot可以将更多的任务分配给它。
2. 2. 有了任务槽共享，可以提高资源的利用率。

注意:


slot是静态的概念，是指taskmanager具有的并发执行能力


parallelism(平行)是动态的概念，是指程序运行时实际使用的并发能力


（5）运行时组件


Flink运行时架构主要包括四个不同的组件，它们会在运行流处理应用程序时协同工作：


作业资源管理器（JobManager）: 分配任务、调度checkpoint做快照


任务管理器（TaskManager）：主要干活的


资源管理器（ResourceManager）：管理分配资源


分发器（Dispatcher）：方便递交任务的接口，WebUI


因为Flink是用Java和Scala实现的，所以所有组件都会运行在Java虚拟机上。每个组件的职责如下：


作业管理器（JobManager）


1. 控制一个应用程序执行的主进程，也就是说，每个应用程序都会被一个不同的JobManager 所控制执行。
2. JobManager 会先接收到要执行的应用程序，这个应用程序会包括：
   作业图（JobGraph）、逻辑数据流图（logical dataflow graph）和打包了所有的类、库和其它资源的JAR包。
3. JobManager 会把JobGraph转换成一个物理层面的数据流图，这个图被叫做“执行图”（ExecutionGraph），
    包含了所有可以并发执行的任务。
4. JobManager 会向资源管理器（ResourceManager）请求执行任务必要的资源，
  也就是任务管理器（TaskManager）上的插槽（slot）。
  一旦它获取到了足够的资源，就会将执行图分发到真正运行它们的TaskManager上。
  而在运行过程中，JobManager会负责所有需要中央协调的操作，比如说检查点（checkpoints）的协调。

任务管理器（TaskManager）


1. Flink中的工作进程。通常在Flink中会有多个TaskManager运行，
   每一个TaskManager都包含了一定数量的插槽（slots）。插槽的数量限制了TaskManager能够执行的任务数量。
2. 启动之后，TaskManager会向资源管理器注册它的插槽；收到资源管理器的指令后，
   TaskManager就会将一个或者多个插槽提供给JobManager调用。JobManager就可以向插槽分配任务（tasks）来执行了。
3. 在执行过程中，一个TaskManager可以跟其它运行同一应用程序的TaskManager交换数据。

资源管理器（ResourceManager）


1. 主要负责管理任务管理器（TaskManager）的插槽（slot），TaskManger 插槽是Flink中定义的处理资源单元。
2. Flink为不同的环境和资源管理工具提供了不同资源管理器，比如YARN、Mesos、K8s，以及standalone部署。
3. 当JobManager申请插槽资源时，ResourceManager会将有空闲插槽的TaskManager分配给JobManager。
  如果ResourceManager没有足够的插槽来满足JobManager的请求，
  它还可以向资源提供平台发起会话，以提供启动TaskManager进程的容器。

分发器（Dispatcher）

1. 可以跨作业运行，它为应用提交提供了REST接口。
2. 当一个应用被提交执行时，分发器就会启动并将应用移交给一个JobManager。
3. Dispatcher也会启动一个Web UI，用来方便地展示和监控作业执行的信息。
4. Dispatcher在架构中可能并不是必需的，这取决于应用提交运行的方式。

(6)Flink执行图（ExecutionGraph）


由Flink程序直接映射成的数据流图是StreamGraph，也被称为逻辑流图，因为它们表示的是计算逻辑的高级视图。为了执行一个流处理程序，Flink需要将逻辑流图转换为物理数据流图（也叫执行图），详细说明程序的执行方式。


Flink 中的执行图可以分成四层：StreamGraph(逻辑流图) -> JobGraph -> ExecutionGraph -> 物理执行图。

1. StreamGraph：是根据用户通过 Stream API 编写的代码生成的最初的图。用来表示程序的拓扑 [tuò pū] 结构。
2. JobGraph：StreamGraph经过优化后生成了 JobGraph，提交给 JobManager 的数据结构。
             主要的优化为，将多个符合条件的节点 chain 在一起作为一个节点，这样可以减少数据在节点之间流动所需要的序列化/反序列化/传输消耗。
3. ExecutionGraph：JobManager 根据 JobGraph 生成ExecutionGraph。方便调度和监控和跟踪各个 tasks 的状态。
                    ExecutionGraph是JobGraph的并行化版本，是调度层最核心的数据结构。
4. 物理执行图：JobManager 根据 ExecutionGraph 对 Job 进行调度后，
             在各个TaskManager 上部署 Task 后形成的“图”，并不是一个具体的数据结构。

Flink执行executor会自动根据程序代码生成DAG数据流图


简单理解：


1. StreamGraph：最初的程序执行逻辑流程，也就是算子之间的前后顺序--在Client上生成
2. JobGraph：将OneToOne的Operator合并为OperatorChain--在Client上生成
3. ExecutionGraph：将JobGraph根据代码中设置的并行度和请求的资源进行并行化规划!--在JobManager上生成
4. 物理执行图：将ExecutionGraph的并行计划,落实到具体的TaskManager上，将具体的SubTask落实到具体的TaskSlot内进行运行。


文章标签：
实时计算 Flink版
资源管理
Java
数据处理
流计算
分布式计算
Spark
Apache
Maven
Scala
API
调度
相关实践学习
基于Hologres+Flink搭建GitHub实时数据大屏
通过使用Flink、Hologres构建实时数仓，并通过Hologres对接BI分析工具（以DataV为例），实现海量数据实时分析.
实时计算 Flink 实战课程
如何使用实时计算 Flink 搞定数据处理难题？实时计算 Flink 极客训练营产品、技术专家齐上阵，从开源 Flink功能介绍到实时计算 Flink 优势详解，现场实操，5天即可上手！ 欢迎开通实时计算 Flink 版： https://cn.aliyun.com/product/bigdata/sc Flink Forward Asia 介绍： Flink Forward 是由 Apache 官方授权，Apache Flink Community China 支持的会议，通过参会不仅可以了解到 Flink 社区的最新动态和发展计划，还可以了解到国内外一线大厂围绕 Flink 生态的生产实践经验，是 Flink 开发者和使用者不可错过的盛会。 去年经过品牌升级后的 Flink Forward Asia 吸引了超过2000人线下参与，一举成为国内最大的 Apache 顶级项目会议。结合2020年的特殊情况，Flink Forward Asia 2020 将在12月26日以线上峰会的形式与大家见面。
4yva5hg3m356w
目录
相关文章
一个幽默的程序员
|
人工智能 API 数据安全/隐私保护
Apifox 与 Apipost 的 API 文档引擎对比：底层架构、性能与可扩展性分析
深入探索市场上两大主流API工具——Apifox和Apipost的文档能力时，发现了令人惊讶的差距。这不仅仅是功能多寡的问题，更关乎开发效率与团队协作的质变。
一个幽默的程序员
422 1
程序员一鸣
|
缓存 JavaScript IDE
鸿蒙开发：基于最新API，如何实现组件化运行
手动只是让大家了解切换的原理，在实际开发中，可不推荐手动，下篇文章，我们将通过脚本或者插件，快速实现组件化模块之间的切换，实现独立运行，敬请期待！
程序员一鸣
359 0
鸿蒙开发：基于最新API，如何实现组件化运行
游客h2p5himj2xcrw
|
安全 测试技术 API
电商API接口开发：基础架构搭建全攻略
本文详细解析了电商API接口从零搭建基础架构的全流程。首先通过需求分析明确业务功能与接口规范，选定数据格式（如JSON）及通信方式（如RESTful）。接着在架构设计阶段选择合适的技术栈、数据库方案，并引入API网关实现统一管理。开发实现部分涵盖认证授权、数据访问、日志记录与异常处理等核心功能。安全防护则强调数据加密、传输安全及速率限制策略。测试优化阶段包括单元测试、集成测试、性能与安全测试，确保接口稳定性。最后通过工具生成清晰的API文档并实施版本控制，为开发者提供便利。整体流程系统化、模块化，助力打造高效、安全的电商API接口。
游客h2p5himj2xcrw
687 0
安全风信子
|
存储 监控 安全
132_API部署：FastAPI与现代安全架构深度解析与LLM服务化最佳实践
在大语言模型(LLM)部署的最后一公里，API接口的设计与安全性直接决定了模型服务的可用性、稳定性与用户信任度。随着2025年LLM应用的爆炸式增长，如何构建高性能、高安全性的REST API成为开发者面临的核心挑战。FastAPI作为Python生态中最受青睐的Web框架之一，凭借其卓越的性能、强大的类型安全支持和完善的文档生成能力，已成为LLM服务化部署的首选方案。
安全风信子
1528 3
winx_19970108018
|
JSON 供应链 监控
1688商品详情API技术深度解析：从接口架构到数据融合实战
1688商品详情API（item_get接口）可通过商品ID获取标题、价格、库存、SKU等核心数据，适用于价格监控、供应链管理等场景。支持JSON格式返回，需企业认证。Python示例展示如何调用接口获取商品信息。
winx_19970108018
548 6
SOFAStack社区-棠棠
|
SQL 运维 Java
蚂蚁 Flink 实时计算编译任务 Koupleless 架构改造
本文介绍了对Flink实时计算编译任务的Koupleless架构改造。为解决进程模型带来的响应慢、资源消耗大等问题，团队将进程模型改为线程模型，并借助Koupleless的类加载隔离能力实现版本和包的隔离。通过动态装配Plugin及其Classpath，以及Biz运行时仅对依赖Plugin可见的设计，大幅优化了编译任务的性能。结果表明，新架构使编译耗时降低50%，吞吐量提升5倍以上。
SOFAStack社区-棠棠
654 11
蚂蚁 Flink 实时计算编译任务 Koupleless 架构改造
大熊计算机
|
机器学习/深度学习 运维 监控
实时异常检测实战：Flink+PAI 算法模型服务化架构设计
本文深入探讨了基于 Apache Flink 与阿里云 PAI 构建的实时异常检测系统。内容涵盖技术演进、架构设计、核心模块实现及金融、工业等多领域实战案例，解析流处理、模型服务化、状态管理等关键技术，并提供性能优化与高可用方案，助力企业打造高效智能的实时异常检测平台。
大熊计算机
1324 1
灵杰开发者
|
SQL 消息中间件 Kafka
Flink+Paimon+Hologres，面向未来的一体化实时湖仓平台架构设计
本文介绍了阿里云实时数仓Hologres负责人姜伟华在Flink Forward Asia 2024上的分享，涵盖实时数仓的发展历程、从实时数仓到实时湖仓的演进，以及总结。文章通过三代实时数仓架构的演变，详细解析了Lambda架构、Kafka实时数仓分层+OLAP、Hologres实时数仓分层复用等方案，并探讨了未来从实时数仓到实时湖仓的演进方向。最后，结合实际案例和Demo展示了Hologres + Flink + Paimon在实时湖仓中的应用，帮助用户根据业务需求选择合适的方案。
灵杰开发者
2219 20
Flink+Paimon+Hologres，面向未来的一体化实时湖仓平台架构设计
api-v-2467742810
|
缓存 监控 API
电商API的微服务架构优化策略
随着电商快速发展，API成为连接用户、商家与系统的核心。本文探讨微服务架构下电商API的优化策略，分析高并发、低延迟与数据一致性等挑战，并提供服务拆分、缓存异步、监控容器化等实践方案，助力构建高性能、高可用的电商系统，提升用户体验与业务效率。
api-v-2467742810
344 0
百岁001
|
关系型数据库 MySQL 数据库
基于Flink CDC 开发，支持Web-UI的实时KingBase 连接器，三大模式无缝切换，效率翻倍！
TIS 是一款基于Web-UI的开源大数据集成工具，通过与人大金仓Kingbase的深度整合，提供高效、灵活的实时数据集成方案。它支持增量数据监听和实时写入，兼容MySQL、PostgreSQL和Oracle模式，无需编写复杂脚本，操作简单直观，特别适合非专业开发人员使用。TIS率先实现了Kingbase CDC连接器的整合，成为业界首个开箱即用的Kingbase CDC数据同步解决方案，助力企业数字化转型。
百岁001
3509 5
基于Flink CDC 开发，支持Web-UI的实时KingBase 连接器，三大模式无缝切换，效率翻倍！

热门文章

最新文章

  • 1
    API网关为K8S容器应用集群提供强大的接入能力
  • 2
    ​邮箱OTP认证验证API发送邮件接口
  • 3
    ArcGIS API for Silverlight 加载google地图
  • 4
    海外http代理中的api代理是什么意思？使用方法有哪些？
  • 5
    国外地区经纬度查询免费API接口教程
  • 6
    使用commons-io-2.0 API来实现监听文件变化
  • 7
    基于 API 网关践行 API First 开发实践
  • 8
    如何利用电商API接口打造个性化购物体验
  • 9
    Netflix试图通过开发者自治调和大规模API
  • 10
    文件I/O实践(1) --基础API
  • 1
    实时计算 Flink 全新升级 - 全栈流处理平台助力实时智能
    867
  • 2
    云栖实录｜实时计算 Flink 全新升级 - 全栈流处理平台助力实时智能
    741
  • 3
    Flink Agents 0.1.0 发布公告
    924
  • 4
    阿里云、Ververica、Confluent 与 LinkedIn 携手推进流式创新，共筑基于 Apache Flink Agents 的智能体 AI 未来
    1701
  • 5
    零售数据湖的进化之路：滔搏从Lambda架构到阿里云Flink+Paimon统一架构的实战实践
    790
  • 6
    Flink基于Paimon的实时湖仓解决方案的演进
    1429
  • 7
    构建高效的实时数据管道：Flink、Kafka、CnosDB 的完美结合
    668
  • 8
    Flink Agents：基于Apache Flink的事件驱动AI智能体框架
    3778
  • 9
    淘宝闪购基于Flink&Paimon的Lakehouse生产实践：从实时数仓到湖仓一体化的演进之路
    1971
  • 10
    从嵌入式状态管理到云原生架构：Apache Flink 的演进与下一代增量计算范式
    821

    • 相关课程

    更多
  • Apache Flink 入门到实战 - Flink开源社区出品
  • MySQL企业常见架构与调优经验分享
  • 企业Web常用架构LAMP-LNMP实战
  • 企业级互联网分布式系统应用架构学习
  • 实时计算 Flink 版产品入门与实操
  • 高校精品课-上海交通大学 -企业级应用体系架构

    • 相关电子书

    更多
  • 云栖大会：开源 PolarDB 架构演进、关键技术与社区建设
  • 从技术到架构，云原生全面加速应用现代化
  • MaxCompute架构升级及开放性解读
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！