Flink v1.11 - 官网 - 部署与运维

Flink v1.11 - 官网 - 部署与运维

• Flink v1.11 - 官网 - 部署与运维
  • 一、集群与部署
    • 1.1 概览
      • 1.1.1 部署方式
      • 1.1.2 部署目标
      • 1.1.3 Application Mode
    • 1.2 Local Cluster - 本地集群
    • 1.3 Flink Downloads
    • 1.4 Hadoop Integration - Hadoop 集成
    • 1.5 Standalone Cluster - 独立集群
    • 1.6 YARN
      • 1.6.1 Quickstart
      • 1.6.2 YARN Session Mode
      • 1.6.3 Yarn Per-job Mode
      • 1.6.4 Yarn Application Mode
      • 1.6.5 Recovery behavior of Flink on YARN
      • 1.6.6 设置 YARN 上的应用程序优先级
      • 1.6.7 调试失败的 YARN session
      • 1.6.8 为特定的 Hadoop 版本构建 YARN 客户端
      • 1.6.9 Running Flink on YARN behind Firewalls
      • 1.6.10 Background / Internals
    • 1.7 Mesos
    • 1.8 Docker
    • 1.9 Kubernetes
    • 1.10 Native Kubernetes
  • 二、高可用（HA）
    • 2.1 Overview
    • 2.2 Standalone Cluster HA
    • 2.3 YARN Cluster HA
    • 2.4 配置 Zookeeper 安全性
    • 2.5 Bootstrap ZooKeeper
  • 三、状态与容错
    • 3.1 Checkpoints
      • 3.1.1 概述
      • 3.1.2 保留 Checkpoint
    • 3.2 Savepoints
      • 3.2.1 概述
      • 3.2.2 分配算子 ID
      • 3.2.3 操作
      • 3.2.4 F.A.Q
      • 3.2.5 Checkpoints & Savepoints
    • 3.3 State Backends
      • 3.3.1 可用的 State Backends
        • 3.3.1.1 MemoryStateBackend
        • 3.3.1.2 FsStateBackend
        • 3.3.1.3 RocksDBStateBackend
        • 3.3.1.4 设置 State Backend
      • 3.3.2 RocksDB State Backend 进阶
        • 3.3.2.1 增量快照
        • 3.3.2.2 内存管理
        • 3.3.2.3 计时器（内存 vs. RocksDB）
        • 3.3.2.4 开启 RocksDB 原生监控指标
        • 3.3.2.5 列族（ColumnFamily）级别的预定义选项
        • 3.3.2.6 通过 RocksDBOptionsFactory 配置 RocksDB 选项
    • 3.4 大状态与 Checkpoint 调优
      • 3.4.1 总览
      • 3.4.2 监视状态和检查点
      • 3.4.3 调整检查点
      • 3.4.4 调整 RocksDB
        • 3.4.4.1 增量检查点
        • 3.4.4.2 RocksDB 或 JVM Heap 中的计时器
        • 3.4.4.3 调整 RocksDB 内存
      • 3.4.5 容量规划
      • 3.4.6 压缩
      • 3.4.7 任务本地恢复
        • 3.4.7.1 愿景
        • 3.4.7.2 方法
        • 3.4.7.3 主（分布式存储）和辅助（本地任务）状态快照的关系
        • 3.4.7.4 配置任务本地恢复
        • 3.4.7.5 有关不同状态后端的任务本地恢复的详细信息
        • 3.4.7.6 保留分配的调度
  • 四、内存配置
    • 4.1 配置 Flink 进程的内存
      • 4.1.1 配置总内存
      • 4.1.2 JVM 参数
      • 4.1.3 受限的等比内存部分
    • 4.2 配置 TaskManager 内存
      • 4.2.1 配置总内存
      • 4.2.2 配置堆内存和托管内存 - Configure Heap and Managed Memory
        • 4.2.2.1 任务（算子）堆内存 - Task (Operator) Heap Memory
        • 4.2.2.2 托管内存 - Managed Memory
      • 4.2.3 配置堆外内存（直接内存或本地内存）
      • 4.2.4 内存模型详解
      • 4.2.5 框架内存
      • 4.2.6 本地执行
      • 4.2.7 TaskManager 总结
    • 4.3 配置 JobManager 内存
      • 4.3.1 配置总内存
      • 4.3.2 详细配置
        • 4.3.2.1 配置 JVM 堆内存
        • 4.3.2.2 配置堆外内存
      • 4.3.3 本地执行
      • 4.3.4 总结
    • 4.4 调优指南
      • 4.4.1 独立部署模式（Standalone Deployment）下的内存配置
      • 4.4.2 容器（Container）的内存配置
      • 4.4.3 State Backend 的内存配置
        • 4.4.3.1 Heap State Backend
        • 4.4.3.2 RocksDB State Backend
      • 4.4.4 批处理作业的内存配置
    • 4.5 常见问题
      • 4.5.1 IllegalConfigurationException
      • 4.5.2 OutOfMemoryError: Java heap space
      • 4.5.3 OutOfMemoryError: Direct buffer memory
      • 4.5.4 OutOfMemoryError: Metaspace
      • 4.5.5 IOException: Insufficient number of network buffers
      • 4.5.6 容器（Container）内存溢出
    • 4.6 升级指南
      • 4.6.1 升级 TaskManager 内存配置
        • 4.6.1.1 配置参数变化
        • 4.6.1.2 总内存（原堆内存）
        • 4.6.1.3 JVM 堆内存
        • 4.6.1.4 托管内存
      • 4.6.2 升级 JobManager 内存配置
      • 4.6.3 Flink JVM 进程内存限制
      • 4.6.4 容器切除（Cut-Off）内存
        • 4.6.4.1 TaskManager
        • 4.6.4.2 JobManager
      • 4.6.5 flink-conf.yaml 中的默认配置
  • 五、配置参数
    • 5.1 基本配置 - Basic Setup
    • 5.2 通用配置 - Common Setup Options
      • 5.2.1 主机和端口 - Hosts and Ports
      • 5.2.2 容错能力 - Fault Tolerance
      • 5.2.3 检查点和状态后端 - Checkpoints and State Backends
      • 5.2.4 高可用性 - High Availability
      • 5.2.5 内存配置 - Memory Configuration
      • 5.2.6 杂项选择 - Miscellaneous Options
    • 5.3 安全 - Security
      • 5.3.1 SSL
      • 5.3.2 外部系统身份验证 - Auth with External Systems
        • 5.3.2.1 ZooKeeper 身份验证/授权
        • 5.3.2.2 Kerberos 的身份验证/授权
    • 5.4 资源管理框架 - Resource Orchestration Frameworks
      • 5.4.1 YARN
      • 5.4.2 Kubernetes
      • 5.4.3 Mesos
    • 5.5 状态后端 - State Backends
      • 5.5.1 RocksDB State Backend
    • 5.6 指标 - Metrics
      • 5.6.1 RocksDB 原生指标 - RocksDB Native Metrics
    • 5.7 History Server
    • 5.8 实验性 - Experimental
      • 5.8.1 可查询状态 - Queryable State
    • 5.9 Debugging & Expert Tuning
      • 5.9.1 Class Loading
      • 5.9.2 Advanced State Backends Options
      • 5.9.3 Advanced RocksDB State Backends Options
      • 5.9.4 Advanced Fault Tolerance Options
      • 5.9.5 Advanced Cluster Options
      • 5.9.6 Advanced Scheduling Options
      • 5.9.7 Advanced High-availability Options
      • 5.9.8 Advanced High-availability ZooKeeper Options
      • 5.9.9 Advanced SSL Security Options
      • 5.9.10 Advanced Options for the REST endpoint and Client
      • 5.9.11 Advanced Options for Flink Web UI
      • 5.9.12 Full JobManager Options
      • 5.9.13 Full TaskManager Options
      • 5.9.14 RPC / Akka
    • 5.10 JVM 和日志记录 - JVM and Logging Options
    • 5.11 转发环境变量 - Forwarding Environment Variables
    • 5.12 弃用的选项 - Deprecated Options
    • 5.13 备份 - Backup
      • 5.13.1 Client
      • 5.13.2 Execution
      • 5.13.3 Pipeline
      • 5.13.4 Checkpointing
    • 5.14 推荐的配置项
  • 六、生产准备清单
    • 6.1 设置明确的最大并行度
    • 6.2 为算子设置 UUID
    • 6.3 选择正确的状态后端
    • 6.4 配置 JobManager 高可用性
  • 七、CLI
    • 7.1 部署目标
    • 7.2 作业提交示例
    • 7.3 作业管理示例
    • 7.4 保存点
    • 7.5 用法
  • 八、Python REPL
  • 九、Scala REPL
    • 9.1 用法
      • 9.1.1 DataSet API
      • 9.1.2 DataStream API
      • 9.1.3 Table API
      • 9.1.4 SQL
    • 9.2 添加外部依赖
    • 9.3 完整参考
  • 十、扩展资源框架
    • 10.1 扩展资源框架做了什么
    • 10.2 启用扩展资源框架
      • 10.2.1 准备插件
      • 10.2.2 配置项
      • 10.2.3 使用扩展资源
    • 10.3 为你所使用的扩展资源实现自定义插件
    • 10.4 已支持的扩展资源插件
      • 10.4.1 GPU 插件
  • 十一、Kerberos
  • 十二、SSL 设置
  • 十三、文件系统
    • 13.1 概览
    • 13.2 通用配置
      • 13.2.1 默认文件系统
      • 13.2.2 连接限制
  • 十四、升级应用程序和 Flink 版本
    • 14.1 重新启动流应用程序

