Flink入门到放弃

最新推荐文章于 2024-02-12 22:26:14 发布
最新推荐文章于 2024-02-12 22:26:14 发布
阅读量329 收藏 2
点赞数 1
分类专栏： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39743356/article/details/113405841
版权

Flink入门到放弃

简介

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

https://flink.apache.org/zh/#

快速上手

准备

pom.xml

	<properties>
        <flink.version>1.12.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>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

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

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
            <scope>provided</scope>
        </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>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

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

配置idea, 运行的时候包括provided scope

Application->
	configuration->
		Include dependencies with "Provided" scope

批处理wordCount

package com.yire.quickstart.workcount;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;

/**
 * 批处理
 */
public class BatchHandle {
    public static void main(String[] args) throws Exception {

        ExecutionEnvironment environment = ExecutionEnvironment.getExecutionEnvironment();
        DataSource<String> dataSource = environment.readTextFile("input/testWordCount.txt");
        dataSource
                .flatMap((FlatMapFunction<String, Tuple2<String, Long>>) (line, out) -> {
                    String[] s = line.split(" ");
                    for (String s1 : s) {
                        out.collect(new Tuple2<>(s1, 1L));
                    }
                })
                //泛型擦除，要指定泛型
                // 在很多情况下，当涉及Java泛型时，lambda方法无法提供足够的信息来进行自动类型提取。
                .returns(Types.TUPLE(Types.STRING, Types.LONG))
                .groupBy(0)
                .sum(1)
                .print();
    }

}

流处理wordCount

有界

package com.yire.quickstart.workcount;


import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
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.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

import java.util.Arrays;

/**
 * 有界流处理
 */
public class BoundStreamWordCount {
    public static void main(String[] args) throws Exception {
        //用流式
//        ExecutionEnvironment environment = ExecutionEnvironment.getExecutionEnvironment();
        StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> dataSource = environment.readTextFile("input/testWordCount.txt");

        //原始写法
        dataSource
                .flatMap(new FlatMapFunction<String, String>() {
                    @Override
                    public void flatMap(String line, Collector<String> out) throws Exception {
                        Arrays
                                .asList(line.split(" "))
                                .stream()
                                .forEach(x -> {
                                    out.collect(x);
                                });
                    }
                })
                .returns(Types.STRING)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> map(String value) throws Exception {
                        return Tuple2.of(value, 1L);
                    }
                })
                .keyBy(new KeySelector<Tuple2<String,Long>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Long> value) throws Exception {
                        return value.f0;
                    }
                })
                .sum(1)
                .print();

        dataSource
                .flatMap((FlatMapFunction<String, String>) (line, out) -> Arrays
                        .stream(line.split(" "))
                        .forEach(out::collect))
                .returns(Types.STRING)
                .map(value -> Tuple2.of(value, 1L))
                //这个代码用lambda时要加上
                .returns(Types.TUPLE(Types.STRING, Types.LONG))
                .keyBy(k -> k.f0)
                .sum(1)
                .print();

        //保持
        environment.execute();


    }
}

无界

package com.yire.quickstart.workcount;

import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

import java.util.Arrays;


/**
 * 无界流处理
 */
public class UnboundStreamWordCount {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> socket = environment.socketTextStream("hadoop162", 8089);
        socket
                .flatMap((String line, Collector<Tuple2<String, Long>> out) -> {
                    Arrays.stream(line.split(" "))
                            .map(s -> Tuple2.of(s, 1L))
                            .forEach(out::collect);
                })
                .returns(Types.TUPLE(Types.STRING, Types.LONG))
                .keyBy(k -> k.f0)
                .sum(1)
                .print();
        environment.execute();
    }
}

测试，在虚拟机

nc -lk hadoop162 8089

运行模式

可以指定批模式读取有界数据

environment.setRuntimeMode(RuntimeExecutionMode.BATCH);

部署

开发模式

上面的快速入门就是开发模式

local-cluster模式

本地集群，零配置，用于测试、学习

  1. 解压tar包
  2. 解压完的目录复制出一个flink-local

运行无界WordCount

  1. idea中打包（不带依赖），并上传

  2. 启动本地集群bin/start-cluster.sh

  3. 测试

    nc -lk hadoop162 8089

  4. 提交flink应用

    1. 命令行提交

      bin/flink run -m hadoop162:8081 -c com.yire.quickstart.workcount.UnboundStreamWordCount ./flink-1.0-SNAPSHOT.jar

      bin/flink run -m 主机名：端口 -c 全类名 jar包
