大数据技术之Flink

MoSpade
239 阅读17分钟

image.png

第一章 Flink简介

初识Flink

Flink起源于Stratosphere项目，Stratosphere是在2010~2014年由3所地处柏林的大学和欧洲的一些其他的大学共同进行的研究项目，2014年4月Stratosphere的代码被复制并捐赠给了Apache软件基金会，参加这个孵化项目的初始成员是Stratosphere系统的核心开发人员，2014年12月，Flink一跃成为Apache软件基金会的顶级项目。

在德语中，Flink一词表示快速和灵巧，项目采用一只松鼠的彩色图案作为logo，这不仅是因为松鼠具有快速和灵巧的特点，还因为柏林的松鼠有一种迷人的红棕色，而Flink的松鼠logo拥有可爱的尾巴，尾巴的颜色与Apache软件基金会的logo颜色相呼应，也就是说，这是一只Apache风格的松鼠。

image.png

Flink项目的理念是：“Apache Flink是为分布式、高性能、随时可用以及准确的流处理应用程序打造的开源的有状态的流处理框架”。

Apache Flink是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。Flink被设计在所有常见的集群环境中运行，以内存执行速度和任意规模来执行计算。

image.png

Flink的重要特点

事件驱动型(Event-driven)

事件驱动型应用是一类具有状态的应用，它从一个或多个事件流提取数据，并根据到来的事件触发计算、状态更新或其他外部动作。比较典型的就是以kafka为代表的消息队列几乎都是事件驱动型应用。(Flink的计算也是事件驱动型)

  • 与之不同的就是SparkStreaming微批次，如图:

image.png

  • 事件驱动型：

image.png

流与批的世界观

批处理的特点是有界、大量，非常适合需要访问全套记录才能完成的计算工作，一般用于离线统计。

流处理的特点是无界、实时, 无需针对整个数据集执行操作，而是对通过系统传输的每个数据项执行操作，一般用于实时统计。

在spark的世界观中，一切都是由批次组成的，离线数据是一个大批次，而实时数据是由一个一个无限的小批次组成的。

而在flink的世界观中，一切都是由流组成的，离线数据是有界限的流，实时数据是一个没有界限的流，这就是所谓的有界流和无界流。

无界数据流：

无界数据流有一个开始但是没有结束，它们不会在生成时终止并提供数据，必须连续处理无界流，也就是说必须在获取后立即处理event。对于无界数据流我们无法等待所有数据都到达，因为输入是无界的，并且在任何时间点都不会完成。处理无界数据通常要求以特定顺序（例如事件发生的顺序）获取event，以便能够推断结果完整性。

有界数据流：

有界数据流有明确定义的 开始和结束，可以在执行任何计算之前通过获取所有数据来处理有界流，处理有界流不需要有序获取，因为可以始终对有界数据集进行排序，有界流的处理也称为批处理。

image.png

分层API

image.png

最底层级的抽象仅仅提供了有状态流，它将通过过程函数（Process Function）被嵌入到DataStream API中。底层过程函数（Process Function） 与 DataStream API 相集成，使其可以对某些特定的操作进行底层的抽象，它允许用户可以自由地处理来自一个或多个数据流的事件，并使用一致的容错的状态。除此之外，用户可以注册事件时间并处理时间回调，从而使程序可以处理复杂的计算。

实际上，大多数应用并不需要上述的底层抽象，而是针对核心API（Core APIs） 进行编程，比如DataStream API（有界或无界流数据）以及DataSet API（有界数据集）。这些API为数据处理提供了通用的构建模块，比如由用户定义的多种形式的转换（transformations），连接（joins），聚合（aggregations），窗口操作（windows）等等。DataSet API 为有界数据集提供了额外的支持，例如循环与迭代。这些API处理的数据类型以类（classes）的形式由各自的编程语言所表示。

Table API 是以表为中心的声明式编程，其中表可能会动态变化（在表达流数据时）。Table API遵循（扩展的）关系模型：表有二维数据结构（schema）（类似于关系数据库中的表），同时API提供可比较的操作，例如select、project、join、group-by、aggregate等。Table API程序声明式地定义了什么逻辑操作应该执行，而不是准确地确定这些操作代码的看上去如何。

尽管Table API可以通过多种类型的用户自定义函数（UDF）进行扩展，其仍不如核心API更具表达能力，但是使用起来却更加简洁（代码量更少）。除此之外，Table API程序在执行之前会经过内置优化器进行优化。