注：次文档参考 Flink v1.11 官方文档 Deployment & Operations 部分进行编写。
由于精力有限，部分内容并未整理，详见官网。
此文档仅用作个人学习，请勿用于商业获利。

一、集群与部署

1.1 概览

1.1.1 部署方式

• in Session Mode/会话模式
• in a Per-Job Mode
• in Application Mode （v1.11 新增）

以上模式的区别在于：

• 集群生命周期 和 资源隔离保证
• 应用程序的 main() 方法是在 客户端 还是在 集群上 执行（v1.11 新增）

Session Mode

这种模式会预先在 yarn 或者或者 k8s 上启动一个 flink 集群，然后将任务提交到这个集群上，这种模式，集群中的任务使用相同的资源，如果某一个任务出现了问题导致整个集群挂掉，那就得重启集群中的所有任务，这样就会给集群造成很大的负面影响。

Per-Job Mode

考虑到集群的资源隔离情况，一般生产上的任务都会选择 Per-Job 模式，也就是每个任务启动一个 flink 集群，各个集群之间独立运行，互不影响，且每个集群可以设置独立的配置。

目前，对于 Per-Job 模式，jar 包的解析、生成 JobGraph 是在客户端上执行的，然后将生成的 jobgraph 提交到集群。很多公司都会有自己的实时计算平台，用户可以使用这些平台提交 flink 任务，如果任务特别多的话，那么这些生成 JobGraph、提交到集群的操作都会在实时平台所在的机器上执行，那么将会给服务器造成很大的压力。