bin/flink run [OPTIONS] <jar-file> <arguments>
-m参数不支持高可用的集群

    2. 也可以在web-ui界面提交应用

      • Submit New Job

  5. 访问hadoop162:8081（默认web ui server的端口为8081）查看执行情况

  6. 可以进log/查看执行结果

停止集群

bin/stop-cluster.sh

Standalone模式

独立集群模式

  1. 复制安装目录为flink-standalone

  2. 修改配置flink-conf.yaml

    jobmanager.rpc.address: hadoop162

  3. 修改workers

    hadoop164
hadoop165

    没有hadoop162

运行无界WordCount

和local-cluster完全相同

Standalone高可用(HA)

  1. 需要zookeeper
  2. 高可用数据存在hdfs，所以也要开hdfs
  3. JobManager为StandaloneSessionClusterEntrypoint进程
  4. 执行者为TaskManagerRunner进程

配置

  1. 修改flink-conf.yaml

    high-availability: zookeeper
high-availability.storageDir: hdfs://hadoop162:8020/flink/standalone/ha
high-availability.zookeeper.quorum: hadoop162:2181,hadoop164:2181,hadoop165:2181
high-availability.zookeeper.path.root: /flink-standalone
high-availability.cluster-id: /cluster_yire

  2. 修改masters

    hadoop162:8081
hadoop163:8081

  3. 环境变量/etc/profile.d/my.sh

    export HADOOP_CLASSPATH=`hadoop classpath`

  4. 分发

启动

  1. 启动zookeeper
  2. 启动hdfs
  3. 启动flink
  4. 可以访问zookeeper的节点查看主从

Yarn模式

  1. 复制安装包成flink-yarn

  2. 配置HADOOP_CLASSPATH

    export HADOOP_CLASSPATH=`hadoop classpath`

Session-Cluster

  1. 将flink的jobManager启动在yarn上，动态分配资源，跑任务就申请，跑完就释放

  2. 启动flink-Session，-d的意思detached独立模式，相当于启动完退出客户端

    bin/yarn-session.sh -d

  3. 在session上运行job

    1. 自动找

      bin/flink run -d -c com.yire.quickstart.workcount.UnboundStreamWordCount ./flink-1.0-SNAPSHOT.jar

    2. 指定端口

      #端口是随机生成的，在页面的submit界面可以看到
bin/flink run -d -m hadoop162:34382 -c com.yire.quickstart.workcount.UnboundStreamWordCount ./flink-1.0-SNAPSHOT.jar

    3. 指定yarn的appid

      bin/flink run -d -t yarn-session -Dyarn.application.id=application_1611137588501_0005 -c com.yire.quickstart.workcount.UnboundStreamWordCount ./flink-1.0-SNAPSHOT.jar

Per-Job-Cluster

  1. 启动hadoop集群

  2. 运行jar包

    bin/flink run -t yarn-per-job -c com.yire.quickstart.workcount.UnboundStreamWordCount ./flink-1.0-SNAPSHOT.jar

  3. 每次都会提交一个flink集群

Application Mode

跟Per-Job-Cluster的不同是，main函数执行的位置，此模式为yarn的container上（flink的集群上），Per-Job-Cluster为本地

bin/flink run-application -d -t yarn-application -c com.yire.quickstart.workcount.UnboundStreamWordCount ./flink-1.0-SNAPSHOT.jar

yarn模式高可用

原理与standalone不同，standalone为一开就启动多个jobManager，yarn模式下为jobManager停了，会重启

  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>

  2. 配置完分发, 和重启yarn

  3. 在flink-conf.yaml中配置

    #这个值应该小于等于上面yarn那个值
yarn.application-attempts: 3
high-availability: zookeeper
high-availability.storageDir: hdfs://hadoop162:8020/flink/yarn/ha
high-availability.zookeeper.quorum: hadoop162:2181,hadoop164:2181,hadoop165:2181
high-availability.zookeeper.path.root: /flink-yarn

  4. 启动yarn-session

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

  6. 重试的次数为固定间隔时间内的次数，此间隔时间内成功启动的话，会重置这个次数

Scala REPL

类似spark-shell

  1. 本地模式

    bin/start-scala-shell.sh local

  2. yarn-session模式

    bin/start-scala-shell.sh yarn

错误解决

错误1

Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/flink/streaming/api/environment/StreamExecutionEnvironment

解决：idea配置