你可以在表与 DataStream/DataSet 之间无缝切换，以允许程序将 Table API 与 DataStream 以及 DataSet 混合使用。

Flink提供的最高层级的抽象是 SQL 。这一层抽象在语法与表达能力上与 Table API 类似，但是是以SQL查询表达式的形式表现程序。SQL抽象与Table API交互密切，同时SQL查询可以直接在Table API定义的表上执行。

目前Flink作为批处理还不是主流，不如Spark成熟，所以DataSet使用的并不是很多。Flink Table API和Flink SQL也并不完善，大多都由各大厂商自己定制。所以我们主要学习DataStream API的使用。实际上Flink作为最接近Google DataFlow模型的实现，是流批统一的观点，所以基本上使用DataStream就可以了。

2020年12月8日发布的最新版本1.12.0, 已经完成实现了真正的流批一体. 写好的一套代码, 即可以处理流式数据, 也可以处理离线数据. 这个与前面版本的处理有界流的方式是不一样的, Flink专门对批处理数据做了优化处理.

Spark or Flink

Spark 和 Flink 一开始都拥有着同一个梦想，他们都希望能够用同一个技术把流处理和批处理统一起来，但他们走了完全不一样的两条路前者是以批处理的技术为根本，并尝试在批处理之上支持流计算；后者则认为流计算技术是最基本的，在流计算的基础之上支持批处理。正因为这种架构上的不同，今后二者在能做的事情上会有一些细微的区别。比如在低延迟场景，Spark 基于微批处理的方式需要同步会有额外开销，因此无法在延迟上做到极致。在大数据处理的低延迟场景，Flink 已经有非常大的优势。

Spark和Flink的主要差别就在于计算模型不同。Spark采用了微批处理模型，而Flink采用了基于操作符的连续流模型。因此，对Apache Spark和Apache Flink的选择实际上变成了计算模型的选择，而这种选择需要在延迟、吞吐量和可靠性等多个方面进行权衡。

如果企业中非要技术选型从Spark和Flink这两个主流框架中选择一个来进行流数据处理，我们推荐使用Flink， 主（显而）要（易见）的原因为：

  • Flink灵活的窗口
  • Exactly Once语义保证

这两个原因可以大大的解放程序员, 加快编程效率, 把本来需要程序员花大力气手动完成的工作交给框架完成

image.png

第二章 Flink快速上手

创建maven项目

  • POM文件中添加需要的依赖:
<properties>
    <flink.version>1.13.0</flink.version>
    <java.version>1.8</java.version>
    <scala.binary.version>2.12</scala.binary.version>
    <slf4j.version>1.7.30</slf4j.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-runtime-web_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-to-slf4j</artifactId>
        <version>2.14.0</version>
    </dependency>
</dependencies>

<!--打包插件-->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
  • src/main/resources添加文件:log4j.properties
log4j.rootLogger=error, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

批处理WordCount

创建input文件夹，并在input文件夹下创建words.txt文件内容如下：

hello freedom
hello flink
hello java
hello shanxi
nihao flink

创建类用来批处理word.txt文件做wordcount

// 1. 创建执行环境
ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
// 2. 从文件读取数据  按行读取(存储的元素就是每行的文本)
DataSource<String> lineDS = env.readTextFile("input/words.txt");
// 3. 转换数据格式
FlatMapOperator<String, Tuple2<String, Long>> wordAndOne = lineDS
        .flatMap((String line, Collector<Tuple2<String, Long>> out) -> {
            String[] split = line.split(" ");
            for (String word : split) {
                out.collect(Tuple2.of(word, 1L));
            }
        })
        .returns(Types.TUPLE(Types.STRING, Types.LONG));  //当Lambda表达式使用 java 泛型的时候, 由于泛型擦除的存在, 需要显示的声明类型信息

// 4. 按照 word 进行分组
UnsortedGrouping<Tuple2<String, Long>> wordAndOneUG = wordAndOne.groupBy(0);
// 5. 分组内聚合统计
AggregateOperator<Tuple2<String, Long>> sum = wordAndOneUG.sum(1);

// 6. 打印结果
sum.print();

注:如果使用lambda表达式，可能因为 类型擦除 报错 解决： returns（Types.类型）

流处理WordCount

有界流

// 1. 创建流式执行环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 2. 读取文件
DataStreamSource<String> lineDSS = env.readTextFile("input/words.txt");
// 3. 转换数据格式
SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = lineDSS
        .flatMap((String line, Collector<String> words) -> {
            Arrays.stream(line.split(" ")).forEach(words::collect);
        })
        .returns(Types.STRING)
        .map(word -> Tuple2.of(word, 1L))
        .returns(Types.TUPLE(Types.STRING, Types.LONG));