Application Mode

详见 1.1.3 Application Mode

1.1.2 部署目标

• Local : 在本地运行 Flink 进行基本测试和实验
• Standalone : 在裸机或 VM 上运行 Flink 的简单解决方案
• Yarn : 在 Apache Hadoop 的资源管理器顶部部署 Flink
• Mesos : 用于运行分布式系统的通用资源管理器
• Docker : 在容器化环境中运行 Flink 的流行解决方案
• Kubernetes : 用于部署容器化应用程序的自动化系统

1.1.3 Application Mode

作为现代企业的重要工具，流处理和实时分析这类工具逐渐兴起，越来越多的企业以 Apache Flink 为核心构建平台，并将其作为服务在内部提供。在最新举办的 Flink Forward 会议中， Uber、 Netflix 和阿里巴巴等公司的许多相关主题演讲进一步说明了这一趋势。

众多平台旨在通过减轻最终用户的所有运营负担来简化内部的 Application （应用）提交。为了提交 Flink 应用程序，这些平台通常只公开一个集中式或低并行度端点（例如 Web 前端）用于应用提交，我们将其称为 Deployer（部署器）。

平台开发人员和维护人员经常提到的障碍之一是，Deployer 可能是一个很难配置的大量资源消耗者。如果按照平均负载进行配置，可能会导致 Deployer 服务被部署请求淹没（在最坏的情况下，短时间内对所有生产应用程序都是如此），而按照最高负载进行规划的话，又会带来不必要的成本。根据这一观察结果，Flink 1.11 引入了 Application 模式（应用模式）作为部署选项，它允许一个轻量级、更可伸缩性的应用提交过程，从而使应用程序部署负载更均匀地分布在集群的各个节点上。

为了理解这个问题以及了解 Application 模式如何解决该问题，我们首先简要概述 Flink 中应用程序执行的当前状态，然后再阐述部署模式引入的架构变化以及如何利用它们。

Flink 中的应用程序执行

在 Flink 中执行应用程序主要涉及三个实体：

• Client（客户端） - 负责将应用提交给集群
• JobManager（作业管理器） - 负责执行期间必要的 bookkeeping
• TaskManager（任务管理器） - 负责实际的计算

更多细节请参考 Flink 架构 文档。

当前部署模式

在 1.11 版本中引入 Application 模式之前，Flink 允许用户在 Session（会话）或 Per-Job 集群上执行应用程序。两者之间的差异与集群生命周期和它们提供的资源隔离保证有关。

• Session Mode

Session 模式（会话模式）假定集群已经运行，并使用该集群的资源来执行任何提交的应用程序。在同一（Session）集群中执行的应用程序使用相同的资源，并因此相互竞争。

这样做的好处是，你无需为每个提交的作业分配整个集群的资源开销。

但是，如果其中一个作业行为不正常或者关闭了 TaskManager，那么在该 TaskManager 上运行的所有作业都将受到故障的影响。
除了对导致故障的作业产生负面影响之外，这还意味着潜在的大规模恢复过程，即所有重新启动的作业同时访问文件系统，并使其不可用于其他服务。
此外，单个集群运行多个作业意味着 JobManager 的负载更大，它负责集群中所有作业的 bookkeeping。

这种模式非常适合启动短作业，例如交互式查询。

• Per-Job Mode

在 Per-Job 模式中，可用的集群管理器框架（如 YARN 或 Kubernetes）用于为每个提交的作业启动 Flink 集群，该集群仅对该作业可用。当作业完成后，集群将关闭，并清理所有延迟的资源（例如文件）。