Application->
	configuration->
		Include dependencies with "Provided" scope

错误2

Exception in thread "main" org.apache.flink.api.common.functions.InvalidTypesException: The return type of function 'main(UnboundStreamWordCount.java:19)' could not be determined automatically, due to type erasure. You can give type information hints by using the returns(...) method on the result of the transformation call, or by letting your function implement the 'ResultTypeQueryable' interface.
	at org.apache.flink.api.dag.Transformation.getOutputType(Transformation.java:484)
	at org.apache.flink.streaming.api.datastream.DataStream.getType(DataStream.java:190)
	at org.apache.flink.streaming.api.datastream.KeyedStream.<init>(KeyedStream.java:115)
	at org.apache.flink.streaming.api.datastream.DataStream.keyBy(DataStream.java:290)
	at com.yire.quickstart.workcount.UnboundStreamWordCount.main(UnboundStreamWordCount.java:24)

lambda泛型擦除，加上returns(…指定类型…)

程序猿-瑞瑞
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Flink on YARN 部署(上)】Flink on YARN 理论概念
Gavin_周的博客
04-22 472
文章目录前言Flink on YARNYARN中一些重要的概念ResourceManagerNodeManagerApplicationMasterContainerFlink 在 YARN上的分布及提交流程Flink 在 YARN 上的分布提交流程 前言 将Flink 提交在 YARN 上是企业的一种常用做法，这样做的目的是为了提高集群的利用率。 Flink on YARN 有2种部署方式 ...
Flink入门
weixin_45425054的博客
04-11 97
首先Flink是一种事件驱动型流式处理框架，也就是说Flink是被动的接受数据的，因为有数据来才会触发后面的运行，对比spark，即使是spark streaming，也是一批一批的取数据，开启之后也能看到它在不断的打印时间戳，时间间隔为spark streaming的批次时间 Flink可以分为无界流和有界流，区别只在于API读取数据的方法， 这里以java举例，有界流使用readTextFile方法，那么就决定了他总是有个界限的，但是无界流使用socketTextStream，不断的开启一个流，没有停.
【Flink】在算子中使用Tuple出现的bug
Zsigner的博客
07-06 766
在使用map，flatMap 算子的过程中想把pojo 转换成Tuple 类型进行输出，在编码的过程中正常，运行是出现异常
Flink教程(18) Flink1.12.0 批流一体 setRuntimeMode(RuntimeExecutionMode.BATCH) 问题解决
Java Spring Elasticsearch
03-29 3368
一、问题 在Flink1.12.0有个重要的功能，批流一体，就是可以用之前流处理的API处理批数据。 只需要调用setRuntimeMode(RuntimeExecutionMode executionMode)。 RuntimeExecutionMode 就是一个枚举，有流、批和自动。 @PublicEvolving public enum RuntimeExecutionMode { STREAMING, BATCH, AUTOMATIC; private Runtim
Flink简介和入门API
lslslslslss的博客
03-25 2807
什么是Flink Flink起源于Stratosphere项目，Stratosphere是在2010~2014年由3所地处柏林的大学和欧洲的一些其他的大学共同进行的研究项目，2014年4月Stratosphere的代码被复制并捐赠给了Apache软件基金会，参加这个孵化项目的初始成员是Stratosphere系统的核心开发人员，2014年12月，Flink一跃成为Apache软件基金会的顶级项目。 在德语中，Flink一词表示快速和灵巧，项目采用一只松鼠的彩色图案作为lo...
Flink1.13批流合一的介绍
lihengzkj的博客
05-19 1000
Flink批流合一的介绍 概况 DataStream API支持不同的运行时执行模式，我们可以根据实际的需求和任务的特征来选择这些模式。 STREAMING执行模式是DataStream API的“经典”执行行为，应该用于需要持续增量处理并预期无限期在线的无限作业。 此外，还有一种批处理风格的执行模式，我们称之为 BATCH执行模式。 它以一种像批处理框架(如MapReduce)的方式执行作业。 这应用于已知有限的数据源输入并且不会连续运行的有界作业。 Flink对流和批处理的统一方法意味着在有界输入上执行
flink入门文档.pdf
08-16
Flink 入门文档 Flink 是一个大数据处理框架，具有批流一体、高容错、高吞吐、低延迟、大规模计算、多平台部署等核心特点。本文档将对 Flink 的核心概念、架构、API 层次进行详细介绍。 1. 核心概念 Flink 是一个...
flink入门实战
06-15
以flink处理kafka消息流场景为例，将接受到的kafka消息sink到mysql、elastic、hdfs、kafka，通过真实的案例，助你入门flink计算框架。课程案例代码也可移植到其它业务系统，实现快速开发。
Flink从入门到精通
05-28
Flink从入门到精通 Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。Flink 的发展历程始于 2008 年，前身是柏林理工大学的一个研究性项目（Stratosphere）。2014 年被 Apache 孵化器所...
flink入门到精通视频教程
07-15
1.知识体系完备，从小白到大神各阶段读者均能学有所获。 2.生动形象，化繁为简，讲解通俗易懂。 3.结合工作实践及分析应用，培养解决实际问题的能力。 4.每一块知识点, 都有配套案例, 学习不再迷茫。 课程内容： 1....
flink入门资料
10-12
flink基本概念与部署，DataStreamAPI，Druid数据存储，Druid基本概念。Flink应用案例教程，Flink状态管理与恢复及容错设计与指标设计。
Flink：从入门到放弃
程序园@大Null
05-19 2139
文章目录前言一、Flink简介1. Flink组件栈2. Flink基石 前言 待补充 一、Flink简介 Apache Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行状态计算。 1. Flink组件栈 每一层所包含的组件都提供了特定的抽象，用来服务于上层组件： 物理部署层： Flink 支持本地运行、能在独立集群或者在被 YARN 管理的集群上运行， 也能部署在云上，该层主要涉及Flink的部署模式，目前Flink支持多种部署模式：本地、集群(Standalone、YARN)、云(G
flink.10 DataStream api execute mode（很重要）
笔生花的博客
09-06 439
一.概述 在此之前你需要了解:DataStream api 概述 DataStream API 支持不同的运行时执行模式(streaming/batch)，您可以根据用例的要求和作业的特征从中进行选择。 STREAMING DataStream API 有“经典”的执行行为，我们称之为 STREAMING执行模式。这应该用于需要连续增量处理并预计无限期保持在线的无限制作业,这是默认的执行模式. BATCH 这以一种更让人联想到 MapReduce 等批处理框架的方式执行作业。这应该用于您具有已
Flink源码篇-FlinkStreaming执行计划生成流程
进阶的成长之路
05-04 2043
无知不可怕,毁掉自己的是骄傲 1,示例 很多人使用Flink的时候有没有考虑过执行计划是如何生成的,例如Spark的RDD拓扑有向无环图是怎么生成的,打印出来的执行计划应该怎么理解,我们先看一个示例,执行以下System.out.println(env.getExecutionPlan()); { "nodes" : [ { "id" : 1, 图节点ID,也就是transform的ID "type" : "Source: 添加了一个source"...
【Flink】
m0_67239108的博客
05-05 133
是一个实时计算框架和分布式处理引擎，用于在无边界和有边界数据流上进行有状态的计算。Flink 能在所有常见集群环境中运行，并能以内存速度和任意规模进行计算。
Apache Flink从入门到放弃——Flink简介（一）
LXWalaz1s1s的博客
05-03 6551
Apache Flink是一个分布式大数据计算引擎，可以对有界的数据和无界的数据进行有状态的计算，可部署在各种集群环境中，对各种大小数据规模进行快速计算，本章节主要介绍下Flink的历史和由来以及框架基础。............
flink重温笔记（一）：Flink 基础入门
m0_60732994的博客
02-12 1485
最近发现 Flink 技术在实时数仓开发上占比越来越明显，希望通过抓紧复习，加强对 Flink 的理解和应用，提升自己实时数仓的开发能力，以下是今日整理的学习笔记，各种图像均按照自己理解重画，有疏漏的地方还请各位大佬指出，希望能和大家一起共同学习，互相进步。Tips：这是我的第一篇 CSDN 博客，后续会持续分享每日学习总结和心得，2024年大家一起加油！
毕设系统—智慧工地监控管理系统-可执行内含文档代码-可执行内含文档代码.zip
最新发布
07-28
毕设系统—智慧工地监控管理系统-可执行内含文档代码-可执行内含文档代码.zip
flink从入门到精通
09-16
关于Flink从入门到精通的学习路径可以分为以下几个步骤： 1. 学习Flink的基本概念和原理：了解Flink的核心概念，如数据流、转换操作、窗口、状态管理等。可以通过官方文档、教程和书籍进行学习。 2. 安装和配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿-瑞瑞

打赏不准超过你的一半工资哦~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值