// 4. 分组
KeyedStream<Tuple2<String, Long>, String> wordAndOneKS = wordAndOne
        .keyBy(t -> t.f0);
// 5. 求和
SingleOutputStreamOperator<Tuple2<String, Long>> result = wordAndOneKS
        .sum(1);
// 6. 打印
result.print();
// 7. 执行
env.execute();

与批处理的区别：

  1. 执行环境的类不一样
  2. 分组使用的算子不一样：groupby、keyby
  3. 流处理需要启动 env.execute()

无界流

// 1. 创建流式执行环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 2. 读取文件
DataStreamSource<String> lineDSS = env.socketTextStream("hadoop102", 9999);
// 3. 转换数据格式
SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = lineDSS
        .flatMap((String line, Collector<String> words) -> {
            Arrays.stream(line.split(" ")).forEach(words::collect);
        })
        .returns(Types.STRING)
        .map(word -> Tuple2.of(word, 1L))
        .returns(Types.TUPLE(Types.STRING, Types.LONG));
// 4. 分组
KeyedStream<Tuple2<String, Long>, String> wordAndOneKS = wordAndOne
        .keyBy(t -> t.f0);
// 5. 求和
SingleOutputStreamOperator<Tuple2<String, Long>> result = wordAndOneKS
        .sum(1);
// 6. 打印
result.print();
// 7. 执行
env.execute();

第三章 Flink部署

开发模式

前面在idea中运行Flink程序的方式就是开发模式。

local-cluster模式

Flink中的Local-cluster(本地集群)模式,主要用于测试, 学习。

### local-cluster模式配置

local-cluster模式基本属于零配置。

  1. 上传Flink的安装包flink-1.13.1-bin-scala_2.12.tgz到hadoop102

  2. 解压

    tar -zxvf flink-1.13.1-bin-scala_2.12.tgz -C /opt/module

  3. 进入目录/opt/module, 复制flink-local

    cd /opt/module

cp -r flink-1.13.1 flink-local

在local-cluster模式下运行无界的WordCount

  1. 打包idea中的应用

  2. 把不带依赖的jar包上传到目录/opt/module/flink-local下

  3. 启动本地集群

    bin/start-cluster.sh

  4. 在hadoop102中启动netcat

    nc -lk 9999

    注意: 如果没有安装netcat需要先安装:

    sudo yum install -y nc

  5. 命令行提交Flink应用

    bin/flink run -m hadoop102:8081 -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

  6. 在浏览器中查看应用执行情况

image.png

  1. 也可以在log日志查看执行结果

    cat flink-mo-taskexecutor-0-hadoop102.out

image.png

  1. 也可以在WEB UI提交应用

image.png

Standalone模式

Standalone模式又叫独立集群模式。

Standalone模式配置

  1. 复制flink-standalone

    cp -r flink-1.13.1 flink-standalone

  2. 修改配置文件:flink-conf.yaml

    jobmanager.rpc.address: hadoop102

  3. 修改配置文件:workers

    hadoop102

hadoop103

hadoop104

  4. 分发flink-standalone到其他节点

Standalone模式运行无界流WorkCount

  1. 启动standalone集群

    bin/start-cluster.sh

  2. 命令行提交Flink应用

    bin/flink run -m hadoop102:8081 -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

  3. 查看执行情况和本地集群一致.

  4. 也支持Web UI界面提交Flink应用

Standalone高可用(HA)

任何时候都有一个 主 JobManager 和多个备用 JobManagers，以便在主节点失败时有备用 JobManagers 来接管集群。这保证了没有单点故障，一旦备 JobManager 接管集群，作业就可以正常运行。主备 JobManager 实例之间没有明显的区别。每个 JobManager 都可以充当主备节点。

image.png

  1. 修改配置文件: flink-conf.yaml
    high-availability: zookeeper

    high-availability.storageDir: hdfs://hadoop102:8020/flink/standalone/ha

    high-availability.zookeeper.quorum: hadoop102:2181,hadoop103:2181,hadoop104:2181

    high-availability.zookeeper.path.root: /flink-standalone

    high-availability.cluster-id: /cluster_atguigu
  1. 修改配置文件: masters
    hadoop102:8081

    hadoop103:8081

  1. 分发修改的后配置文件到其他节点

  2. 在/etc/profile.d/my.sh中配置环境变量

    export HADOOP_CLASSPATH=`hadoop classpath`