这种模式提供了更好的资源隔离，因为行为不正常的作业不会影响任何其他作业。
另外，由于每个应用程序都有自己的 JobManager，因此它将 bookkeeping 负载分散到多个实体。

考虑到前面提到的 Session 模式中的资源隔离问题，对于长时间运行的作业，用户经常选择 Per-Job 模式，因为这些作业愿意接受一定程度的启动延迟的增加，以支持弹性。

总之，在 Session 模式中，集群生命周期独立于集群中运行的任何作业，并且集群中运行的所有作业共享其资源。
Per-Job 模式选择为每个提交的作业分配一个集群，已提供更好的资源隔离保证，因为资源不会在作业之间共享。在这种情况下，集群的 生命周期 与 作业的生命周期相关。

Application 提交

Flink 应用程序的执行包括两个阶段：

• pre-flight，即当用户的 main() 方法被调用时；
• runtime，即用户代码调用 execute()时立即触发。

main() 方法使用 Flink 的 API（DataStream API、Table API、DataSet API）之一构造用户程序。当 main() 方法调用 env.execute() 时，用户定义的管道将被转换成 Job Graph（作业图），并将其传递给集群。

Session 模式和 Per-Job 模式 都会在 Client 执行应用程序的 main() 方法，即 pre-flight 阶段。

对于已经在本地具有其作业的所有依赖关系，然后通过在其机器上运行的 Client 提交其应用程序的单个用户来说，这通常不是问题。但是，对于通过远程实体（如 Deployer）提交的情况下，这个过程包括：

1. 本地下载应用程序的依赖项；
2. 执行 main() 方法提取 Job Graph；
3. 将 Job Graph 及其依赖项发送到集群以便执行；
4. 等待结果。