注意:

  • 需要提前保证HAOOP_HOME环境变量配置成功
  • 分发到其他节点

  1. 首先启动hdfs集群和zookeeper集群

  2. 启动standalone HA集群

    bin/start-cluster.sh

  3. 可以分别访问

    http://hadoop102:8081

    http://hadoop103:8081

  1. 在zkCli.sh中查看谁是leader

    启动zk客户端

    zkCli.sh

    get /flink-standalone/cluster_atguigu/leader/rest_server_lock

image.png

  1. 杀死hadoop102上的Jobmanager, 再看leader

image.png

注意: 不管是不是leader从WEB UI上看不到区别, 并且都可以与之提交应用

Yarn模式

独立部署（Standalone）模式由Flink自身提供计算资源，无需其他框架提供资源，这种方式降低了和其他第三方资源框架的耦合性，独立性非常强。但是你也要记住，Flink主要是计算框架，而不是资源调度框架，所以本身提供的资源调度并不是它的强项，所以还是和其他专业的资源调度框架集成更靠谱，所以接下来我们来学习在强大的Yarn环境中Flink是如何使用的。（其实是因为在国内工作中，Yarn使用的非常多）

把Flink应用提交给Yarn的ResourceManager, Yarn的ResourceManager会申请容器从Yarn的NodeManager上面. Flink会创建JobManager和TaskManager在这些容器上.Flink会根据运行在JobManger上的job的需要的slot的数量动态的分配TaskManager资源

Yarn模式配置

  1. 复制flink-yarn

    cp -r flink-1.13.1 flink-yarn

  2. 配置环境变量HADOOP_CLASSPATH, 如果前面已经配置可以忽略。

    在/etc/profile.d/my.sh中配置

    export HADOOP_CLASSPATH=`hadoop classpath`

Yarn运行无界流WordCount

  1. 启动hadoop集群(hdfs, yarn)

  2. 运行无界流

    bin/flink run -t yarn-per-job -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar
  1. 在yarn的ResourceManager界面查看执行情况

image.png

Flink on Yarn的3种部署模式

Flink提供了yarn上运行的3模式，分别为Session-Cluster，Application Mode和Per-Job-Cluster模式。

Session-Cluster

image.png

Session-Cluster模式需要先启动Flink集群，向Yarn申请资源。以后提交任务都向这里提交。这个Flink集群会常驻在yarn集群中，除非手工停止。

在向Flink集群提交Job的时候, 如果资源被用完了,则新的Job不能正常提交.

缺点: 如果提交的作业中有长时间执行的大作业, 占用了该Flink集群的所有资源, 则后续无法提交新的job.

所以, Session-Cluster适合那些需要频繁提交的多个小Job, 并且执行时间都不长的Job.

Per-Job-Cluster

image.png

一个Job会对应一个Flink集群，每提交一个作业会根据自身的情况，都会单独向yarn申请资源，直到作业执行完成，一个作业的失败与否并不会影响下一个作业的正常提交和运行。独享Dispatcher和ResourceManager，按需接受资源申请；适合规模大长时间运行的作业。

每次提交都会创建一个新的flink集群，任务之间互相独立，互不影响，方便管理。任务执行完成之后创建的集群也会消失。

Application Mode

Application Mode会在Yarn上启动集群, 应用jar包的main函数(用户类的main函数)将会在JobManager上执行. 只要应用程序执行结束, Flink集群会马上被关闭. 也可以手动停止集群.

与Per-Job-Cluster的区别：就是Application Mode下, 用户的main函数式在集群中执行的，并且当一个application中有多个job的话，per-job模式则是一个job对应一个yarn中的application，而Application Mode则这个application中对应多个job。

测试代码：

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class Application_Test {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        test1(env);
        test2(env);
        test3(env);
    }

    public static void test1(StreamExecutionEnvironment env) throws Exception {

        DataStreamSource<String> stringDataStreamSource = env.fromElements("22222");
        stringDataStreamSource.map(new MapFunction<String, String>() {
            @Override
            public String map(String value) throws Exception {
                return value;
            }
        }).print();
        env.execute();
    }

    public static void test2(StreamExecutionEnvironment env) throws Exception {
        DataStreamSource<String> stringDataStreamSource = env.fromElements("22222");
        stringDataStreamSource.map(new MapFunction<String, String>() {
            @Override
            public String map(String value) throws Exception {
                return value;
            }
        }).print();
        env.execute();
    }

    public static void test3(StreamExecutionEnvironment env) throws Exception {
        DataStreamSource<String> stringDataStreamSource = env.socketTextStream("hadoop102", 9999);
        stringDataStreamSource.map(new MapFunction<String, String>() {
            @Override
            public String map(String value) throws Exception {
                return value;
            }
        }).print();
        env.execute();
    }

}