这使得 Client 消耗了大量的资源，因为它可能需要大量的网络带宽来下载依赖项或将二进制文件发送到集群，并且需要 CPU 周期来执行 main() 方法。随着越来越多的用户共享同一个 Client，这个问题甚至会变得更加突出。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hjooKavC-1600137656682)(https://flink.apache.org/img/blog/2020-07-14-application-mode/session-per-job.png)]

上图展示了使用三种应用程序（$红$、$蓝$、$绿$）的两种部署模式。每个并行度为3。
黑色矩形代表不同的进程：TaskManager、JobManager 和 Deployer。
我们假设在所有情况下都只有一个 Deployer 流程。彩色三角形表示提交进程的负载，而彩色矩形表示 TaskManager 和 JobManager 进程的负载。
如图所示，Per-Job 模式和 Session 模式下的 Deployer 共享相同的负载。它们的不同之处在于任务的分配和 JobManager 负载。
在 Session 模式下，集群中的所有作业共享一个 JobManager。而在 Per-Job 模式下，每个作业都有一个 JobManager。此外，Session 模式下的任务会随机分配给 TaskManager，而在 Per-Job 模式下，每个 TaskManager 只能有单个作业任务。

Application 模式

Application 模式建立在上述观察结果的基础上，并尝试将 Per-Job 模式的资源隔离 与 轻量级且可伸缩的应用提交过程 结合起来。为实现这一点，它为每个提交的应用程序创建一个集群，但是这一次，应用程序的 main() 方法在 JobManager 上执行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TfQB7g1R-1600137656685)(https://flink.apache.org/img/blog/2020-07-14-application-mode/application.png)]

为每个应用程序创建一个集群可以看作是创建一个只在特定应用程序的作业之间共享的 Session 集群，并在应用程序结束时关闭。使用这种架构，Application 模式提供与 Per-Job 模式相同的资源隔离和负载平衡保证，但在整个应用程序的粒度上。这是有道理的，因为属于同一应用程序的工作应该相互关联，并被视为一个单元。

在 JobManager 上执行 main() 方法， 不仅可以节省提取 Job Graph 所需的 CPU 周期，也可以节省 Client 本地下载依赖项并将 Job Graph 及其依赖项发送到集群所需的带宽。
此外，由于每个应用程序只有一个 JobManager，因此，它可以更均匀地分散网络负载。
上图对此进行了说明，其中我们具有与 “Session 和 Per-Job 部署模式” 部分中相同的场景，但是这一次 Client 负载已经转移到了每个应用程序的 JobManager。

注：在 Application 模式下， main() 方法是在集群上执行的，而不是像在其他模式中那样在 Client 上执行。这可能对代码产生影响，例如，使用 regsiterCachedFile() 在环境中注册的任何路径都必须由应用程序的 JobManager 进行访问。

与 Per-Job 模式相比，Application 模式允许提交由多个作业组成的应用程序。作业执行的顺序不受部署模式的影响，而是受用于启动作业的调用的影响。使用阻塞 execute() 方法建立一个顺序，并将导致 “next” 作业的执行被延迟到 “this” 作业完成为止。相反，一旦提交了当前作业，非阻塞 executeAsync() 方法将立即继续提交 “next” 作业。

降低网络需求

如上所述，通过在 JobManager 上执行应用程序的 main() 方法，Application 模式可以节省以前在提交作业时所需的大量资源。但仍有改进的余地。

重点关注 YARN，YARN 已经支持此处提到的所有优化，即使 Application 模式已经就绪，Client 仍然需要发送用户 Jar 到 JobManager。此外，对于每个应用程序，Client 必须将 “flink-dist” 目录发送到集群，该目录包含框架本身的二进制文件，包括 flink-dist.jar 、 lib/ 和 plugin/ 目录。这两者可能会在 Client 占用大量带宽。此外，在每次提交时发送相同的 flink-dist 二进制文件既是对带宽的浪费，也是对存储空间的浪费。只需允许应用程序共享相同的二进制文件即可减少存储空间的浪费。

在 Flink 1.11 中，我们引入了允许用户执行以下操作的选项：

指定一个目录的远程路径，在该目录中，YARN 可以找到 Flink 分发二进制文件。
指定一个远程路径，YARN 可以在其中找到用户 Jar。

对于第一步，我们利用了 YARN 的分布式缓存，并允许应用程序共享这些二进制文件。因此，如果一个应用程序碰巧在它的 TaskManager 的本地存储中找到了 Flink 的副本，由于之前的一个应用程序在同一个 TaskManager 上执行，它甚至都不需要在内部下载它。

注：这两种优化都可以用于 YARN 上的所有部署模式，而不仅仅是 Application 模式。

示例：YARN 上的 Application 模式

有关完整说明，请参阅 Flink 的官方文档，更具体地说，请参阅引用集群管理框架的页面，例如 YARN 或 Kubernetes。接下来我将给出一些关于 YARN 的例子，其中上述所有功能都是可用的。

要以 Application 模式启动用用程序，可以使用：

./bin/flink run-application -t yarn-application ./MyApplication.jar

使用这条命令，所有的配置参数，例如用于引导应用程序状态的保存点的路径，或者所需的 JobManager/TaskManager 内存大小，都可以通过它们的配置选项（以 -d 作为前缀）来指定。有关可用配置选项的目录，请参阅 配置参数。

例如，指定 JobManager 和 TaskManager 内存大小的命令如下所示：

./bin/flink run-application -t yarn-application \
-Djobmanager.memory.process.size=2048m \
-Dtaskmanager.memory.process.size=4096m \
./MyApplication.jar

如前所述，以上内容将确保您的应用程序的 main() 方法将在 JobManager 上执行。

为了进一步节省将Flink发行版运送到群集的带宽，请考虑将 Flink 发行版预上传到 YARN 可以访问的位置，并使用 yarn.provided.lib.dirs 配置选项，如下所示：

./bin/flink run-application -t yarn-application \
-Djobmanager.memory.process.size=2048m \
-Dtaskmanager.memory.process.size=4096m \
-yD yarn.provided.lib.dirs="hdfs://myhdfs/remote-flink-dist-dir" \
./MyApplication.jar

最后，为了进一步节省提交应用程序 Jar 所需的带宽，可以预先将其上传到 HDFS，并指定指向 ./MyApplication.jar 的远程路径，如下所示：

./bin/flink run-application -t yarn-application \
-Djobmanager.memory.process.size=2048m \
-Dtaskmanager.memory.process.size=4096m \
-yD yarn.provided.lib.dirs="hdfs://myhdfs/remote-flink-dist-dir" \
hdfs://myhdfs/jars/MyApplication.jar

这将使作业提交变得更加轻量级，因为所需的 Flink jar 和应用程序 Jar 将从指定的远程位置提取，而不是由 Client 发送到集群。Client 将唯一提供给集群的是应用程序的配置，其中包括上述提到的所有路径。

原文链接： Application Deployment in Flink: Current State and the new Application Mode

1.2 Local Cluster - 本地集群

下载启动

检查 Java 版本

java -version

从 下载页面 下载二进制文件。您可以选择任何您喜欢的 Scala 版本。对于某些功能，您可能还需要下载一个预先捆绑的 Hadoop jar 并将其放入 $FLINK_HOME/lib 目录中。

# 创建用户
userdel -r flink && useradd flink && echo flink | passwd --stdin flink

# 下载
su - flink
wget https://mirrors.tuna.tsinghua.edu.cn/apache/flink/flink-1.11.1/flink-1.11.1-bin-scala_2.11.tgz

# 解压
tar -zxvf flink-1.11.1-bin-scala_2.11.tgz 

# 创建软链
ln -s flink-1.11.1 flink

# 配置环境变量
vim ~/.bashrc 
export FLINK_HOME=/home/software/flink/flink-1.11.0
export PATH=$PATH:$FLINK_HOME/bin:

source ~/.bashrc 

启动

/home/flink/flink-1.11.1/bin/start-cluster.sh 

# UI
http://localhost:8081

停止

/home/flink/flink-1.11.1/bin/stop-cluster.sh 

1.3 Flink Downloads

Apache Flink® 1.11.1 是当前最新的稳定版本。

如果你计划将 Apache Flink 与 Apache Hadoop 一起使用（在 YARN 上运行 Flink ，连接到 HDFS ，连接到 HBase ，或使用一些基于 Hadoop 文件系统的 connector ），请查看 Hadoop 集成文档。

Release Notes - Flink 1.11

原文链接：https://ci.apache.org/projects/flink/flink-docs-release-1.11/zh/release-notes/flink-1.11.html

Maven 依赖

你只要将以下依赖项添加到 pom.xml 中，就能在项目中引入 Apache Flink 。这些依赖项包含了本地执行环境，因此支持本地测试。

<!--  ======== Flink Core - Java ========  -->
<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-java</artifactId>
  <version>1.11.1</version>
</dependency>
<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-streaming-java_2.11</artifactId>
  <version>1.11.1</version>
</dependency>
<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-clients_2.11</artifactId>
  <version>1.11.1</version>
</dependency>

<!--  ======== Flink Core - Scala ========  -->
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-scala_2.11</artifactId>
    <version>1.11.1</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-streaming-scala_2.11</artifactId>
    <version>1.11.1</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-clients_2.11</artifactId>
    <version>1.11.1</version>
</dependency>

从源码构建 Flink

前提：

• Maven 3
• Java 8

注意：Maven 3.3.x 可以构建 Flink，但是不能正确地遮盖某些依赖项。Maven 3.2.5会正确创建库。
要构建单元测试，请使用 Java 8u51 或更高版本，以防止使用 PowerMock 运行器的单元测试失败。

下载源码

wget http://archive.apache.org/dist/flink/flink-1.11.1/flink-1.11.1-src.tgz

构建 Flink 的最简单方法：

mvn clean install -DskipTests

这指示 Maven（mvn）首先删除所有现有的内部版本（clean），然后创建一个新的 Flink 二进制文件（install）。
为了加快构建速度，您可以跳过测试，QA 插件 和 JavaDocs：

mvn clean install -DskipTests -Dfast
# Scala version 2.11 (default) 
# mvn clean install -DskipTests -Dscala-2.12

编译好的文件

flink-1.11.1/flink-dist/target/flink-1.11.1-bin/

tar -zcvf flink-1.11.1.tgz flink-1.11.1

1.4 Hadoop Integration - Hadoop 集成

为了使用 Hadoop 功能（例如YARN，HDFS），必须为 Flink 提供所需的 Hadoop 类，因为默认情况下未捆绑这些类。

• 环境变量

推荐的方法是通过 HADOOP_CLASSPATH 环境变量将 Hadoop 类路径添加到 Flink 。

Flink 将使用环境变量 HADOOP_CLASSPATH 来扩展启动 Flink 组件（例如 Client，JobManager 或 TaskManager）时使用的类路径。默认情况下，大多数 Hadoop 发行版和云环境不会设置此变量，因此，如果 Flink 选择 Hadoop 类路径，则必须在运行 Flink 组件的所有计算机上导出环境变量。

在 YARN 上运行时，这通常不是问题，因为在 YARN 中运行的组件将使用 Hadoop 类路径启动，但是在将作业提交给 YARN 时，可能会发生 Hadoop 依赖项必须在类路径中的情况。为此，在 shell 中使用 export HADOOP_CLASSPATH=hadoop classpath` 通常足以运行。

export HADOOP_CLASSPATH=`hadoop classpath`
export HADOOP_CONF_DIR=/etc/hadoop/conf
export FLINK_HOME=~/flink
export PATH=$PATH:$FLINK_HOME/bin:$HADOOP_CLASSPATH:$HADOOP_CONF_DIR:

在本地执行工作

要使用小型集群将作业作为一个 JVM 进程在本地运行，必须将必需的 hadoop 依赖项显式添加到已启动的 JVM 进程的类路径中。

要使用 Maven 运行应用程序，可以将所需的 Hadoop 依赖项添加到 pom.xml 中，例如：

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-client</artifactId>
    <version>2.8.3</version>
    <scope>provided</scope>
</dependency>

使用 flink-shaded-hadoop-2-uberjar 解决依赖冲突（旧版）

警告：从 Flink 1.11 开始，flink-shaded-hadoop-2-uberFlink 项目不再正式支持使用发行版。建议用户通过提供 Hadoop 依赖关系 HADOOP_CLASSPATH（请参见上文）。

Flink 1.10 以及之前的 Hadoop 发行版，可以将版本对应的 Pre-bundled Hadoop v* jar 包放入 Flink 的 /lib 目录中就足够了。

如果没有对应的版本，那么可以针对该版本构建 flink 阴影的版本。运行以下命令以 flink-shaded 针对所需的 Hadoop 版本（例如 version 2.6.5-custom ）进行构建和安装：

mvn clean install -Dhadoop.version=2.6.5-custom

完成此步骤后，将 flink-shaded-hadoop-2-uber jar 放入 /lib 分发目录中。

1.5 Standalone Cluster - 独立集群

群集由 一个主节点 和 一个或多个工作节点 组成。在开始设置系统之前，请确保在每个节点上都安装了以下软件：

• Java 1.8.x+
• ssh（jobmanager -> taskmanager）

集群规划：

ip/host	jobmanager	taskmanager
10.0.0.1	√
10.0.0.2		√
10.0.0.3		√

修改配置

转到下载页面并获取准备运行的软件包。确保选择与您的 Hadoop 版本匹配的 Flink 软件包。如果您不打算使用 Hadoop，请选择任何版本。

• flink-conf.yaml 修改

# 主节点配置
jobmanager.rpc.address: 10.0.0.1
# 定义允许 Flink 在每个节点上分配的最大主内存量（单位 MB）
# 工作节点也可根据自身内存大小自定义这两个数值
jobmanager.memory.process.size: 2048m
taskmanager.memory.process.size: 4096m
# 定义每台服务器的最大 Slot 数
taskmanager.numberOfTaskSlots: 4

• workers 修改

10.0.0.2
10.0.0.3

• 下发安装包并创建软链

略

Flink 目录必须在同一路径下的每个工作线程上都可用。您可以使用共享的 NFS 目录，也可以将整个 Flink 目录复制到每个工作节点。

请参阅 配置参数 以获取详细信息和其他配置选项。

特别是以下几个非常重要的配置值：

• 每个 JobManager 的可用内存量 - jobmanager.memory.process.size
• 每个 TaskManager 的可用内存量 - taskmanager.memory.process.size 并查看 内存设置指南
• 每台计算机可用的 CPU 数 - taskmanager.numberOfTaskSlots
• 程序的默认并行性 - parallelism.default
• 临时目录 - io.tmp.dirs

启动 Flink

start-cluster.sh

# 将 JobManager/TaskManager 实例添加到集群
jobmanager.sh ((start|start-foreground) [host] [webui-port])|stop|stop-all
taskmanager.sh start|start-foreground|stop|stop-all

使用 ./bin/flink 将 程序提交到 Flink 群集：

Action "run" compiles and runs a program.

  Syntax: run [OPTIONS] <jar-file> <arguments>
  "run" action arguments:
     -c,--class <classname>           Class with the program entry point ("main"
                                      method or "getPlan()" method. Only needed
                                      if the JAR file does not specify the class
                                      in its manifest.
     -m,--jobmanager <host:port>      Address of the JobManager to
                                      which to connect. Use this flag to connect
                                      to a different JobManager than the one
                                      specified in the configuration.
     -p,--parallelism <parallelism>   The parallelism with which to run the
                                      program. Optional flag to override the
                                      default value specified in the
                                      configuration

Example :

wget -O LICENSE-2.0.txt http://www.apache.org/licenses/LICENSE-2.0.txt

hadoop fs -copyFromLocal LICENSE-2.0.txt hdfs:///tmp

flink run ~/flink/examples/batch/WordCount.jar --input hdfs:///tmp/LICENSE-2.0.txt --output hdfs:///tmp/wordcount-result-dir

1.6 YARN

1.6.1 Quickstart

Start a long-running Flink cluster on YARN

# If HADOOP_CLASSPATH is not set:
#   export HADOOP_CLASSPATH=`hadoop classpath`
./bin/yarn-session.sh -jm 1024m -tm 4096m

Run a single Flink job on YARN

# If HADOOP_CLASSPATH is not set:
#   export HADOOP_CLASSPATH=`hadoop classpath`
flink run -m yarn-cluster -p 4 -yjm 1024m -ytm 4096m ~/flink/examples/batch/WordCount.jar --input hdfs:///tmp/test.txt --output hdfs:///tmp/wordcount-result-dir

以上运行的任务可以在 Yarn ResourceManager 管理页上查看。

1.6.2 YARN Session Mode

使用 yarn-session.sh -h 查看具体指令

Usage:
   Optional
     -at,--applicationType <arg>     Set a custom application type for the application on YARN
     -D <property=value>             use value for given property
     -d,--detached                   If present, runs the job in detached mode
     -h,--help                       Help for the Yarn session CLI.
     -id,--applicationId <arg>       Attach to running YARN session
     -j,--jar <arg>                  Path to Flink jar file
     -jm,--jobManagerMemory <arg>    Memory for JobManager Container with optional unit (default: MB)
     -m,--jobmanager <arg>           Address of the JobManager to which to connect. Use this flag to connect to a different JobManager than the one specified in the configuration.
     -nl,--nodeLabel <arg>           Specify YARN node label for the YARN application
     -nm,--name <arg>                Set a custom name for the application on YARN
     -q,--query                      Display available YARN resources (memory, cores)
     -qu,--queue <arg>               Specify YARN queue.
     -s,--slots <arg>                Number of slots per TaskManager
     -t,--ship <arg>                 Ship files in the specified directory (t for transfer)
     -tm,--taskManagerMemory <arg>   Memory per TaskManager Container with optional unit (default: MB)
     -yd,--yarndetached              If present, runs the job in detached mode (deprecated; use non-YARN specific option instead)
     -z,--zookeeperNamespace <arg>   Namespace to create the Zookeeper sub-paths for high availability mode

请注意，客户端要求将 YARN_CONF_DIR 或 HADOOP_CONF_DIR 环境变量设置为读取 YARN 和 HDFS 配置。

示例：发出以下命令以启动Yarn会话集群，在该集群中，每个任务管理器均以 8 GB 内存和 32 个处理插槽启动：

./bin/yarn-session.sh -tm 8192 -s 32
# 使用 Ctrl + C 关闭 Flink 集群

系统将使用中的配置 conf/flink-conf.yaml。如果要更改某些内容，请遵循我们的 配置参数。

YARN 上的 Flink 将覆盖以下配置参数 jobmanager.rpc.address （因为 JobManager 始终分配在不同的机器上），io.tmp.dirs（我们使用的是 YARN 提供的 tmp 目录）以及 parallelism.default 是否指定了插槽数。

如果您不想更改配置文件来设置配置参数，则可以选择通过 -D 标志传递动态属性。因此，您可以通过以下方式传递参数： -Dfs.overwrite-files=true -Dtaskmanager.memory.network.min=536346624 。

示例调用为运行作业管理器的 ApplicationMaster 启动了一个容器。当作业提交到集群时，会话集群将自动分配运行任务管理器的其他容器。

将 Flink 部署到 YARN 群集中后，它将向您显示作业管理器的连接详细信息。

仅当群集上的 ApplicationMaster 有足够的资源可用时，YARN 上的 Flink 才会启动。大多数 YARN 调度程序都考虑了容器的请求内存，有些还考虑了 vcore 的数量。默认情况下，vcore 的数量等于处理插槽（-s）参数。在 yarn.containers.vcores 允许覆盖 vcores 的数量与自定义值。为了使此参数起作用，您应该在集群中启用 CPU 调度。

在 YARN 上启动一个长期运行的 Flink 集群

如果您不想一直保持 Flink YARN 客户端运行，也可以启动一个分离的 YARN 会话。该参数称为 -d 或 --detached 。在这种情况下，Flink YARN 客户端只会将 Flink 提交到群集，然后自行关闭。

# If HADOOP_CLASSPATH is not set:
# export HADOOP_CLASSPATH=`hadoop classpath`
# 开启一个有 8个 slots，每个 jobManager 内存为 1G，每个 TaskManager 内存为 1G 的 Yarn Session
yarn-session.sh -s 8 -jm 1024 -tm 1024 -nm YarnSessionDemo -d

# 可使用以下两种方式关闭 Flink 集群
echo "stop" | yarn-session.sh -id <appId>
yarn application -kill applicationId // 但是请注意，杀死 Flink 可能不会清除所有作业工件和临时文件。

附加到现有会话

yarn application -list
yarn-session.sh -id applicationId/yarnAppId

提交任务

在 Web UI 上提交运行 Jar 包并执行

OR 

flink run -yid application_12345678 ~/flink/examples/batch/WordCount.jar --input hdfs:///tmp/test.txt --output hdfs:///tmp/wordcount-result.txt

1.6.3 Yarn Per-job Mode

上面的文档描述了如何在 Hadoop YARN 环境中启动 Flink 集群。也可以仅在执行单个作业时在 YARN 中启动 Flink。

例：

./bin/flink run -m yarn-cluster ./examples/batch/WordCount.jar

该 ./bin/flink 工具还提供 YARN 会话的命令行选项。它们以 y 或 yarn 为前缀（用于长参数选项）。

注意：通过设置环境变量，可以为每个作业使用不同的配置目录 FLINK_CONF_DIR 。要使用此副本，请从 Flink 分发版复制 conf 目录并进行修改。

User jars & Classpath

用户依赖管理还是有一定的注意事项的，默认情况下当单个 job 在运行的时候 flink 会将用户 jar 包含进 系统 chasspath 内部。该行为也可以通过 yarn.per-job-cluster.include-user-jar 参数进行控制。

当将该参数设置为 DISABLED，Flink 会将 jar 放入到 用户 classpath 里面（这里要强调一下，前面说的是 系统 classpath，而这里是 用户 classpath）。

用户 jar 的在 classpath 的位置顺序是由该参数的下面几个值决定的：

• ORDER：（默认）根据词典顺序将 jar 添加到系统类路径。
• FIRST：将 jar 添加到系统类路径的开头。
• LAS