打包上传到集群，分别以Per-job和Application Mode模式运行，对比区别

Per-job模式执行结果，一个job对应一个Application

image.png

Application Mode模式执行结果，多个job对应一个Application

image.png

官方建议:

出于生产的需求, 我们建议使用Per-job or Application Mode,因为他们给应用提供了更好的隔离!

image.png

ci.apache.org/projects/fl…

Per-Job-Cluster模式执行无界流WordCount

bin/flink run -d -t yarn-per-job -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

提交任务到Yarn的其他队列

（老版本）bin/flink run -d -m yarn-cluster -yqu hive -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

bin/flink run -d -t yarn-per-job -Dyarn.application.queue=hive -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

Session-Cluster模式执行无界流WordCount

  1. 启动一个Flink-Session

    bin/yarn-session.sh -d

  2. 在Session上运行Job

    bin/flink run -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

会自动找到你的yarn-session启动的Flink集群.也可以手动指定你的yarn-session集群:

bin/flink run -t yarn-session -Dyarn.application.id=application_XXXX_YY -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

注意: application_XXXX_YY 指的是在yarn上启动的yarn应用

如果是1.12版本开启了Yarn模式的高可用，上面指定yarn-session集群的命令 不能用，需要去掉 -t yarn-session

bin/flink run -Dyarn.application.id=application_XXXX_YY -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

Application Mode模式执行无界流WordCount

bin/flink run-application -t yarn-application -c com.atguigu.flink.java.chapter_2.Flink03_WC_UnBoundedStream ./flink-prepare-1.0-SNAPSHOT.jar

Yarn模式高可用

Yarn模式的高可用和Standalone模式的高可用原理不一样。

Standalone模式中, 同时启动多个Jobmanager, 一个为leader其他为standby的, 当leader挂了, 其他的才会有一个成为leader。

yarn的高可用是同时只启动一个Jobmanager, 当这个Jobmanager挂了之后, yarn会再次启动一个, 其实是利用的yarn的重试次数来实现的高可用。

  1. 在yarn-site.xml中配置
    <property>

    <name>yarn.resourcemanager.am.max-attempts</name>

    <value>4</value>

    <description>

    The maximum number of application master execution attempts.

    </description>

    </property>

注意: 配置完不要忘记分发, 和重启yarn

  1. 在flink-conf.yaml中配置
    yarn.application-attempts: 3cd

    high-availability: zookeeper

    high-availability.storageDir: hdfs://hadoop102:8020/flink/yarn/ha

    high-availability.zookeeper.quorum: hadoop102:2181,hadoop103:2181,hadoop104:2181

    high-availability.zookeeper.path.root: /flink-yarn

  1. 启动yarn-session

  2. 杀死Jobmanager, 查看的他的复活情况

    注意: yarn-site.xml中是它活的次数的上限, flink-conf.xml中的次数应该小于这个值。

  3. 测试过程中会发现一直kill不掉jobManager，是因为除了重新次数这个机制外，还有一个时间的机制（Akka超时时间），如果在一定的时间内jobManager重新拉取了几次还是挂掉的话，那就会真正的挂掉。

Scala REPL

scala 交互环境。

  1. local模式启动 REPL

    /opt/module/flink-local » bin/start-scala-shell.sh local

  2. yarn-session 模式启动

    先启动一个yarn-session, 然后就可以把shell跑在yarn-session上了

    bin/start-scala-shell.sh yarn 注意: Flink1.13版本中,交互环境已经被取消

K8S & Mesos模式

Mesos是Apache下的开源分布式资源管理框架，它被称为是分布式系统的内核,在Twitter得到广泛使用,管理着Twitter超过30,0000台服务器上的应用部署，但是在国内，依然使用着传统的Hadoop大数据框架，所以国内使用mesos框架的并不多，这里我们就不做过多讲解了，在Flink1.14版本已被取消。

容器化部署时目前业界很流行的一项技术，基于Docker镜像运行能够让用户更加方便地对应用进行管理和运维。容器管理工具中最为流行的就是Kubernetes（k8s），而Flink也在最近的版本中支持了k8s部署模式。这里我们也不做过多的讲解。

第四章 Flink运行架构

运行架构

avatar
文章
阅读
粉丝