关于flink:凭实力蝉联第一Flink-又双叒叕上榜啦

近期,Apache 软件基金会 2020 财年年度报告出炉,作为世界上最大的开源基金会,Apache 软件基金会治理着 2 亿多行代码,监督着 339+  Apache 我的项目。该报告回顾了 2020 财年基金会的次要成绩并对重大项目及重要事件进行盘点与总结。 其中,Flink 因为社区的参加和奉献在 Apache 我的项目中仍放弃着多项排名当先的记录: Mailing List 活跃度排名第一GitHub 访问量排名第二Commits 数排名第二与 2019 财年相比,Flink 邮件列表活跃度仍放弃 TOP 1,Commits 数排名由第三名回升至第二名,Github 访问量也有显著增长,在 Apache 我的项目中排名第二。 ▼ 以下为报告原文翻译 ▼ 往年是 Apache 软件基金会成立的第 21 个年头,从最后的仅 21 名创始人倒退至今,Apache 在报告中强调了其 “Apache 之道”(Apache Way)。报告中示意,正是这样一种社区驱动的 Apache 之道,促成了成千上万个开发者单干,使数百个我的项目走向成熟。报告还称,“地球上每个接入了互联网的国家都在应用 Apache 软件。” 2020 财年,Apache 软件基金会达成了以下次要成就: 增加了约 800 万行 Apache 代码,价值约 6 亿美元;总代码价值超过 200 亿美元;Apache 资料库中共治理着超过 2.27 亿行代码;选举了 34 名新的 ASF 集体成员,目前总计 813 名;超过 7,700 名代码提交者;206 个顶级社区,监督 339 个以上的 Apache 我的项目,以及数十个子项目和打算;9 个最新毕业的顶级我的项目;Apache 孵化器中目前有 45 个我的项目正在开发;apache.org 每周页面浏览量超过 3500 万;从 Apache 镜像下载的源代码大概有 2 PB;最沉闷的 Apache 我的项目前五名别离是:Kafka、Hadoop、Lucene、POI、ZooKeeper;提交次数排名前五的 Apache 我的项目别离是:Camel、Flink、Beam、HBase、Lucene Solr;按代码行排列的前五名 Apache 我的项目别离是:NetBeans、OpenOffice、Flex (combined)、Mynewt (combined)、Trafodion;2,892 个提交者在 174,889 次提交中更改了 60,132,710 行代码;12,413 人创立了 63,172 个新 issue;2,868 人敞开了 54,633 个 issue;19,396 位作者在 1,417 个邮件列表中针对 907,870 个主题发送了 2,137,560 封电子邮件;前 5 个最沉闷的邮件列表:Flink、Tomcat、Royale、Beam、Lucene Solr;2,045 个 git 存储库,蕴含约 250GB 代码和存储库历史记录;Apache HTTP Server 成立 25 周年(ASF 成立 21 周年);签订了 748 份集体贡献者许可协定(ICLA);签订了 33 份企业贡献者许可协定;签订了 40 项软件受权协定;以及ASF 间断 15 年负责 Google Summer of Code 的领导。点击下方链接可查看残缺报告~Flink 社区感激大家过来一年的参加和陪伴,Flink 成长的每一步都有你们的奉献,心愿将来也能持续与大家携手同行,迎接新挑战,发明新纪录! ...

August 5, 2020 · 1 min · jiezi

关于flink:单日课程超10万节VIPKID-如何通过实时计算提升上课体验

VIPKID 介绍VIPKID 是一家在线青少儿英语教育平台,成立七年以来,公司保持以赋能教育,启迪将来为使命,专一于一对一的线上教学模式,采纳 100% 的纯北美外教,学员遍布 63 个国家和地区。 截止目前,仅付费学生规模超 70 万人 ,单日一对一课量超 10 万节,顶峰时段课程并发最高达到 3.5 万节。领有笼罩了寰球 35 个国家的 5 条跨海专线,在 16 个国家、55 个城市实现数据中心传输节点布局,可能依据实时动静在一分钟内实现智能切换[1]。 外围业务场景次要场景介绍在一对一(一个老师和一个学生)模式的上课过程中,老师通过直播的模式以课件为辅助进行授课,互动的模式不仅包含直观的声音和视频还有聊天室以及在课件上写字划线拖动动作等,整个课程中波及多个组件模块。 各模块以协同依赖的形式提供服务,其中任意环节产生的事件对老师和学生都要做到可见和同步,如老师可看见学生在教室能力开始上课、学生可听见老师谈话、学生可看到老师翻页课件等能力持续失常上课直到完结。 在大规模网络教学中,流媒体实时互动直播和音讯实时数据传输重大依赖用户设施和网络,数据体量大,尤其咱们是跨海传输的状况下变得十分辣手,对于网络稳定性有着十分刻薄的要求。 与大班网课直播相比,1v1 更重视互动,所以对问题的容忍度极低,任何一方的问题都会影响上课体验。其中场景之一为当呈现网络等异样问题时,用户就会点击”Help“按钮进行求助,此时须要监课人员(以下简称“FM”,来自 Fireman 缩写)立即染指解决,这对服务人员的规模和操作实时性有较大的需要。 以后业务痛点目前在只有人工解决用户 Help 的模式下,因为日均 Help 申请量大(约占总课程的10%),人均监课量大,同时从接管到申请到监课人员染指解决问题也须要辗转多个流程,会有以下问题: 问题解决不及时,用户容易期待,阻断上课,带给用户体验差;人工解决效率低,课量减少以及大规模突发状况下,导致 FM 团队规模减少,须要更多人力;有些用户出了问题,没有分割监课人员的话,问题被暗藏;技术实现为了解决上文提到的业务痛点问题,通过各环节业务特征提取及梳理,咱们设计了一种通过实时计算来产出业务标签,并利用标签数据进行主动监课来解决用户 Help 的计划。下文将重点形容整个计划的技术实现细节:波及到数据体系建设、自动化业务零碎建设、外围问题与优化以及最终收益成果: 数据体系建设:介绍用于撑持整个实时计算的 Vlink 数据平台、以后场景下相干业务数据采集和业务标签数据计算,是业务实现的撑持;自动化业务零碎:介绍如何利用实时数据流来解决以后业务痛点;问题与优化:介绍实现过程中碰到的业务和技术问题以及解决方案;收益成果:介绍最终取得的收益成绩;数据体系建设整个数据体系建设的初衷是解决数据从哪里来、数据的业务逻辑是什么、如何计算、如何对立治理以及赋能更多场景,解决更多业务问题。 Vlink 数据平台:介绍一站式数据平台,提供数据接入明细:a.数据起源; b.数据的业务含意; c.数据打点法则,进步开发接入效率,解决上下游不明确问题; 业务数据采集:介绍以后场景下的业务数据采集;业务数据计算:介绍如何利用Flink来计算简单逻辑的业务数据;■ Vlink 数据平台Vlink 数据平台是基于在 Flink Streaming Job 开发过程中一些问题的反思后,借鉴服务端开发上线流程,以研发人员为核心的进步开发效率,升高保护老本为出发点而设计研发的零碎,并反对数据采集治理、打点接入治理、打点测试集成等性能。 次要性能点1.交互式运行作业 除 Flink Sql 外,业内对于 Streaming 类型的作业提交运行形式还是和官网提供的上传 Jar 包一样,打包 -> 期待并关注 -> 上传 -> 期待并关注 -> 运行。咱们联结运维团队,提供一键打包部署性能,可设置 AutoRun 在部署胜利后主动运行。 ...

August 4, 2020 · 2 min · jiezi

关于flink:Apache-Flink-Meetup-上海站精彩回顾附PPT下载

8月2日,往年首场线下 Apache Flink Meetup · 上海站圆满闭幕。久违的亲切脸孔,零距离交换互动以及标志性合照,还是原来的配方还是相熟的感觉!社区在尽力发明所有跟大家见面的可能! 本次上海站 Meetup,社区邀请了来自小红书、唯品会、英特尔、阿里巴巴的四位技术专家跟大家分享近期 Flink 的最新利用实际与最新社区动静。 Meetup 议题回顾:高能预警!Apache Flink Meetup · 上海站返场啦 流动亮点:唯品会批流交融的生产环境实际英特尔 Analytics Zoo 在 Flink 极客挑战赛中的利用案例分享Flink 在小红书实时平台中的利用Flink SQL 1.11 新性能与最佳实际▼合照▼ <关注公众号,回复“0802上海”即可获取直播回看链接及流动 PPT 合集> 关注 Flink 中文社区,获取更多技术干货

August 4, 2020 · 1 min · jiezi

关于flink:Flink生成dot文件的可视化执行计划图工具类使用

1.啥也不说,先上工具类代码: import com.google.gson.Gson;import java.util.HashMap;import java.util.Map;import java.util.regex.Matcher;import java.util.regex.Pattern;public class FlinkUtils { private static class FlinkPlanEdge { private int id; private String ship_strategy; @SuppressWarnings("unused") private String side; public int getId() { return id; } public String getShip_strategy() { return ship_strategy; } } private static class FlinkPlanNode { private static final FlinkPlanEdge[] NO_EDGES = new FlinkPlanEdge[0]; private int id; private String type; @SuppressWarnings("unused") private String pact; private String contents; private int parallelism; private FlinkPlanEdge[] predecessors; public int getId() { return id; } public String getType() { return type; } public String getContents() { return contents; } public int getParallelism() { return parallelism; } public FlinkPlanEdge[] getPredecessors() { if (predecessors == null) { return NO_EDGES; } else { return predecessors; } } } private static class FlinkPlan { private FlinkPlanNode[] nodes; public FlinkPlanNode[] getNodes() { return nodes; } } /** * Given a JSON representation of a Flink Topology (from StreamExecutionEnvironment#getExecutionPlan), convert it to * a standard .dot format suitable for visualizing with OmniGraffle and other programs. * * See http://www.graphviz.org/doc/info/lang.html See http://www.graphviz.org/doc/info/attrs.html * * @param plan * JSON version of plan * @return dot format graph. */ public static String planToDot(String plan) { FlinkPlan flinkPlan = new Gson().fromJson(plan, FlinkPlan.class); StringBuilder result = new StringBuilder("digraph G {\n"); // Keep track of iteration sources, which are implicit. So we map from // the iteration number to the source id Map<Integer, Integer> iterationMap = new HashMap<Integer, Integer>(); final Pattern ITERATION_SOURCE_NAME = Pattern.compile("IterationSource\\-(\\d+)"); final Pattern ITERATION_SINK_NAME = Pattern.compile("IterationSink\\-(\\d+)"); final Pattern SOURCE_OR_SINK_NAME = Pattern.compile("(Source|Sink): (.*)"); FlinkPlanNode[] nodes = flinkPlan.getNodes(); for (FlinkPlanNode node : nodes) { Matcher m = SOURCE_OR_SINK_NAME.matcher(node.getType()); boolean isSourceOrSink = m.matches(); String nodeName = isSourceOrSink ? m.group(2) : node.getContents(); String nodeShape = isSourceOrSink ? "box" : "ellipse"; boolean isIterationSourceOrSink = ITERATION_SOURCE_NAME.matcher(node.getType()) .matches() || ITERATION_SINK_NAME.matcher(node.getType()).matches(); String fillColor = isSourceOrSink || isIterationSourceOrSink ? "8EFF4C" : "FFFFFF"; result.append( String.format(" %d [shape=\"%s\", fillcolor=\"#%s\", label=\"%s (%d)\"];\n", node.getId(), nodeShape, fillColor, nodeName, node.getParallelism())); m = ITERATION_SOURCE_NAME.matcher(node.getType()); if (m.matches()) { // Map from iteration number to the source node id iterationMap.put(Integer.parseInt(m.group(1)), node.getId()); } } // Now dump out the edges // 1 -> 2 [label = "blah"]; for (FlinkPlanNode node : nodes) { int nodeId = node.getId(); FlinkPlanEdge[] edges = node.getPredecessors(); for (FlinkPlanEdge edge : edges) { result.append(String.format(" %d -> %d [label = \"%s\"];\n", edge.getId(), nodeId, edge.getShip_strategy())); } // Now check if this node is an iteration sink. If so, add an explicit edge // from it to the corresponding source node. Matcher m = ITERATION_SINK_NAME.matcher(node.getType()); if (m.matches()) { int iterationID = Integer.parseInt(m.group(1)); result.append(String.format(" %d -> %d [label = \"ITERATION\"];\n", node.getId(), iterationMap.get(iterationID))); } } result.append("}\n"); return result.toString(); }}2.在flink中应用 ...

August 4, 2020 · 3 min · jiezi

关于flink:从-19-到-111聊聊-PyFlink-的核心功能演进附-Demo-代码

Flink 1.11 正式公布曾经三周了,其中最吸引我的个性就是 Hive Streaming。刚巧 Zeppelin-0.9-preview2 也在前不久公布了,所以就写了一篇 Zeppelin 上的 Flink Hive Streaming 的实战解析。本文次要从以下几局部跟大家分享: Hive Streaming 的意义Checkpoint & Dependency写入 KafkaHive Streaming SinkHive Streaming SourceHive Temporal TableHive Streaming 的意义很多同学可能会好奇,为什么 Flink 1.11 中,Hive Streaming 的位置这么高?它的呈现,到底能给咱们带来什么? 其实在大数据畛域,始终存在两种架构  Lambda 和 Kappa: Lambda 架构——流批拆散,静态数据通过定时调度同步到 Hive 数仓,实时数据既会同步到 Hive,也会被实时计算引擎生产,这里就引出了一点问题。数据口径问题离线计算产出延时太大数据冗余存储Kappa架构——全副应用实时计算来产出数据,历史数据通过回溯音讯的生产位点计算,同样也有很多的问题,毕竟没有一劳永逸的架构。消息中间件无奈保留全副历史数据,同样数据都是行式存储,占用空间太大实时计算计算历史数据力不从心无奈进行 Ad-Hoc 的剖析为了解决这些问题,行业内推出了实时数仓,解决了大部分痛点,然而还是有些中央力不从心。比方波及到历史数据的计算怎么办?我想做 Ad-Hoc 的剖析又怎么玩?所以行业内当初都是实时数仓与离线数仓并行存在,而这又带来了更多的问题:模型须要多份、数据产出不统一、历史数据的计算等等 。 而 Hive Streaming 的呈现就能够解决这些问题!再也不必多套模型了;也不须要同一个指标因为波及到历史数据,写一遍实时 SQL 再写一遍离线 SQL;Ad-Hoc 也能做了,怎么做?读 Hive Streaming 产出的表就行! 接下来,让咱们从参数配置开始,接着流式的写入 Hive,再到流式的读取 Hive 表,最初再 Join 上 Hive 维表吧。这一整套流程都体验后,想必大家对 Hive Streaming 肯定会有更深刻的理解,更可能领会到它的作用。 Checkpoint & Dependency因为只有在实现 Checkpoint 之后,文件才会从 In-progress 状态变成 Finish 状态,所以,咱们须要正当的去配置 Checkpoint,在 Zeppelin 中配置 Checkpoint 很简略。 ...

August 4, 2020 · 2 min · jiezi

关于flink:BIGO-实时计算平台建设实践

BIGO 寰球音视频业务对数据的实时能力要求越来越高,数据分析师心愿多维度实时看到新增用户、沉闷用户等业务数据以便尽快把握市场动向,机器学习工程师心愿实时拿到用户的浏览、点击等数据而后通过在线学习将用户偏好疾速退出到模型中,以便给用户推送以后最感兴趣的内容,APP 开发工程师心愿可能实时监控 APP 关上的成功率、解体率。 这些实时数据的能力都要依附实时计算平台来提供。从业界来看,实时化的趋势正在减速,本文将介绍 BIGO 基于 Flink 的实时计算平台的建设教训和成绩。 平台介绍BIGO 实时计算的倒退大略分为两个阶段,在 2018 年之前,实时场景还比拟少,实时的作业数量也不多,过后次要采纳 Spark Streaming 来反对。从 2018 年开始,在综合思考了 Flink 绝对于 Spark Streaming 的劣势之后,决定将实时计算平台切换到基于 Flink 的技术路线上来。通过近两年的倒退,BIGO 实时计算平台日趋完善,根本反对了公司内支流的实时计算场景,下图是 BIGO 实时计算平台的架构图: 实时计算的数据起源可分为两大类,一类是用户在 APP 或者浏览器里的浏览、点击等行为日志,通过 kafka 收集进入实时计算;另一类是用户的行为产生的关系型数据库里记录的扭转,这些改变产生的 biglog 被 BDP 抽取进入实时计算。 从图中能够看出,BIGO 实时计算平台底层基于 Yarn 来做集群资源管理,借助于 Yarn 的散布式调度能力,实现大规模集群下的调度。实时平台的计算引擎在开源 Flink 的根底上,为适配 BIGO 的场景进行了非凡的定制及开发。实时平台的下层是 BIGO 自研的一站式开发平台 BigoFlow,在这里,用户能够不便的进行作业的开发、调试以及监控运维。BigoFlow 提供了欠缺的 SQL 开发能力、自动化监控配置能力以及日志主动收集、查问能力,让用户仅须要一条 SQL,就能够实现一个业务作业。它具备以下性能: 提供了弱小的 SQL 编辑器,能够进行语法查看及主动提醒。能够对接公司所有的数据源及数据存储,省去了业务方自定义的工作。日志主动收集到 ES 里,用户能够不便的检索和查问,能够疾速的定位谬误。作业要害指标主动对接到公司的监控告警平台,用户不必再本人配置。收集所有作业的资源应用状况,主动进行剖析,帮忙辨认、治理不合理作业。实时计算出来的后果依据业务的需要,会寄存到不同的存储中。ETL 类作业的后果通常会入库到 Hive中,须要进行 Adhoc 查问的数据通常会放到 ClickHouse 外面。监控告警等类型的作业能够间接把后果输入到告警平台的 Prometheus 数据库里,供告警平台间接应用。 ...

August 3, 2020 · 2 min · jiezi

关于flink:从-19-到-111聊聊-PyFlink-的核心功能演进附-Demo-代码

1.PyFlink 的发展史 1.1、v1.8.xFlink 在 1.8 版本的时候就曾经提供 Python API,只在 Datase/Stream 上提供反对。存在一些问题,比方:Table API 不反对 Python。两套各自独立实现的一个 Python API。底层实现是 JPython,JPython 无奈反对 Python3.x。1.2、v1.9.x2019 年 8 月公布。反对 Python Table API。1.3、v1.10.x2020 年 2 月公布。提供了 Python UDF 的反对。提供 UDF 的依赖治理。1.4、将来倒退提供 Pandas UDF 的反对。提供用户自定义的一些 UDF Metrics。ML API。在易用性方面,提供 SQL DDL 反对 Python UDF。在前面的一些版本中,咱们也心愿越来越多的人可能参加到 PyFlink 的奉献和开发中去。2.PyFlink 外围性能及原理介绍PyFlink 外围性能将次要从每个版本的划分来跟大家进行介绍,第1个 PyFlink 1.9 版本外面提供 Python Table API 的反对,而后是 PyFlink 1.10 外面提供了 Python UDF 还有相干依赖治理,最初 1.11 版本外面提供了 Pandas UDF 和用户自定义的 Metrics。 ...

July 29, 2020 · 4 min · jiezi

关于flink:Flink-111-SQL-使用攻略

7 月 6 日,Apache Flink 1.11 正式公布。从 3 月初进行性能布局到 7 月初正式发版,1.11 用将近 4 个月的工夫重点优化了 Flink 的易用性问题,晋升用户的生产应用体验。 SQL 作为 Flink 中公认的外围模块之一,对推动 Flink 流批一体性能的欠缺至关重要。在 1.11 中,Flink SQL 也进行了大量的加强与欠缺,开发大性能 10 余项,不仅扩充了利用场景,还简化了流程,上手操作更简略。其中,值得注意的改变包含: 默认 Planner 曾经切到 Blink planner 上。引入了对 CDC(Change Data Capture,变动数据捕捉)的反对,用户仅用几句简略的 SQL 即可对接 Debezium 和 Canal 的数据源。离线数仓实时化,用户可不便地应用 SQL 将流式数据从 Kafka 写入 Hive 等。Flink SQL 演变随着流计算的倒退,挑战不再仅限于数据量和计算量,业务变得越来越简单,开发者可能是资深的大数据从业者、初学 Java 的爱好者,或是不懂代码的数据分析者。如何进步开发者的效率,升高流计算的门槛,对推广实时计算十分重要。SQL 是数据处理中应用最宽泛的语言,它容许用户简明扼要地展现其业务逻辑。Flink 作为流批一体的计算引擎,致力于提供一套 SQL 反对全副利用场景,Flink SQL 的实现也齐全遵循 ANSI SQL 规范。之前,用户可能须要编写上百行业务代码,应用 SQL 后,可能只须要几行 SQL 就能够轻松搞定。Flink SQL 的倒退大略经验了以下阶段: ...

July 28, 2020 · 6 min · jiezi

关于flink:Flink-111-SQL-使用攻略

7 月 6 日,Apache Flink 1.11 正式公布。从 3 月初进行性能布局到 7 月初正式发版,1.11 用将近 4 个月的工夫重点优化了 Flink 的易用性问题,晋升用户的生产应用体验。 SQL 作为 Flink 中公认的外围模块之一,对推动 Flink 流批一体性能的欠缺至关重要。在 1.11 中,Flink SQL 也进行了大量的加强与欠缺,开发大性能 10 余项,不仅扩充了利用场景,还简化了流程,上手操作更简略。其中,值得注意的改变包含: 默认 Planner 曾经切到 Blink planner 上。引入了对 CDC(Change Data Capture,变动数据捕捉)的反对,用户仅用几句简略的 SQL 即可对接 Debezium 和 Canal 的数据源。离线数仓实时化,用户可不便地应用 SQL 将流式数据从 Kafka 写入 Hive 等。Flink SQL 演变随着流计算的倒退,挑战不再仅限于数据量和计算量,业务变得越来越简单,开发者可能是资深的大数据从业者、初学 Java 的爱好者,或是不懂代码的数据分析者。如何进步开发者的效率,升高流计算的门槛,对推广实时计算十分重要。SQL 是数据处理中应用最宽泛的语言,它容许用户简明扼要地展现其业务逻辑。Flink 作为流批一体的计算引擎,致力于提供一套 SQL 反对全副利用场景,Flink SQL 的实现也齐全遵循 ANSI SQL 规范。之前,用户可能须要编写上百行业务代码,应用 SQL 后,可能只须要几行 SQL 就能够轻松搞定。Flink SQL 的倒退大略经验了以下阶段: ...

July 28, 2020 · 6 min · jiezi

关于flink:Flink-使用大状态时的一点优化

通过本文你能 get 到以下几点: Flink 内应用大状态时,该如何配置?常见的负载平衡策略有哪些?Flink 源码中在抉择 RocksDB 状态磁盘时,存在的问题。一些解决方案,并剖析了每种计划的利弊。一、为什么要优化?(优化背景)Flink 反对多种 StateBackend,当状态比拟大时目前只有 RocksDBStateBackend 可供选择。 RocksDB 是基于 LSM 树原理实现的 KV 数据库,LSM 树读放大问题比较严重,因而对磁盘性能要求比拟高,强烈建议生产环境应用 SSD 作为 RocksDB 的存储介质。然而有些集群可能并没有配置 SSD,仅仅是一般的机械硬盘,当 Flink 工作比拟大,且对状态拜访比拟频繁时,机械硬盘的磁盘 IO 可能成为性能瓶颈。在这种状况下,该如何解决此瓶颈呢? 应用多块硬盘来分担压力RocksDB 应用内存加磁盘的形式存储数据,当状态比拟大时,磁盘占用空间会比拟大。如果对 RocksDB 有频繁的读取申请,那么磁盘 IO 会成为 Flink 工作瓶颈。 强烈建议在 flink-conf.yaml 中配置 state.backend.rocksdb.localdir 参数来指定 RocksDB 在磁盘中的存储目录。当一个 TaskManager 蕴含 3 个 slot 时,那么单个服务器上的三个并行度都对磁盘造成频繁读写,从而导致三个并行度的之间互相争抢同一个磁盘 io,这样必然导致三个并行度的吞吐量都会降落。 庆幸的是 Flink 的 state.backend.rocksdb.localdir 参数能够指定多个目录,个别大数据服务器都会挂载很多块硬盘,咱们冀望同一个 TaskManager 的三个 slot 应用不同的硬盘从而缩小资源竞争。具体参数配置如下所示: state.backend.rocksdb.localdir: /data1/flink/rocksdb,/data2/flink/rocksdb,/data3/flink/rocksdb,/data4/flink/rocksdb,/data5/flink/rocksdb,/data6/flink/rocksdb,/data7/flink/rocksdb,/data8/flink/rocksdb,/data9/flink/rocksdb,/data10/flink/rocksdb,/data11/flink/rocksdb,/data12/flink/rocksdb留神:务必将目录配置到多块不同的磁盘上,不要配置单块磁盘的多个目录,这里配置多个目录是为了让多块磁盘来分担压力。 如下图所示是笔者测试过程中磁盘的 IO 使用率,能够看出三个大状态算子的并行度别离对应了三块磁盘,这三块磁盘的 IO 均匀使用率都放弃在 45% 左右,IO 最高使用率简直都是 100%,而其余磁盘的 IO 均匀使用率为 10% 左右,绝对低很多。由此可见应用 RocksDB 做为状态后端且有大状态的频繁读写操作时,对磁盘 IO 性能耗费的确比拟大。 ...

July 27, 2020 · 3 min · jiezi

关于flink:小白从零开始学ApacheFlink

1. Apache Flink 介绍起源:http://www.54tianzhisheng.cn/...Apache Flink 是近年来越来越风行的一款开源大数据计算引擎,它同时反对了批处理和流解决,也能用来做一些基于事件的利用。应用官网的一句话来介绍 Flink 就是 “Stateful Computations Over Streams”。 首先 Flink 是一个纯流式的计算引擎,它的根本数据模型是数据流。流能够是无边界的有限流,即个别意义上的流解决。也能够是有边界的无限流,这样就是批处理。因而 Flink 用一套架构同时反对了流解决和批处理。其次,Flink 的一个劣势是反对有状态的计算。如果解决一个事件(或一条数据)的后果只跟事件自身的内容无关,称为无状态解决;反之后果还和之前解决过的事件无关,称为有状态解决。略微简单一点的数据处理,比如说根本的聚合,数据流之间的关联都是有状态解决。 无穷数据集:无穷的继续集成的数据汇合有界数据集:无限不会扭转的数据汇合那么那些常见的无穷数据集有哪些呢? 用户与客户端的实时交互数据利用实时产生的日志金融市场的实时交易记录…数据运算模型有哪些呢: 流式:只有数据始终在产生,计算就继续地进行批处理:在事后定义的工夫内运行计算,当实现时开释计算机资源[外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-i3IYaQm9-1595768814163)(https://ws3.sinaimg.cn/large/...] 2. What is Flink?[外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-1KK2dXk1-1595768814167)(https://ws3.sinaimg.cn/large/...] [外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-8uDNlF7v-1595768814169)(https://ws2.sinaimg.cn/large/...] [外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-W7z6hQI9-1595768814171)(https://ws4.sinaimg.cn/large/...] [外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-4mHt3Iq8-1595768814173)(/Applications/Typora.app/Contents/Resources/TypeMark/Docs/img/006tNbRwly1fw6nu5yishj31kw0w04cm.jpg)] [外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-qGWVgGhG-1595768814174)(https://ws2.sinaimg.cn/large/...] 从下至上: 1、部署:Flink 反对本地运行、能在独立集群或者在被 YARN 或 Mesos 治理的集群上运行, 也能部署在云上。 2、运行:Flink 的外围是分布式流式数据引擎,意味着数据以一次一个事件的模式被解决。 3、API:DataStream、DataSet、Table、SQL API。 4、扩大库:Flink 还包含用于简单事件处理,机器学习,图形处理和 Apache Storm 兼容性的专用代码库。 3. Flink 数据流编程模型1. 形象级别[外链图片转存失败,源站可能有防盗链机制,倡议将图片保留下来间接上传(img-yZWEXSka-1595768814175)(https://ws2.sinaimg.cn/large/...] 最底层提供了有状态流。它将通过 过程函数(Process Function)嵌入到 DataStream API 中。它容许用户能够自在地解决来自一个或多个流数据的事件,并应用统一、容错的状态。除此之外,用户能够注册事件工夫和处理事件回调,从而使程序能够实现简单的计算。DataStream / DataSet API 是 Flink 提供的外围 API ,DataSet 解决有界的数据集,DataStream 解决有界或者无界的数据流。用户能够通过各种办法(map / flatmap / window / keyby / sum / max / min / avg / join 等)将数据进行转换 / 计算。Table API 是以 表 为核心的申明式 DSL,其中表可能会动态变化(在表白流数据时)。Table API 提供了例如 select、project、join、group-by、aggregate 等操作,应用起来却更加简洁(代码量更少)。你能够在表与 DataStream/DataSet 之间无缝切换,也容许程序将 Table API 与 DataStream 以及 DataSet 混合应用。 ...

July 26, 2020 · 8 min · jiezi

关于flink:阿里巴巴大规模应用-Flink-的实战经验常见问题诊断思路

1.常见运维问题1.1 作业运行环境本文中介绍的作业运行环境次要是在阿里巴巴团体内,构建在 Hadoop 生态之上的 Flink 集群,蕴含 Yarn、HDFS、ZK 等组件;作业提交模式采纳 yarn per-job Detached 模式。 第1步,作业提交是通过 Flink Yarn Client,将用户所写的作业代码以及编译好的 jar 包上传到 HDFS 上;第2步 Flink Client 与 Yarn ResourceManager 进行通信,申请所须要的的 Container 资源;第3步,ResourceManager 收到申请后会在集群中的 NodeManager 调配启动 AppMaster 的 Container 过程,AppMaster 中蕴含 Flink JobManager 模块和 Yarn 通信的 ResourceManager 模块;第4步,在 JobManager 中依据作业的 JobGraph 生成 Execution Graph,ResourceManager 模块向 Yarn 的 ResourceManager 通信,申请 TaskManager 须要的 container 资源,这些 container 由 Yarn 的 NodeManger 负责拉起。每个 NodeManager 从 HDFS 上下载资源,启动 Container(TaskManager),并向 JobManager 注册;JobManger 会部署不同的 task 工作到各个 TaskManager 中执行。■ 资源申请形式1. 指定资源大小提交时,指定每个 TaskManager、JobManager 应用多少内存,CPU 资源。2. 细粒度资源管制阿里巴巴团体内次要采纳 ResourceSpec 形式指定每个 Operator 所需的资源大小,根据 task 的并发聚合成 container 资源向 Yarn 申请。 ...

July 24, 2020 · 2 min · jiezi

关于flink:Flink-Weekly-每周社区动态更新

大家好,本文为 Flink Weekly 的第二十三期,由蒋晓峰、李本超独特整顿及 Review。本期次要内容包含:近期社区开发进展、邮件问题答疑、Flink 最新社区动静及技术文章举荐等。 Flink 开发进展Flink 社区近期开发最新动静将从 Release、DEV、FLIP、Discuss、Others 五局部跟大家分享。 RELEASE■ 1.11.1 版本的投票曾经通过,行将公布。该版本涵盖了比拟多重要的 Bugfix,倡议尝试 1.11.0 版本的用户都间接切换到这个版本。 [1]http://apache-flink-mailing-l... DEV■ Chenqin 发动了反对 Thrift Format 的探讨,目前看该个性还是比拟受欢迎的,而且的确有些场景是须要的。之前也有一个相干的 PR[3],社区心愿能够基于这个 PR 来持续推动一下这个工作。 [2]http://apache-flink-mailing-l...[3] https://github.com/apache/fli...  FLIP■ [FLIP-128] 伍翀发动 Refactor Descriptor API to register connectors in Table API 的提案,改良 Table API 中的“Connect API”,即用户用来在环境中形容/注册表的 API。 自 1.5.0 起 Flink 引入 Descriptor API 来配置和有效化 TableSources/TableSinks,即 TableEnvironment#connect API。以后的 Descriptor API 有诸多问题包含社区关注最新版本中的新 SQL DDL 性能。SQL DDL 通过精心设计具备许多丰盛的性能,然而 Descriptor API 短少许多要害性能例如计算列、主键、分区键等;以后连接器必须实现相应的描述符(例如 new Kafka())能力应用 “connect” API,心愿在没有相应描述符的状况下注册连接器,简化连接器的开发并且代替 registerTableSource/Sink;Descriptor API 和 SQL DDL 的根底实现不同,保护两个不同的代码门路十分低廉。 ...

July 24, 2020 · 3 min · jiezi

关于flink:Demo-示例如何原生的在-K8s-上运行-Flink

Kubernetes 简介什么是 Kubernetes?Kubernetes 置信大家都比拟相熟,近两年大家都在探讨云原生的话题,探讨 Kubernetes。那么什么是 Kubernetes 呢? K8s 是一个资源管理零碎。如果大家对 Yarn、 Mesos 相熟,假如给定一批裸的物理机,将资源管理零碎部署下来之后,能够在此之上基于它的 API 或者 SDK 开发一些分布式软件或者应用程序。例如能够在 Yarn 上开发传统的 MapReduce,在 K8s 上能够开发一些分布式的 Web Server,或者是大数据计算工作等等。 K8s 是一个容器编排零碎。不同于传统的 Yarn,K8s 在所有的过程运行过程中,是全副基于容器化的,但这里的容器并不只是单纯的 Docker 容器,它也包含 Rocket 等其余相干的隔离措施。如果在生产环境中要求比拟高的话,可能会有一些平安容器,比方 Kata Containers 等等。K8s 在 Slave 上部署的应用程序,都是用容器化的形式去做散发和治理,同时用容器化的技术做隔离。 K8s 是一个自动化运维零碎。它是一个申明式的 API,咱们只须要通知 K8s 集群须要创立一个 Deployment,设置的正本数量,须要达到一个什么样的状态,调度零碎也就是 K8s 就会帮忙咱们维持状态,直到达到设置的状态为止。如果两头产生了一些 failover 或者产生了一些失败,它会主动地将工作迁徙到其余的机器上,来满足以后的调度。 云原生。目前简直所有的云厂商都曾经提供了 K8s 服务反对,包含国内的阿里、国内上的 Amazon、Google 等等,包含传统的微软都曾经提供了对于 K8s 的 Managed 服务或者是 Unmanaged 服务。随着目前 Lambda 表达式或者 Function 计算的利用, Serverless 形式也变得更加风行。除了传统的部署小集群以外,通过云产生一个 manager,构建一个大的 Serverless 集群,而后用户按需进行计算资源付费,这也是一种新的模式。 ...

July 24, 2020 · 5 min · jiezi

关于flink:高能预警Apache-Flink-Meetup-上海站返场啦

近期,Flink 社区上线了一系列好玩乏味又干货十足的流动。错过的小伙伴能够看这里:如果您是 Flink 爱好者想疾速上手入门,Flink 极客训练营帮您从0到1学会 Flink;如果您对挑战自我解决难题感兴趣,Flink 极客挑战赛邀您一起挑战疫情防控的世界级难题。 Flink 极客训练营第二期预约:https://page.aliyun.com/form/...Flink 极客挑战赛详情: https://tianchi.aliyun.com/sp...然而,有同学说都是线上流动都是直播,线下 Meetup 什么时候能安顿? 小松鼠作为宠粉口头派,安顿,立马就给大家安顿!8月2日,Flink 社区邀请来自英特尔、小红书、唯品会、蚂蚁金服以及阿里巴巴的五位技术专家齐聚上海,线下跟大家分享近期 Flink 的最新利用实际与最新社区动静。 流动工夫: 2020年8月2日 13:00-17:30流动地点: 上海长宁金钟路凌空SOHO-携程总部12号楼11层 ■ 本次 Meetup 亮点: 大咖星散,来自英特尔、小红书、唯品会、蚂蚁金服、阿里巴巴的5位一线技术专家齐聚魔都,与您分享探讨 Flink 社区最新利用与社区动向。爆款话题,聚焦流批一体的生产环境利用、Flink SQL 1.11 新性能、机器学习、小红书实时平台利用、蚂蚁金服风控教训等精彩话题。社区交换,汇聚技术行业的精英人才,碰撞思维交换业界最新动静。多重大礼,报名加入,就有机会取得超多 Flink 独家定制的酷炫周边!8月2日下午 13:00 - 17:30,Apache Flink Meetup 上海站期待您的到来!本次 Meetup 在线下举办同时进行在线直播,会场限额 100 人,扫描下方二维码或点击报名链接即可报名,感兴趣的同学快来抢前排~ 《批流交融在唯品会的实际利用》王新春 | 唯品会 数据平台实时团队高级架构师 嘉宾简介:王新春,唯品会数据平台实时团队高级架构师。次要负责实时计算平台、机器学习平台、实时数据荡涤和实时报表等业务;在退出唯品会之前,是美团点评(原公众点评)数据平台高级架构师;从零开始搭建实时计算平台以及数据平台工具体系开发和建设等工作。 演讲简介:流式数据处理和批数据处理的体系深度交融,局部数据加工和打宽间接在流数据中解决,并作为批处理或者 OLAP 引擎(Spark SQL/Presto/ClickHouse)等的输出,以达到数据口径对立,并且升高批处理的资源耗费的指标。 具体的实际包含:应用 Flink 做流量数据实时 ETL;Flink 实时入仓 MySQL 数据;应用 Flink 加工实时宽表和实时轻度汇总层数据,并提供给离线宽表、举荐算法和数据产品等应用。 《Analytics Zoo 在 Flink 极客挑战赛中的利用》宋佳明 | 英特尔 机器学习工程师 嘉宾简介:开源我的项目 Analytics Zoo 的重要贡献者,在机器学习、大数据、常识图谱等畛域有超过2年的教训。 ...

July 23, 2020 · 1 min · jiezi

关于flink:专治数仓疑难杂症美团点评-Flink-实时数仓应用经验分享

实时数仓建设目标解决传统数仓的问题实时数仓是一个很容易让人产生混同的概念。实时数仓自身仿佛和把 PPT 彩色的背景变得更白一样,从传统的教训来讲,咱们认为数仓有一个很重要的性能,即可能记录历史。通常,数仓都是心愿从业务上线的第一天开始有数据,而后始终记录到当初。 但实时处理技术,又是强调以后解决状态的一门技术,所以咱们认为这两个绝对对抗的计划重叠在一起的时候,它注定不是用来解决一个比拟宽泛问题的一种计划。于是,咱们把实时数仓建设的目标定位为解决因为传统数据仓库数据时效性低解决不了的问题。 因为这个特点,咱们给定了两个准则: 传统数仓能解决的问题,实时数仓就不解决了。比方上个月的一些历史的统计,这些数据是不会用实时数仓来建设的。问题自身就不太适宜用数仓来解决,也不必实时数仓解决。比方业务性很强的需要,或者是对时效性要求特地高的需要。这些需要咱们也不倡议通过实时数仓这种形式来进行解决。当然为了让咱们整个零碎看起来像是一个数仓,咱们还是给本人提了一些要求的。这个要求其实跟咱们建设离线数仓的要求是一样的,首先实时的数仓是须要面向主题的,而后具备集成性,并且保障绝对稳固。 离线数仓和实时数仓的区别在于离线数据仓库是一个保留历史累积的数据,而咱们在建设实时数仓的时候,咱们只保留上一次批处理到以后的数据。这个说法十分的拗口,然而实际上操作起来还是蛮轻松的。 通常来讲解决方案是保留大略三天的数据,因为保留三天的数据的话,能够稳固地保障两天残缺的数据,这样就能保障,在批处理流程还没有解决完昨天的数据的这段间隙,仍然可能提供一个残缺的数据服务。 实时数仓的利用场景 实时 OLAP 剖析OLAP 剖析自身就非常适合用数仓去解决的一类问题,咱们通过实时数仓的扩大,把数仓的时效性能力进行晋升。甚至可能在剖析层面上都不必再做太多革新,就能够使原有的 OLAP 剖析工具具备剖析实时数据的能力。 实时数据看板这种场景比拟容易接受,比方天猫双11的实时大屏滚动展现外围数据的变动。实际上对于美团来讲,不光有促销上的业务,还有一些次要的门店业务。对于门店的老板而言,他们可能在日常的每一天中也会很关怀本人当天各个业务线上的销售额。 实时特色实时特色指通过汇总指标的运算来对商户或者用户标记上一些特色。比方屡次购买商品的用户后盾会断定为优质用户。另外,商户销售额稿,后盾会认为该商户商的热度更高。而后,在做实时精准经营动作时可能会优先思考相似的门店或者商户。 实时业务监控美团点评也会对一些外围业务指标进行监控,比如说当线上呈现一些问题的时候,可能会导致某些业务指标降落,咱们能够通过监控尽早发现这些问题,进而来缩小损失。 如何建设实时数仓实时数仓概念映射咱们通过离线数仓开发和实时数仓开发的对应关系表,帮忙大家疾速清晰的了解实时数仓的一些概念。 编程形式离线开发最常见的计划就是采纳 Hive SQL 进行开发,而后加上一些扩大的 udf 。映射到实时数仓里来,咱们会应用 Flink SQL ,同样也是配合 udf 来进行开发。 作业执行层面离线解决的执行层面个别是 MapReduce 或者 Spark Job ,对应到实时数仓就是一个继续一直运行的 Flink Streaming 的程序。 数仓对象层面离线数仓实际上就是在应用 Hive 表。对于实时数仓来讲,咱们对表的形象是应用 Stream Table 来进行形象。 物理存储离线数仓,咱们少数状况下会应用 HDFS 进行存储。实时数仓,咱们更多的时候会采纳像 Kafka 这样的音讯队列来进行数据的存储。 实时数仓的整体架构在此之前咱们做过一次分享,是对于为什么抉择 Flink 来做实时数仓,其中重点介绍了技术组件选型的起因和思路,具体内容参考《美团点评基于 Flink 的实时数仓建设实际》。本文分享的次要内容是围绕数据自身来进行的,上面是咱们目前的实时数仓的数据架构图。 《美团点评基于 Flink 的实时数仓建设实际》https://tech.meituan.com/2018/10/18/meishi-data-flink.html 从数据架构图来看,实时数仓的数据架构会跟离线数仓有很多相似的中央。比方分层构造;比如说 ODS 层,明细层、汇总层,乃至应用层,它们命名的模式可能都是一样的。尽管如此,实时数仓和离线数仓还是有很多的区别的。 跟离线数仓次要不一样的中央,就是实时数仓的档次更少一些。 以咱们目前建设离线数仓的教训来看,数仓的第二层远远不止这么简略,个别都会有一些轻度汇总层这样的概念,其实第二层会蕴含很多层。另外一个就是应用层,以往建设数仓的时候,应用层其实是在仓库外部的。在应用层建设好后,会建同步工作,把数据同步到利用零碎的数据库里。 在实时数仓外面,所谓 APP 层的利用表,实际上就曾经在利用零碎的数据库里了。上图,尽管画了 APP 层,但它其实并不算是数仓里的表,这些数据实质上曾经存过来了。 ...

July 22, 2020 · 2 min · jiezi

关于flink:为什么-Flink-无法实时写入-MySQL

作者:孙金城 摘要:本文为 Flink 生产环境利用中的疑难分析,Flink 无奈实时写入 MySQL 是初学者常见问题之一,由社区同学罗鹏程提出,Apache Flink PMC 孙金城(金竹)老师分享该问题的解决方案及剖析思路。次要分为以下四局部: 问题形容解决思路起因分析触类旁通Tips:更多生产环境问题交换及反馈请订阅 Flink 中文邮件列表~ 问题形容Flink 1.10 应用 flink-jdbc 连接器的形式与 MySQL 交互,读数据和写数据都能实现,然而在写数据时,发现 Flink 程序执行结束之后,能力在 MySQL 中查问到插入的数据。即,尽管是流计算,但却不能实时的输入计算结果? 相干代码片段: JDBCAppendTableSink.builder() .setDrivername("com.mysql.jdbc.Driver") .setDBUrl("jdbc:mysql://localhost/flink") .setUsername("root") .setPassword("123456") .setParameterTypes( BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO) .setQuery("insert into batch_size values(?,?)") .build()如何解决?Flink 1.10 这个问题是晓得一秒钟,不知磨洋工的 Case,在初学时候非常容易遇上,那么真的是 Flink 不能实时写入 MySQL 吗?当然不是,下面代码根底之上简略的加上一行,就解决问题了: ....setBatchSize(1) //将写入MySQL的buffer大小为1。..起因分析那么问题尽管解决了,根本原因是个啥呢?兴许你看到这里会说,这问题很显著,就是 Flink 设计 JDBC Sink 的时候出于性能因素思考,对写入 buffer 做了默认值设置。 没错,这一点你说的很对,在 Flink 1.10 中 JDBC OutputFormat 的基类 AbstractJDBCOutputFormat 外面和这相干的变量 DEFAULT_FLUSH_MAX_SIZE 默认值是 5000,所以在你学习测试时候因为测试数据少(少于 5000),数据始终在 buffer 中,直到数据源数据完结,作业也完结了,才将计算结果刷入 MySQL,所以没有实时的(每条)写入 MySQL。如下: ...

July 22, 2020 · 1 min · jiezi

关于flink:进击的-Flink网易云音乐实时数仓建设实践

如何基于 Flink 的新 API 降级实时数仓架构? 背景介绍网易云音乐从 2018 年开始搭建实时计算平台,到目前为止曾经倒退至如下规模: 机器数量:130+单 Kafka 峰值 QPS:400W+在线运行工作数:500+开发者:160+业务笼罩:在线业务反对,实时报表统计,实时特色解决,实时索引反对2020 年 Q1 工作数增长 100%,处于高速倒退中 这是网易云音乐实时数仓 18 年的版本,基于 Flink 1.7 版本开发,过后 Flink SQL 的整体架构也还不是很欠缺。咱们应用了 Antlr (通用的编程语言解析器,它只需编写名为 G4 的语法文件,即可主动生成解析的代码,并且以对立的格局输入,解决起来非常简单。因为 G4 文件是通过开发者自行定制的,因而由 Antlr 生成的代码也更加简洁和个性化)自定义了一些 DDL 欠缺了维表 Join 的语法。通过 Antlr 实现语法树的解析当前,再通过 CodeGen(依据接口文档生成代码)技术去将整个 SQL 代码生成一个 Jar 包,而后部署到 Flink 集群下来。 此时还没有对立的元数据管理系统。在 JAR 包工作的开发上, 咱们也没有任何框架的束缚,平台也很难晓得 JAR 的工作上下游以及相干业务的重要性和优先级。这套架构咱们跑了将近一年的工夫,随着工作越来越多,咱们发现了以下几个问题: 反复的数据了解因为没有进行对立的元数据管理,每个工作的代码外面都须要事后定义 DDL 语句,而后再进行 Select 等业务逻辑的开发;音讯的元数据不能复用,每个开发都须要进行反复的数据了解,须要理解数据从哪里来、数据如何解析、数据的业务含意是什么;整个过程须要多方沟通,整体还存在了解谬误的危险;也不足对立的管理系统去查找本人想要的数据。 和官网版本越走越远因为晚期版本很多 SQL 的语法都是咱们本人自定义的,随着 Flink 自身版本的欠缺,语法和官网版本差异越来越大,功能完善性上也慢慢跟不上官网的版本,易用性天然也越来越差。如果你自身就是一名熟知 Flink SQL 的开发人员,可能还须要重新学习咱们平台本人的语法,整体不是很对立,有些问题也很难在互联网上找到相干的材料,只能靠运维来解决。 ...

July 21, 2020 · 2 min · jiezi

关于flink:字节跳动李本超一年成为-Committer我与-Flink-社区的故事

首先简略做个自我介绍,我是李本超,是字节跳动基础架构流式计算方向的工程师,次要负责 Flink SQL 方向。最近十分有幸受邀成为 Apache Flink Committer。 我参加社区次要是从19年下半年开始的,最开始次要是汇报一些应用过程中遇到的 bug,并且会力不从心的去修复它。与此同时也始终在关注 user 和 dev 邮件列表,一方面理解社区的最新进展和将来倒退方向;一方面也在从其他人的发问和答复中学习教训。起初随着理解的深刻,也就参加到了帮忙解答用户问题,参加设计的探讨、以及感兴趣的 issue 的探讨等。 社区筛选 Committer 的条件是比拟平衡的,各种模式的参加奉献社区,都会被记录和认可,比方奉献代码,奉献文档(包含翻译),参加各种模式的探讨,帮忙解答用户的发问等。从我集体的角度来讲,这些方面都做了肯定水平的参加,做的最突出的一个点次要是在 user 列表里沉闷的比较突出。 本篇文章次要是介绍我本人参加社区的过程和一些心得体会,次要从以下几个方面进行了介绍: 初识 Flink 社区如何融入社区在社区的播种对社区的奉献参加社区的倡议初识 Flink 社区我第一次接触 Flink 的工夫其实比拟早,2017 年我研究生毕业的时候,我过后的 mentor 给我定的方向就是流式计算,具体来说就是 Flink。过后我对于 Flink 还齐全是一个小白,工作上也齐全是一个小白,在读了几天 Flink 文档后,就失去了一个十分浅显的论断,Spark Streaming 应该就能够满足咱们的场景了(因为之前在实验室搞过 Spark,而且实习的时候又较为深度的应用过 Spark Streaming)。这一个浅显的论断让我跟 Flink 深度接触的时间延迟了 2 年。 第二次接触 Flink 是在 2018 年夏天的一次 Flink Meetup 上,对于过后的情景的印象到当初都还是很粗浅的。尤其是大沙老师过后的演讲尤其是对我影响比拟大,大沙对于 Flink 深入浅出的解说,给我的感觉就是 Flink 社区里都是一群大牛,而且 Flink 自身也十分的有意思。 过后就想,如果有幸哪天也可能跟这些人一起在社区参加工作,将会是如许幸福的一件事。值得一提的是,过后光芒老师也分享了 Flink 在字节跳动的落地应用,冥冥中注定吧,我当初也是他团队的一员了。在这之后咱们在公司(上家公司)内也做了一些对 Flink 利用落地应用的摸索,整体来讲 Flink 还是很好地满足了咱们的场景。然而因为公司的数据特点,并没有遇到太多大流量下的挑战,只是在应用层做了一些简略的工作。 ...

July 20, 2020 · 2 min · jiezi

关于flink:Flink-最佳搭档开发部署平台-Zeppelin-的自白

Flink 的学习者或者爱好者想必非常理解,除了须要相熟 Flink 自身之外,如果能有一款简略上手的 Flink 开发部署工具,不必写前端代码就能实现实时大屏、反对全副语言接口、反对多条 SQL,还能治理 Flink Job,这样的开发部署平台是不是齐全无奈回绝? 很侥幸,Apache 社区就有这么一款工具:Zeppelin,而且可能是开源界最好的 Flink 开发平台。 上面是 Zeppelin 和 Flink 的故事。 Zeppelin:Flink 最佳搭档Flink:我提供了 SQL、Java、Scala 还有 Python 等多种语言反对,不过每种语言都有本人的入口,多种语言混着用临时无奈实现。比方在 sql-client 中只能运行 SQL,不能写 UDF,在 Pyflink shell 里,只能用 Python 的 UDF,不能写和用 scala 和 java 的 UDF。有没有谁能帮我把这些语言全副买通? Zeppelin:我能够! Flink:我的一个很大的应用场景是实时大屏,然而我一个人办不到,往往须要借助第三方存储,还须要前端开发,有没有谁能让用户不必写前端代码就实现实时大屏? Zeppelin:我能够! Flink:我的 SQL 曾经很弱小了,然而用户在 sql-client 里不能写 comment,临时也不反对运行多条 SQL 语句,有谁能帮我把这些性能补齐下? Zeppelin:我能够! Flink:好多初学者说要跑一个 Flink job 须要多种配置并且须要学习各种命令行,有没有谁能让大家更容易提交和治理 Flink Job。 Zeppelin:我能够! Flink:Flink Job 提交目前只能一个个提交,有些同学想并行执行多个 Flink Job,谁能帮我搞定这个需要? Zeppelin:我能够! Flink:我有丰盛的 connector,用户须要把 connector 打包到 uber jar 里,或者 copy 到 Flink 的 Lib 下,这有可能把各种 connector jar 混在一起,容易发生冲突,有没有谁能提供一个洁净点的计划? ...

July 20, 2020 · 2 min · jiezi

关于flink:Flink-111-Unaligned-Checkpoint-解析

作为 Flink 最根底也是最要害的容错机制,Checkpoint 快照机制很好地保障了 Flink 利用从异样状态复原后的数据准确性。同时 Checkpoint 相干的 metrics 也是诊断 Flink 利用衰弱状态最为重要的指标,胜利且耗时较短的 Checkpoint 表明作业运行状况良好,没有异样或反压。然而,因为 Checkpoint 与反压的耦合,反压反过来也会作用于 Checkpoint,导致 Checkpoint 的种种问题。针对于此,Flink 在 1.11 引入 Unaligned Checkpint 来解耦 Checkpoint 机制与反压机制,优化高反压状况下的 Checkpoint 体现。 以后 Checkpoint 机制简述置信不少读者对 Flink Checkpoint 基于 Chandy-Lamport 算法的分布式快照曾经比拟相熟,该节简略回顾下算法的根底逻辑,相熟算法的读者可释怀跳过。Chandy-Lamport 算法将分布式系统形象成 DAG(临时不思考有闭环的图),节点示意过程,边示意两个过程间通信的管道。分布式快照的目标是记录下整个零碎的状态,即能够分为节点的状态(过程的状态)和边的状态(信道的状态,即传输中的数据)。因为零碎状态是由输出的音讯序列驱动变动的,咱们能够将输出的音讯序列分为多个较短的子序列,图的每个节点或边先后解决完某个子序列后,都会进入同一个稳固的全局统状态。利用这个个性,零碎的过程和信道在子序列的边界点别离进行本地快照,即便各局部的快照工夫点不同,最终也能够组合成一个有意义的全局快照。 从实现上看,Flink 通过在 DAG 数据源定时向数据流注入名为 Barrier 的非凡元素,将间断的数据流切分为多个无限序列,对应多个 Checkpoint 周期。每当接管到 Barrier,算子进行本地的 Checkpoint 快照,并在实现后异步上传本地快照,同时将 Barrier 以播送形式发送至上游。当某个 Checkpoint 的所有 Barrier 达到 DAG 末端且所有算子实现快照,则标记着全局快照的胜利。 在有多个输出 Channel 的状况下,为了数据准确性,算子会期待所有流的 Barrier 都达到之后才会开始本地的快照,这种机制被称为 Barrier 对齐。在对齐的过程中,算子只会持续解决的来自未呈现 Barrier Channel 的数据,而其余 Channel 的数据会被写入输出队列,直至在队列满后被阻塞。当所有 Barrier 达到后,算子进行本地快照,输入 Barrier 到上游并恢复正常解决。比起其余分布式快照,该算法的劣势在于辅以 Copy-On-Write 技术的状况下不须要 “Stop The World” 影响利用吞吐量,同时根本不必长久化解决中的数据,只用保留过程的状态信息,大大减小了快照的大小。 ...

July 20, 2020 · 3 min · jiezi

关于flink:Flink学习Flink-SQL-窗口函数

flink窗口函数蕴含滚动窗口、滑动窗口、会话窗口和OVER窗口 滚动窗口滚动窗口(TUMBLE)将每个元素调配到一个指定大小的窗口中。通常,滚动窗口有一个固定的大小,并且不会呈现重叠。例如,如果指定了一个5分钟大小的滚动窗口,有限流的数据会依据工夫划分为[0:00 - 0:05)、[0:05, 0:10)、[0:10, 0:15)等窗口。下图展现了一个30秒的滚动窗口。应用标识函数选出窗口的起始工夫或者完结工夫,窗口的工夫属性用于上级Window的聚合。 窗口标识函数返回类型形容TUMBLE_START(time-attr, size-interval)TIMESTAMP返回窗口的起始工夫(蕴含边界)。例如[00:10, 00:15) 窗口,返回00:10 。TUMBLE_END(time-attr, size-interval)TIMESTAMP返回窗口的完结工夫(蕴含边界)。例如[00:00, 00:15]窗口,返回00:15。TUMBLE_ROWTIME(time-attr, size-interval)TIMESTAMP(rowtime-attr)返回窗口的完结工夫(不蕴含边界)。例如[00:00, 00:15]窗口,返回00:14:59.999 。返回值是一个rowtime attribute,即能够基于该字段做工夫属性的操作,例如,级联窗口只能用在基于Event Time的Window上TUMBLE_PROCTIME(time-attr, size-interval)TIMESTAMP(rowtime-attr)返回窗口的完结工夫(不蕴含边界)。例如[00:00, 00:15]窗口,返回00:14:59.999。返回值是一个proctime attribute,即能够基于该字段做工夫属性的操作,例如,级联窗口只能用在基于Processing Time的Window上TUMBLE window示例 import org.apache.flink.api.common.typeinfo.TypeHint;import org.apache.flink.api.common.typeinfo.TypeInformation;import org.apache.flink.api.java.tuple.Tuple3;import org.apache.flink.streaming.api.TimeCharacteristic;import org.apache.flink.streaming.api.datastream.DataStream;import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;import org.apache.flink.streaming.api.functions.timestamps.AscendingTimestampExtractor;import org.apache.flink.table.api.EnvironmentSettings;import org.apache.flink.table.api.Table;import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;import java.sql.Timestamp;import java.util.Arrays;public class TumbleWindowExample { public static void main(String[] args) throws Exception { /** * 1 注册环境 */ EnvironmentSettings mySetting = EnvironmentSettings .newInstance()// .useOldPlanner() .useBlinkPlanner() .inStreamingMode() .build(); // 获取 environment StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); // 指定零碎工夫概念为 event time env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime); StreamTableEnvironment tEnv = StreamTableEnvironment.create(env,mySetting); // 初始数据 DataStream<Tuple3<Long, String,Integer>> log = env.fromCollection(Arrays.asList( //工夫 14:53:00 new Tuple3<>(1572591180_000L,"xiao_ming",300), //工夫 14:53:09 new Tuple3<>(1572591189_000L,"zhang_san",303), //工夫 14:53:12 new Tuple3<>(1572591192_000L, "xiao_li",204), //工夫 14:53:21 new Tuple3<>(1572591201_000L,"li_si", 208) )); // 指定工夫戳 SingleOutputStreamOperator<Tuple3<Long, String, Integer>> logWithTime = log.assignTimestampsAndWatermarks(new AscendingTimestampExtractor<Tuple3<Long, String, Integer>>() { @Override public long extractAscendingTimestamp(Tuple3<Long, String, Integer> element) { return element.f0; } }); // 转换为 Table Table logT = tEnv.fromDataStream(logWithTime, "t.rowtime, name, v"); Table result = tEnv.sqlQuery("SELECT TUMBLE_START(t, INTERVAL '10' SECOND) AS window_start," + "TUMBLE_END(t, INTERVAL '10' SECOND) AS window_end, SUM(v) FROM " + logT + " GROUP BY TUMBLE(t, INTERVAL '10' SECOND)"); TypeInformation<Tuple3<Timestamp,Timestamp,Integer>> tpinf = new TypeHint<Tuple3<Timestamp,Timestamp,Integer>>(){}.getTypeInfo(); tEnv.toAppendStream(result, tpinf).print(); env.execute(); }}sql逻辑,每十秒钟聚合执行后果:(2019-11-01 06:53:00.0,2019-11-01 06:53:10.0,603)(2019-11-01 06:53:20.0,2019-11-01 06:53:30.0,208)(2019-11-01 06:53:10.0,2019-11-01 06:53:20.0,204) ...

July 20, 2020 · 3 min · jiezi

关于flink:Flink学习Flink-on-Yarn

本文转载自:https://ververica.cn/develope...作者:周凯波(宝牛) Flink 架构概览Flink 架构概览–Job 用户通过 DataStream API、DataSet API、SQL 和 Table API 编写 Flink 工作,它会生成一个JobGraph。JobGraph 是由 source、map()、keyBy()/window()/apply() 和 Sink 等算子组成的。当 JobGraph 提交给 Flink 集群后,可能以 Local、Standalone、Yarn 和 Kubernetes 四种模式运行。 Flink 架构概览–JobManager JobManager的性能次要有: 将 JobGraph 转换成 Execution Graph,最终将 Execution Graph 拿来运行Scheduler 组件负责 Task 的调度Checkpoint Coordinator 组件负责协调整个工作的 Checkpoint,包含 Checkpoint 的开始和实现通过 Actor System 与 TaskManager 进行通信其它的一些性能,例如 Recovery Metadata,用于进行故障复原时,能够从 Metadata 外面读取数据。Flink 架构概览–TaskManager TaskManager 是负责具体任务的执行过程,在 JobManager 申请到资源之后开始启动。TaskManager 外面的次要组件有: Memory & I/O Manager,即内存 I/O 的治理Network Manager,用来对网络方面进行治理Actor system,用来负责网络的通信TaskManager 被分成很多个 TaskSlot,每个工作都要运行在一个 TaskSlot 外面,TaskSlot 是调度资源里的最小单位。 ...

July 20, 2020 · 2 min · jiezi

关于flink:Flink学习管理大型状态之增量-Checkpoint-详解

文章转载自:https://ververica.cn/develope...作者:邱从贤(山智) Apache Flink 是一个有状态的流计算框架,状态是作业算子中曾经解决过的内存状态,供后续解决时应用。状态在流计算很多简单场景中十分重要,比方: 保留所有历史记录,用来寻找某种记录模式保留最近一分钟的所有记录,用于对每分钟的记录进行聚合统计保留以后的模型参数,用于进行模型训练有状态的流计算框架必须有很好的容错性,能力在生产环境中施展用途。这里的容错性是指,不论是产生硬件故障,还是程序异样,最终的后果不丢也不重。 Flink 的容错性从一开始就是一个十分弱小的个性,在遇到故障时,可能保障不丢不重,且对失常逻辑解决的性能影响很小。 这外面的外围就是 checkpoint 机制,Flink 应用 checkpoint 机制来进行状态保障,在 Flink 中 checkpoint 是一个定时触发的全局异步快照,并长久化到长久存储系统上(通常是分布式文件系统)。产生故障后,Flink 抉择从最近的一个快照进行复原。有用户的作业状态达到 GB 甚至 TB 级别,对这么大的作业状态做一次 checkpoint 会十分耗时,耗资源,因而咱们在 Flink 1.3 中引入了增量 checkpoint 机制。 在增量 checkpoint 之前,Flink 的每个 checkpoint 都蕴含作业的所有状态。咱们在察看到状态在 checkpoint 之间的变动并没有那么大之后,反对了增量 checkpoint。增量 checkpoint 仅蕴含上次 checkpoint 和本次 checkpoint 之间状态的差别(也就是“增量”)。 对于状态十分大的作业,增量 checkpoint 对性能的晋升非常明显。有生产用户反馈对于 TB 级别的作业,应用增量 checkpoint 后能将 checkpoint 的整体工夫从 3 分钟降到 30 秒。这些工夫节俭次要归功于不须要在每次 checkpoint 都将所有状态写到长久化存储系统。 如何应用以后,仅可能在 RocksDB StateBackend 上应用增量 checkpoint 机制,Flink 依赖 RocksDB 外部的备份机制来生成 checkpoint 文件。Flink 会主动清理掉之前的 checkpoint 文件, 因而增量 checkpoint 的历史记录不会有限增长。 ...

July 18, 2020 · 2 min · jiezi

Flink学习内存管理

本文转载自:https://ververica.cn/develope... 作者:伍翀(云邪) 现在,大数据畛域的开源框架(Hadoop,Spark,Storm)都应用的  JVM,当然也包含 Flink。基于  JVM  的数据分析引擎都须要面对将大量数据存到内存中,这就不得不面对  JVM 存在的几个问题: Java 对象存储密度低。一个只蕴含 boolean 属性的对象占用了16个字节内存:对象头占了8个,boolean 属性占了1个,对齐填充占了7个。而实际上只须要一个bit(1/8字节)就够了。Full GC 会极大地影响性能,尤其是为了解决更大数据而开了很大内存空间的 JVM 来说,GC 会达到秒级甚至分钟级。OOM 问题影响稳定性。OutOfMemoryError 是分布式计算框架常常会遇到的问题,当 JVM 中所有对象大小超过调配给 JVM 的内存大小时,就会产生 OutOfMemoryError 谬误,导致 JVM 解体,分布式框架的健壮性和性能都会受到影响。所以目前,越来越多的大数据我的项目开始本人治理 JVM 内存了,像 Spark、Flink、HBase,为的就是取得像 C 一样的性能以及防止 OOM 的产生。本文将会探讨 Flink 是如何解决下面的问题的,次要内容包含内存治理、定制的序列化工具、缓存敌对的数据结构和算法、堆外内存、JIT 编译优化等。 踊跃的内存治理Flink 并不是将大量对象存在堆上,而是将对象都序列化到一个预调配的内存块上,这个内存块叫做 **MemorySegment**,它代表了一段固定长度的内存(默认大小为 32KB),也是 Flink 中最小的内存调配单元,并且提供了十分高效的读写办法。你能够把 MemorySegment 设想成是为 Flink 定制的 **java.nio.ByteBuffer**。它的底层能够是一个一般的 Java 字节数组(**byte[]**),也能够是一个申请在堆外的 **ByteBuffer**。每条记录都会以序列化的模式存储在一个或多个**MemorySegment**中。 Flink 中的 Worker 名叫 TaskManager,是用来运行用户代码的 JVM 过程。TaskManager 的堆内存次要被分成了三个局部: Network Buffers: 肯定数量的32KB大小的 buffer,次要用于数据的网络传输。在 TaskManager 启动的时候就会调配。默认数量是 2048 个,能够通过 **taskmanager.network.numberOfBuffers** 来配置。(浏览这篇文章理解更多Network Buffer的治理)Memory Manager Pool: 这是一个由 MemoryManager 治理的,由泛滥MemorySegment组成的超大汇合。Flink 中的算法(如 sort/shuffle/join)会向这个内存池申请 MemorySegment,将序列化后的数据存于其中,应用完后开释回内存池。默认状况下,池子占了堆内存的 70% 的大小。Remaining (Free) Heap: 这部分的内存是留给用户代码以及 TaskManager 的数据结构应用的。因为这些数据结构个别都很小,所以基本上这些内存都是给用户代码应用的。从GC的角度来看,能够把这里看成的新生代,也就是说这里次要都是由用户代码生成的短期对象。留神:Memory Manager Pool 次要在Batch模式下应用。在Steaming模式下,该池子不会预分配内存,也不会向该池子申请内存块。也就是说该局部的内存都是能够给用户代码应用的。不过社区是打算在 Streaming 模式下也能将该池子利用起来。 ...

July 17, 2020 · 4 min · jiezi

解决问题-1474-个Flink-111-究竟有哪些易用性上的改善

7月7日,Flink 1.11.0 正式公布了,作为这个版本的 release manager 之一,我想跟大家分享一下其中的经验感触以及一些代表性 feature 的解读。在进入深度解读前,咱们先简略理解下社区公布的个别流程,帮忙大家更好的了解和参加 Flink 社区的工作。 首先在每个版本的布局初期,会从志愿者中选出 1-2 名作为 Release Manager。1.11.0 版本我作为中国这边的 Release Manager,同时还有一名来自 Ververica 的 Piotr Nowojski 作为德国方的 Release Manager,这在某种程度上也阐明中国的开发者和贡献度在整个社区的占比很重要。接下来会进行这个版本的 Feature Kickoff。在一些大的方向上,社区的布局周期可能比拟久,会分阶段、分步骤逾越多个版本实现,确保品质。每个版本的侧重点也会有所不同,比方前两个版本侧重于批处理的增强,而这个版本更侧重于流解决易用性的晋升。社区规划的 Feature 列表会在邮件列表中发动探讨,以收集更多的用户/开发者意见和反馈。个别的开发周期为 2-3 个月工夫,提前会明确布局出大略的 Feature Freeze 工夫,之后进行 Release Candidate 的公布和测试、以及 Bug Fix。个别通过几轮的迭代周期后会正式投票通过一个绝对稳固的 Candidate 版本,而后基于这个版本正式公布。Flink 1.11.0 从 3 月初的性能布局到 7 月初的正式公布,历经了差不多 4 个月的工夫,对 Flink 的生态、易用性、生产可用性、稳定性等方面都进行了加强和改善,上面将一一跟大家分享。 一  综述Flink 1.11.0 从 Feature 解冻后公布了 4 次 Candidate 才最终通过。经统计,一共有 236 个贡献者参加了这次版本开发,解决了 1474 个 Jira 问题,波及 30 多个 FLIP,提交了 2325 个 Commit。 ...

July 16, 2020 · 5 min · jiezi

官方剧透111-发版前我们偷看了-Flink-中文社区发起人的聊天记录

Flink 1.11 行将 Release 啦!作为备受瞩目的新一代开源大数据计算引擎,Flink 无疑已成为 Apache 基金会和 GitHub 最为沉闷的我的项目之一。 自 2014 年正式开源, Flink 倒退十分迅速,在 GitHub 上其访问量在 Apache 我的项目中位居前三。去年年底 Flink Forward Asia 2019 大会颁布,仅仅 2019 年一年的工夫,Flink 在 GitHub 上的 star 数量就翻了一倍,Contributor 数量也呈现出持续增长的态势。 GitHub 地址指路:https://github.com/apache/flink越来越多的企业和开发者正在一直地退出 Flink 社区,中国开发者也为 Flink 开发做出了微小的奉献。最近,Flink 终于要迎来1.11版本的更新,不仅对 SQL 和 PyFlink 的反对进行了优化,还有 Hive 的兼容性,以及加强了拓展资源(GPU)的调度反对。 将在6月下旬发版的的 Flink 1.11 重要性能个性更新如下:(目前已在官网文档更新) 加强 Web UI 性能全新 Source APIDataStream API 反对 Kafka 载体实现子图 Failover晋升 DDL 易用性(动静 Table 属性,Primary Key反对)加强 Hive 流批一体化(Hive Streaming sink,Filesystem Connector)反对被 Zeppelin 集成,所有公布性能可用加强 PyFlink(Pandas反对,SQL DDL/Client集成),晋升 Python UDF 性能反对 Application 运行模式、加强 K8s 性能以及 Docker 镜像对立对立 Job Master 内存配置反对 GPU 调度调整 Savepoint 文件门路不便挪动Runtime 实现 Unalinged 模式提速反压场景下 CheckpointFlink 1.11 版本更新之际,大数据文摘跟阿里巴巴资深技术专家,实时计算负责人,也是 Flink 中文社区发起人王峰 (莫问)聊了聊,对于 Flink 此次新版的重点,以及将来社区的倒退布局,莫问老师都给了咱们一波官网剧透。 ...

July 15, 2020 · 2 min · jiezi

字节跳动基于Flink的MQHive实时数据集成

在数据中台建设过程中,一个典型的数据集成场景是将 MQ (Message Queue,例如 Kafka、RocketMQ 等)的数据导入到 Hive 中,以供上游数仓建设以及指标统计。因为 MQ-Hive 是数仓建设第一层,因而对数据的准确性以及实时性要求比拟高。 本文次要围绕 MQ-Hive 场景,针对目前字节跳动内已有解决方案的痛点,提出基于 Flink 的实时解决方案,并介绍新计划在字节跳动外部的应用现状。 已有计划及痛点字节跳动内已有解决方案如下图所示,次要分了两个步骤: 通过 Dump 服务将 MQ 的数据写入到 HDFS 文件再通过 Batch ETL 将 HDFS 数据导入到 Hive 中,并增加 Hive 分区 痛点工作链较长,原始数据须要通过屡次转换最终能力进入 Hive实时性比拟差,Dump Service、Batch ETL 提早都会导致最终数据产出提早存储、计算开销大,MQ 数据反复存储和计算基于原生 Java 打造,数据流量持续增长后,存在单点故障和机器负载不平衡等问题运维老本较高,架构上无奈复用公司内 Hadoop/Flink/Yarn 等现有基础设施不反对异地容灾基于 Flink 实时解决方案劣势针对目前公司传统解决方案的痛点,咱们提出基于 Flink 的实时解决方案,将 MQ 的数据实时写入到 Hive,并反对事件工夫以及 Exactly Once 语义。相比老计划,新计划劣势如下所示: 基于流式引擎 Flink 开发,反对 Exactly Once 语义实时性更高,MQ 数据间接进入 Hive,无两头计算环节缩小两头存储,整个流程数据只会落地一次撑持 Yarn 部署模式,不便用户迁徙资源管理弹性,不便扩容以及运维反对双机房容灾整体架构整体架构如下图所示,次要包含 DTS(Data Transmission Service) Source、DTS Core、DTS Sink 三大模块,具体性能如下: ...

July 15, 2020 · 3 min · jiezi

详解-Flink-实时应用的确定性

作者:林小铂(网易游戏) 确定性(Determinism)是计算机科学中非常重要的个性,确定性的算法保障对于给定雷同的输出总是产生雷同的输入。在分布式实时计算畛域,确定性是业界始终难以解决的课题,由此导致用离线计算修改实时计算结果的 Lambda 架构成为大数据畛域过来近十年的支流架构。 而在最近几年随着 Google The Dataflow Model 的提出,实时计算和离线计算的关系逐步清晰,在实时计算中提供与离线计算统一的确定性成为可能。本文将基于风行实时计算引擎 Apache Flink,梳理构建一个确定性的实时利用要满足什么条件。 确定性与准确性比起确定性,准确性(Accuracy)可能是咱们接触更多的近义词,大多数场景下两者能够混用,但其实它们稍有不同: 精确的货色肯定是确定的,但确定性的货色未必百分百精确。在大数据畛域,不少算法能够依据需要调整老本和准确性的均衡,比方 HyperLogLog 去重统计算法给出的后果是有肯定误差的(因而不是精确的),但却同时是确定性的(重算能够失去雷同后果)。 要分区确定性和准确性的缘故是,准确性与具体的业务逻辑严密耦合难以评估,而确定性则是通用的需要(除去多数场景用户成心应用非确定性的算法)。当一个 Flink 实时利用提供确定性,意味着它在异样场景的主动重试或者手动重流数据的状况下,都能像离线作业个别产出雷同的后果,这将很大水平上进步用户的信任度。 影响 Flink 利用确定性的因素投递语义常见的投递语义有 At-Most-Once、At-Least-Once 和 Exactly-Once 三种。严格来说只有 Exactly-Once 满足确定性的要求,但如果整个业务逻辑是幂等的, 基于 At-Least-Once 也能够达到后果的确定性。 实时计算的 Exactly-Once 通常指端到端的 Exactly-Once,保障输入到上游零碎的数据和上游的数据是统一的,没有反复计算或者数据失落。要达到这点,须要别离实现读取数据源(Source 端)的 Exactly-Once、计算的 Exactly-Once 和输入到上游零碎(Sink 端)的 Exactly-Once。 其中后面两个都比拟好保障,因为 Flink 利用出现异常会主动复原至最近一个胜利 checkpoint,Pull-Based 的 Source 的状态和 Flink 外部计算的状态都会主动回滚到快照工夫点,而问题在于 Push-Based 的 Sink 端。Sink 端是否能顺利回滚依赖于内部零碎的个性,通常来说须要内部零碎反对事务,然而不少大数据组件对事务的反对并不是很好,即便是实时计算最罕用的 Kafka 也直到 2017 年的 0.11 版本才反对事务,更多的组件须要依赖各种 trick 来达到某种场景下的 Exactly-Once。 总体来说这些 Trick 能够分为两大类: ...

July 15, 2020 · 2 min · jiezi

Apache-Flink-是什么

Apache Flink 是一个框架和分布式解决引擎,用于在无边界和有边界数据流上进行有状态的计算。Flink 能在所有常见集群环境中运行,并能以内存速度和任意规模进行计算。 接下来,咱们来介绍一下 Flink 架构中的重要方面。 解决无界和有界数据任何类型的数据都能够造成一种事件流。信用卡交易、传感器测量、机器日志、网站或挪动应用程序上的用户交互记录,所有这些数据都造成一种流。 数据能够被作为 无界 或者 有界 流来解决。 1.无界流 有定义流的开始,但没有定义流的完结。它们会无休止地产生数据。无界流的数据必须继续解决,即数据被摄取后须要立即解决。咱们不能等到所有数据都达到再解决,因为输出是有限的,在任何时候输出都不会实现。解决无界数据通常要求以特定程序摄取事件,例如事件产生的程序,以便可能推断后果的完整性。 2.有界流 有定义流的开始,也有定义流的完结。有界流能够在摄取所有数据后再进行计算。有界流所有数据能够被排序,所以并不需要有序摄取。有界流解决通常被称为批处理。 Apache Flink 善于解决无界和有界数据集 准确的工夫管制和状态化使得 Flink 的运行时(runtime)可能运行任何解决无界流的利用。有界流则由一些专为固定大小数据集非凡设计的算法和数据结构进行外部解决,产生了杰出的性能。 通过摸索 Flink 之上构建的 用例 来加深了解。 部署利用到任意中央Apache Flink 是一个分布式系统,它须要计算资源来执行应用程序。Flink 集成了所有常见的集群资源管理器,例如 Hadoop YARN、 Apache Mesos 和 Kubernetes,但同时也能够作为独立集群运行。 Flink 被设计为可能很好地工作在上述每个资源管理器中,这是通过资源管理器特定(resource-manager-specific)的部署模式实现的。Flink 能够采纳与以后资源管理器相适应的形式进行交互。 部署 Flink 应用程序时,Flink 会依据应用程序配置的并行性主动标识所需的资源,并从资源管理器申请这些资源。在产生故障的状况下,Flink 通过申请新资源来替换产生故障的容器。提交或控制应用程序的所有通信都是通过 REST 调用进行的,这能够简化 Flink 与各种环境中的集成。 运行任意规模利用Flink 旨在任意规模上运行有状态流式利用。因而,应用程序被并行化为可能数千个工作,这些工作散布在集群中并发执行。所以应用程序可能充分利用无尽的 CPU、内存、磁盘和网络 IO。而且 Flink 很容易保护十分大的应用程序状态。其异步和增量的检查点算法对解决提早产生最小的影响,同时保障准确一次状态的一致性。 Flink 用户报告了其生产环境中一些令人印象粗浅的扩展性数字 解决每天解决数万亿的事件,利用保护几TB大小的状态, 和利用在数千个内核上运行。利用内存性能有状态的 Flink 程序针对本地状态拜访进行了优化。工作的状态始终保留在内存中,如果状态大小超过可用内存,则会保留在能高效拜访的磁盘数据结构中。工作通过拜访本地(通常在内存中)状态来进行所有的计算,从而产生非常低的解决提早。Flink 通过定期和异步地对本地状态进行长久化存储来保障故障场景下准确一次的状态一致性。 原文链接:https://flink.apache.org/zh/flink-architecture.html

July 15, 2020 · 1 min · jiezi

你与30W奖金只差一个-Apache-Flink-极客挑战赛的报名

万众瞩目的第二届 Apache Flink 极客挑战赛来啦! 去年,第一届 Apache Flink 极客挑战赛,会集了寰球11个国家和地区,233所高校,397家企业,4393位顶尖选手参赛! 在整个较量的过程中,通过实践和实战的超强联合,大家都播种满满,逐渐晋升了理论业务能力,刷新了古代大数据的认知,找到气味相投的 nice 团队,发明有限可能! 来康康大家的感触吧~ 理解了实践与实际的差距,明确了实际出真知的真谛。学术是一个无限输出有限资源的环境,理论场景却是一个有限输出无限资源的环境。在诸多的限度下实现实践的成果是一个挑战,也是一次播种。 ——中国科学院 Fractal 咱们对大数据与机器学习的联合利用也有了更粗浅的了解。在这个越来越智能的大数据时代,咱们深信 Flink 和 intel Analytics Zoo 定能发明更大的价值。 ——北京邮电大学 建文大帝 加入像 Flink 性能优化大赛、中间件性能挑战赛等工程类较量,是学习和进步编程技能的绝佳路径。 ——北京信息科技大学 乘蜗牛追乌龟 可能找到气味相投的人一起打较量是很 nice 的经验! ——电子科技大学 阿川的本色出演 掀起报名狂潮的 Apache Flink 极客挑战赛,在第二届进行了全面降级。赛制选题上,围绕全世界最为关注的“疫情”开展;助阵大咖会以业余角度参加到评审环节中,给大赛削减更多的含金量;不同的赛制规定也晋升了大赛的全面性;参赛人员的奖金和激励师处分特地值得大家期待,既放弃了偏心公正,同时也削减了趣味互动性。 大赛相干介绍2020 年从天而降的疫情对整个国家的公共卫生事件应答能力提出了很高的要求,如何利用科技伎俩对疫情流传进行精准无效的防控成为了要害。为了让科技更好地联合民生,让 IT 技术进一步造福社会,阿里云联手英特尔以及 Apache Flink 社区独特发动本次较量。心愿选手可能通过本次大赛获取更多技术启发,实质性的利用到咱们的生存当中,成就生存,发明价值! 即日起至9月16日中午12:00,Apache Flink 极客挑战赛报名正式开启! 第二届 Apache Flink 极客挑战赛由 Apache Flink Community China 发动,阿里云计算平台事业部、天池平台、intel 联结举办,达摩院提供向量搜寻的技术输入。 较量助阵大咖阵容 赛制制度赛题阐明 基于从安防摄像头视频脱敏后的人脸及人体数据,利用 Flink + Analytics Zoo + 向量搜索引擎 Proxima 对新冠确诊病例的历史和实时口头轨迹进行追踪。赛题背地的技术在 NLP、Computer Graphics、举荐零碎等方面都有相当宽泛的利用,因而较量也将考查解决方案通用性。 ...

July 14, 2020 · 1 min · jiezi

官宣-千呼万唤Apache-Flink-1110-正式发布啦

Apache Flink 社区很荣幸的发表 Flink 1.11.0 版本正式公布!超过 200 名贡献者参加了 Flink 1.11.0 的开发,提交了超过 1300 个修复或优化。这些批改极大的进步了 Flink 的可用性,并且加强了各个 API 栈的性能。其中一些比拟重要的批改包含: 外围引擎局部引入了非对齐的 Checkpoint 机制。这一机制是对 Flink 容错机制的一个重要改良,它能够进步重大反压作业的 Checkpoint 速度。实现了一套新的 Source 接口。通过对立流和批作业 Source 的运行机制,提供罕用的外部实现如事件工夫解决,watermark 生成和闲暇并发检测,这套新的 Source 接口能够极大的升高实现新的 Source 时的开发复杂度。Flink SQL 引入了对 CDC(Change Data Capture,变动数据捕捉)的反对,它使 Flink 能够不便的通过像 Debezium 这类工具来翻译和生产数据库的变动日志。Table API 和 SQL 也扩大了文件系统连接器对更多用户场景和格局的反对,从而能够反对将流式数据从 Kafka 写入 Hive 等场景。PyFlink 优化了多个局部的性能,包含对向量化的用户自定义函数(Python UDF)的反对。这些改变使 Flink Python 接口能够与罕用的 Python 库(如 Pandas 和 NumPy)进行互操作,从而使 Flink 更适宜数据处理与机器学习的场景。Flink 1.11.0 的二进制公布包和源代码能够在 Flink 官网的下载页面取得,对应的 PyFlink 公布包能够在 PyPI 网站下载。详情能够参阅公布阐明,公布性能更新与更新后的文档。 ...

July 9, 2020 · 5 min · jiezi

首次揭秘春晚活动下快手实时链路保障实践

摘要:本文由快手开发工程师刘建刚分享,主要介绍春晚活动下快手实时链路保障实践。内容主要包含以下四部分: 快手 Flink 简介春晚实时保障方案春晚实时大屏未来规划Tips:点击「阅读原文」链接可查看作者原版 PPT 及分享视频~ 一、快手 Flink 简介我们首先来看一下快手的实时计算架构图。主要分为4个部分,包括数据接入、数据计算、数据应用和数据展示。各层职责分明、衔接顺畅,方便用户开发。 快手的 Flink 集群规模大概有 3000 多台机器,日处理条目数为20万亿,峰值为38亿条。主要应用场景包含以下四类: 实时 SQL 平台,这是 Flink 托管的一个产品化的 SQL 平台。短视频、直播等指标的实时计算,涵盖了公司的主要业务和产品。机器学习的数据预处理,支撑着快手广告等各种模型的训练。快手所有的日志拆分、同步等实时的数据流。 二、春晚实时保障方案快手中标了2020年的央视春晚,春晚作为全球华人辞旧迎新的晚会,数据量之大前所未有。快手 Flink 作为公司的实时计算平台,支持春晚超大状态和千万并发等复杂计算。春晚项目的挑战主要体现在稳定性、实时性、准确性三个方面,我们为此制定了一系列方案为春晚保驾护航。 下面我会通过这4个方面来介绍一下我们为春晚做的努力。 第一个是过载保护,主要介绍极端压力下的技术应对方案;第二个是全系统的稳定性,确保各个方面都万无一失;第三个是压力测试,它是春晚的提前模拟;第四个是资源的保障,涉及到资源的管理和保障。 1.过载保护Flink 在流量激增或者单点性能不足的情况下,有可能会发生卡死、雪崩或者失败的情况。这个时候一旦我们的实时作业挂掉,整个作战计划就会被打乱,可能给公司带来很大的损失。 我们针对这种场景设计了一种健康检查、智能限速、源端控制相结合的柔性可用技术。为什么要通过源端控制?首先,如果出了问题,我们可以在下游的 task 上进行控制,但是这样的话可能带来一个问题,它会造成反压等阻塞行为,有可能会把整个作业卡死,所以我们通过控制数据源来从本质上解决问题。下面是我们技术实现: TaskManager 作为从节点,将自己的健康信息定期汇报到 Master 节点。Master 节点一旦检测到极端压力,立刻要求所有的 source 限速 50%。如果之后作业状态良好,就会慢慢的提高我们的输入 QPS,每次 10%。 然后看一下我们的测试效果图。流量高峰到来时 QPS 为 200K。一旦 Master 节点检测到极端压力,直接将 QPS 限速到 100K。之后检测到作业状态良好,就逐步地进行恢复。经过测试(随着逐渐恢复各项指标会有波动),我们的 CPU 使用率从最高的 100% 降到了 80%~90%,ygc 由每分钟的10秒降到了每分钟3秒以内,同时也避免了的 oom、心跳超时、卡死等各种问题。这种技术能够保障我们 Flink 在极度压力下的存活,起到了削峰保命的效果。 我们还设计了一种轻量级的热更新模型,在作业不停止的情况下通过 restful 接口实时的控制作业去应对各种压力,避免了繁琐的修改代码、打包、上线等耗时过程。常见功能包括关闭快照、设置采样率、source 源鲜素,如下图所示。 ...

July 6, 2020 · 1 min · jiezi

官方剧透111-发版前我们偷看了-Flink-中文社区发起人的聊天记录

简介: 自 2014 年正式开源, Flink 发展非常迅速,在 GitHub 上其访问量在 Apache 项目中位居前三。去年年底 Flink Forward Asia 2019 大会公布,仅仅 2019 年一年的时间,Flink 在 GitHub 上的 star 数量就翻了一倍,Contributor 数量也呈现出持续增长的态势。 原文链接:点击这里 Flink 1.11 即将 Release 啦!作为备受瞩目的新一代开源大数据计算引擎,Flink 无疑已成为 Apache 基金会和 GitHub 最为活跃的项目之一。 自 2014 年正式开源, Flink 发展非常迅速,在 GitHub 上其访问量在 Apache 项目中位居前三。去年年底 Flink Forward Asia 2019 大会公布,仅仅 2019 年一年的时间,Flink 在 GitHub 上的 star 数量就翻了一倍,Contributor 数量也呈现出持续增长的态势。 GitHub 地址指路: https://github.com/apache/flink越来越多的企业和开发者正在不断地加入 Flink 社区,中国开发者也为 Flink 开发做出了巨大的贡献。最近,Flink 终于要迎来1.11版本的更新,不仅对 SQL 和 PyFlink 的支持进行了优化,还有 Hive 的兼容性,以及增强了拓展资源(GPU)的调度支持。 ...

July 6, 2020 · 2 min · jiezi

如何使用-Apache-Flink-查询-Pulsar-流

在之前我们介绍了 Apache Pulsar 及其与其他消息系统的不同之处,并讲解了如何融合 Pulsar 和 Flink 协同工作,为大规模弹性数据处理提供无缝的开发人员体验。本文将介绍 Apache Pulsar 和 Apache Flink 的集成和最新研发进展,并详细说明如何利用 Pulsar 内置 schema,使用 Apache Flink 实时查询 Pulsar 流。 Apache Pulsar 简介Apache Pulsar 是一个灵活的发布/订阅消息系统,支持持久日志存储。Pulsar 的架构优势包括多租户、统一消息模型、结构化事件流、云原生架构等,这些优势让 Pulsar 能够完美适用于多种用户场景,从计费、支付、交易服务到融合组织中不同的消息架构。更多关于 Pulsar 的信息,点击 Apache Pulsar documentation 或通过 Slack 与 Pulsar 社区联系。 现有 Pulsar & Flink 集成(Apache Flink 1.6+)在现有的 Pulsar 和 Flink 集成中,Pulsar 作为 Flink 应用程序中的消息队列来使用。Flink 开发人员可以选择特定 Pulsar source,并连接到所需的 Puslar 集群和 topic,将 Pulsar 用作 Flink 的流 source 和流 sink: ...

July 3, 2020 · 4 min · jiezi

如何使用-Apache-Flink-查询-Pulsar-流

原作者: Sijie Guo、Markos Sfikas翻译:StreamNative-Sijia在之前的博客中,我们介绍了 Apache Pulsar 及其与其他消息系统的不同之处,并讲解了如何融合 Pulsar 和 Flink 协同工作,为大规模弹性数据处理提供无缝的开发人员体验。本文将介绍 Apache Pulsar 和 Apache Flink 的集成和最新研发进展,并详细说明如何利用 Pulsar 内置 schema,使用 Apache Flink 实时查询 Pulsar 流。 Apache Pulsar 简介Apache Pulsar 是一个灵活的发布/订阅消息系统,支持持久日志存储。Pulsar 的架构优势包括多租户、统一消息模型、结构化事件流、云原生架构等,这些优势让 Pulsar 能够完美适用于多种用户场景,从计费、支付、交易服务到融合组织中不同的消息架构。更多关于 Pulsar 的信息,点击 Apache Pulsar documentation 或通过 Slack 与 Pulsar 社区联系。 现有 Pulsar & Flink 集成(Apache Flink 1.6+)在现有的 Pulsar 和 Flink 集成中,Pulsar 作为 Flink 应用程序中的消息队列来使用。Flink 开发人员可以选择特定 Pulsar source,并连接到所需的 Puslar 集群和 topic,将 Pulsar 用作 Flink 的流 source 和流 sink: ...

July 3, 2020 · 4 min · jiezi

Flink的window时间语义Watermark机制多代码案例详解Flink学习入门三

大家好,我是后来,我会分享我在学习和工作中遇到的点滴,希望有机会我的某篇文章能够对你有所帮助,所有的文章都会在公众号首发,欢迎大家关注我的公众号" 后来X大数据 ",感谢你的支持与认可。通过前2篇flink的学习,已经基本掌握了flink的基本使用,但是关于flink真正内核的东西还没开始说,那先简单介绍一下,flink的核心亮点: 窗口时间语义精准一次性我们在第一篇的学习了解到了flink的wordCount,以及在第二篇的API 中,我们也只是获取到数据,进行简单的转换,就直接把数据输出。 但是我们在之前都是以事件为驱动,等于说是来了一条数据,我就处理一次,但是现在遇到的问题是: 我们可以简单的把wordCount的需求比做公司的订单金额,也就是订单金额会随着订单的增加而只增不减,那么如果运营部门提了以下需求: 每有1000条订单就输出一次这1000条订单的总金额每5分钟输出一次刚刚过去这5分钟的订单总金额每3秒输出一次最近5分钟内的累计成交额连续2条订单的间隔时间超过30秒就按照这个时间分为2组订单,输出前一组订单的总金额那么面对这个需求,因为时间一直是流动的,大家有什么想法? 基于这些需求,我们来讲一下flink的窗口。 窗口窗口:无论是hive中的开窗函数,还是Spark中的批次计算中的窗口,还是我们这里讲的窗口,本质上都是对数据进行划分,然后对划分后的数据进行计算。 那么Windows是处理无限流的核心。Windows将流分成有限大小的“存储桶”,我们可以在其上应用计算。 在flink中,窗口式Flink程序一般有2类, 键控流stream .keyBy(...) <- keyed versus non-keyed windows .window(...) <- required: "assigner" [.trigger(...)] <- optional: "trigger" (else default trigger) [.evictor(...)] <- optional: "evictor" (else no evictor) [.allowedLateness(...)] <- optional: "lateness" (else zero) [.sideOutputLateData(...)] <- optional: "output tag" (else no side output for late data) .reduce/aggregate/fold/apply() <- required: "function" [.getSideOutput(...)] <- optional: "output tag"非键控流stream .windowAll(...) <- required: "assigner" [.trigger(...)] <- optional: "trigger" (else default trigger) [.evictor(...)] <- optional: "evictor" (else no evictor) [.allowedLateness(...)] <- optional: "lateness" (else zero) [.sideOutputLateData(...)] <- optional: "output tag" (else no side output for late data) .reduce/aggregate/fold/apply() <- required: "function" [.getSideOutput(...)] <- optional: "output tag"唯一的区别是:对键控流的keyBy(…)调用window(…),而非键控流则是调用windowAll(…)。 ...

June 29, 2020 · 4 min · jiezi

免费下载-阿里云实时计算整体解决方案白皮书重磅发布

随着信息化程度的加深,大数据已成为国家基础性战略资源,掌握和运用大数据的能力正日益成为衡量国家和地区经济社会发展程度的重要标志。同时,以大数据、人工智能为代表的核心技术正飞速发展,逐渐成为推动整个产业运行和转型升级的核心驱动力量,各个传统产业也随之走上智能化升级的道路。 如何构建完整的数据体系,充分挖掘数据价值,构建企业核心竞争力正逐渐成为各个行业升级转型的关键所在。 随着阿里云实时计算在各行各业丰富场景中的应用,实时计算赢得了金融、物流、广告、IoT等行业一线企业的一致认可。为更好的助力各行业企业实现企业数字化转型,为企业的创新、重构核心竞争力提供坚实支撑;阿里云实时计算重磅推出金融、物流、IoT、广告等行业解决方案白皮书。 <p style="text-align:center"><font size=5>点击免费下载:《阿里云实时计算物流行业解决方案》</font><font size=5>《阿里云实时计算金融行业解决方案》</font><font size=5>《阿里云实时计算广告行业解决方案》</font><font size=5>《阿里云实时计算IoT行业解决方案》</font> 实时计算(Alibaba Cloud RealtimeCompute,Powered by Ververica)是阿里云提供的基于 Apache Flink 构建 的企业级大数据计算平台。实时计算在 PB 级别的数据集上可以支持亚秒级别的处理延时,赋能用户标准实时数 据处理流程和行业解决方案;在支持 Datastream API 作业开发的同时,提供了批流统一的 Flink SQL,弥补了社 区 SQL 功能缺失,使得 BI 场景下的开发变得更加简单;丰富的上下游 connector 保证了与用户已使用的大数据组 件无缝对接;智能作业调优和诊断功能进一步简化了用户的开发和使用。同时,实时计算在 Apache Flink 核心功能的基础上还增强了企业用户所关注的集群稳定、性能优化、安全控制、系统监 控和作业管理等。 如果您对阿里云实时计算感兴趣,想了解更多实时计算功能与场景应用,点击下方链接可了解更多: https://help.aliyun.com/produ... <p style="text-align:center">▼ 阿里云实时计算交流群 ▼</p> <p style="text-align:center"></p>

June 18, 2020 · 1 min · jiezi

数仓系列-深入解读-Flink-资源管理机制

作者:宋辛童(五藏)整理:王文杰(Flink 社区志愿者) 摘要:本文根据 Apache Flink 系列直播整理而成,由阿里巴巴高级开发工程师宋辛童分享。文章主要从基本概念、当前机制与策略、未来发展方向等三个方面帮助开发者深入理解 Flink 的资源管理机制。 基本概念当前机制与策略未来发展方向Tips:点击「下方链接」可查看更多数仓系列视频~https://ververica.cn/develope... 1. 基本概念1.1 相关组件我们今天介绍的主要是与 Flink 资源管理相关的组件,我们知道一个 Flink Cluster 是由一个 Flink Master 和多个 Task Manager 组成的,Flink Master 和 Task Manager 是进程级组件,其他的组件都是进程内的组件。 图1. Flink 资源管理相关组件 如图1所示,一个 Flink Master 中有一个 Resource Manager 和多个 Job Manager ,Flink Master 中每一个 Job Manager 单独管理一个具体的 Job ,Job Manager 中的 Scheduler 组件负责调度执行该 Job 的 DAG 中所有 Task ,发出资源请求,即整个资源调度的起点;JobManager 中的 Slot Pool 组件持有分配到该 Job 的所有资源。另外,Flink Master 中唯一的 Resource Manager 负责整个 Flink Cluster 的资源调度以及与外部调度系统对接,这里的外部调度系统指的是 Kubernetes、Mesos、Yarn 等资源管理系统。 ...

June 18, 2020 · 3 min · jiezi

实时即未来一个小微企业心中的流计算

摘要:本文由墨芷技术团队唐铎老师分享,主要讲述其技术团队内部引入流计算的整个过程,包括最初的决策、期间的取舍以及最终落地,一路走来他们的思考、感悟以及经验分享。 初识 Flink为什么一定要上 Flink一个小例子总结Tips:“实时即未来”在很多人的眼中可能只是一句口号,但在墨芷,这是他们亲手创造的故事。 大家好,我们是浙江墨芷信息科技有限公司,一个刚刚满3年的创业团队,主营业务是电商代运营,目前是淘宝四星级服务商。 我们的核心团队先后服务于国内知名女装、家电、母婴、男装、童装、珠宝饰品、化妆品等多个品类知名品牌商,具有丰富的品牌运营管理经验,服务过的品牌均在行业前列。 主营业务围绕泛时尚领域(服装、婴童、美妆、生活家居、珠宝饰品)互联网平台品牌运营及全网品牌推广,涉及品牌定位与推广、电商运营、商品企划与经营、视觉设计、营销推广、顾客服务、仓储物流等综合端到端服务。 本文将分享墨芷与流计算结缘的故事。 01 初识Flink第一次接触 Flink 流计算是在18年9月的云栖大会上,大沙老师与在场以及线上的开发者们分享 Flink,会场座无虚席,会场门外还围着三五层的听众。虽然老师的讲解时间不长,听的也是一知半解,却有种很强烈感觉,“实时,即是未来”。 从云栖小镇回来后,跟自己的团队讨论了一下,大家决定向 Flink 开进,但前进的难度是我们没有预料到的。那个时候学习资料很少,一本《Flink 基础教程》被我们翻来复去的看,动手实操门槛较高,进度非常不理想。 图1 云栖大会流计算分会场 19年3月,有幸参加了在杭州举行的 Flink 用户交流会,报名时只是抱着学习的心态去旁听,但到现场后震惊了,参会的不仅是 Flink 的深度用户,更甚的是每位都来自估值百亿以上的大厂。无论是讨论的内容还是出身都让我们感到自卑。 回来之后的第二天,一起去的五个人不约而同的都到公司加班,即便不说透,这次会议给大家带来的心丽冲击是巨大的,也促使了我们下定决心,即便难度再大也要把 Flink 应用起来。 在此一个月之后,我们用 Java 编写的 Flink Job 上线了,即便实现的功能很简单,但这是我们坚实的一小步。 图2 社区里广为流传的一张照片 2020年年初,疫情肆虐,团队人员变动,客观条件使我们不得不放弃之前用 Java 编写的一切,转投 Python。这个决定极其艰难,我们很清楚,一切将回到原点。 但我们与 Flink 的缘分还没结束。刚好,我们看到社区发起了 PyFlink 扶持计划,于是邮件咨询,也有幸被眷顾。接下来的一个月时间,我们在金竹、付典、断尘几位老师的帮助下,将原有的 Flink Job 迁移到了 PyFlink 上,同时也带着需求去学习 PyFlink 的特性。这才有了与大家分享学习成果的机会。 02 为什么一定要上Flink说到这,一定有同行问,为啥一个小微企业还要上流计算,用得上吗? 我们面临的是若干个严峻的事实: 人员数量的膨胀带来了成倍的开销。公司用了3年时间,将团队规模扩张到的150人,在嘉兴这个小城市里这是很不容易的一件事,而且主业是电商代运营,这种工作更像我们软件行业的项目外包。一提到外包,同行们肯定会联想到人力配备,简单讲,有项目做才能养活人,没项目的话,闲置的人力成本就是亏本买卖。人效提升困难,规定再严格的 KPI 也会有瓶颈。同事们每天上班第一件事就是发前一天的销售业绩,只是这个小小的日报,就要耗费半个小时的时间,数据的时效又是“T + 1”,略显滞后。在做直通车推广时,由于同事的疏忽,一些已经不再需要付费推广或可以降低竞价的商品还在按照原计划持续烧钱,人工监控很难及时地发现这些问题。作为 IT 规划的主导者,一直以来我都希望可以依托团队在电商经营上丰厚的经验及操盘能力,这样目标很明了,就是搭建我们自己的数据实时决策平台。 决策,我们暂且拆开来看,决断与策略。团队自有经验及做事的判断逻辑,我们把它划到策略一侧,现在我们缺少的是“决断的能力”,决断既要考虑准确性,又要顾及时效性,当然,如果决断时能渐进地优化策略也是极好的。所以我们大致规划了图3中的架构。从下至上依次为我们的 DataSource(数据源),Swarm(多源数据收集平台),DW(数据仓库),NB(电商离线数据中台),Radical(电商数据决策平台)。数据逐层向上被收集,保存,计算,展现,应用,而Flink在数据的生命周期内担当实时计算的重要任务。 还记得电商场景下商家被薅羊毛的新闻吗? 目前没有任何一款电商 ERP 有针对这方面的功能设计。如果可以编写一个基于 Flink 流计算的实时监控异常销售情况的小插件,在获取到订单中的实付金额去比对之前的商品价格,再结合最新的库存计算后判断得出结果,适时弹出告警,那样的悲剧是否可以避免? ...

June 18, 2020 · 5 min · jiezi

Flink作业问题分析和调优实践

摘要:本文主要分享 Flink 的 CheckPoint 机制、反压机制及 Flink 的内存模型。对这3部分内容的熟悉是调优的前提,文章主要从以下几个部分分享: 原理剖析性能定位经典场景调优内存调优Checkpoint 机制1.什么是 checkpoint简单地说就是 Flink 为了达到容错和 exactly-once 语义的功能,定期把 state 持久化下来,而这一持久化的过程就叫做 checkpoint ,它是 Flink Job 在某一时刻全局状态的快照。 当我们要对分布式系统实现一个全局状态保留的功能时,传统方案会引入一个统一时钟,通过分布式系统中的 master 节点广播出去给每一个 slaves 节点,当节点接收到这个统一时钟时,它们就记录下自己当前的状态即可。 但是统一时钟的方式也存在一定的问题,某一个 node 进行的 GC 时间比较长,或者 master 与 slaves 的网络在当时存在波动而造成时钟的发送延迟或者发送失败,都会造成此 slave 和其它的机器出现数据不一致而最终导致脑裂的情况。如果我们想要解决这个问题,就需要对 master 和 slaves 做一个 HA(High Availability)。但是,一个系统越是复杂,就越不稳定且维护成本越高。 Flink 是将 checkpoint 都放进了一个名为 Barrier 的流。 上图中就是一个 Barrier 的例子,从上游的第一个 Task 到下游的最后一个 Task,每次当 Task 经过图中蓝色的栅栏时,就会触发 save snapshot(快照)的功能。我们用一个例子来简单说明。 2.实例分析 这是一个简单的 ETL 过程,首先我们把数据从 Kafka 中拿过来进行一个 trans 的转换操作,然后再发送到一个下游的 Kafka ...

June 18, 2020 · 3 min · jiezi

深入分析-Flink-SQL-工作机制

作者 | 伍翀(云邪),阿里巴巴技术专家整理 | 陈婧敏(清樾),阿里巴巴技术专家 摘要:本文整理自 Flink Forward 2020 全球在线会议中文精华版,由 Apache Flink PMC 伍翀(云邪)分享,社区志愿者陈婧敏(清樾)整理。旨在帮助大家更好地理解 Flink SQL 引擎的工作原理。文章主要分为以下四部分: Flink SQL ArchitectureHow Flink SQL Works?Flink SQL OptimizationsSummary and FuturesTips:点击下方链接可查看作者分享的原版视频~ https://ververica.cn/develope... Apache Flink 社区在最近的两个版本(1.9 & 1.10 )中为面向未来的统一流批处理在架构层面做了很多优化,其中一个重大改造是引入了 Blink Planner,开始支持 SQL & Table API 使用不同的 SQL Planner 进行编译(Planner 的插件化)。 本文首先会介绍推动这些优化背后的思考,展示统一的架构如何更好地处理流式和批式查询,其次将深入剖析 Flink SQL 的编译及优化过程,包括: Flink SQL 利用 Apache Calcite 将 SQL 翻译为关系代数表达式,使用表达式折叠(Expression Reduce),下推优化(Predicate / Projection Pushdown )等优化技术生成物理执行计划(Physical Plan),利用 Codegen 技术生成高效执行代码。Flink SQL 使用高效的二进制数据存储结构 BinaryRow 加速计算性能;使用 Mini-batch 攒批提高吞吐,降低两层聚合时由 Retraction 引起的数据抖动;聚合场景下数据倾斜处理和 Top-N 排序的优化原理。 ...

June 18, 2020 · 5 min · jiezi

数仓大法好跨境电商-Shopee-的实时数仓之路

作者:黄良辉 本文讲述 Flink 在 Shopee 新加坡数据组(Shopee Singapore Data Team)的应用实践,主要内容包括: 实时数仓建设背景Flink 在实时数据数仓建设中结合 Druid、Hive 的应用场景实时任务监控Streaming SQL 平台化Streaming Job 管理未来规划优化方向建设背景Shopee 是东南亚与台湾领航电商平台,覆盖新加坡、马来西亚、菲律宾、台湾、印度尼西亚、泰国及越南七大市场,同时在中国深圳、上海和香港设立跨境业务办公室。 Shopee在2020年第一季的总订单量高达4.298亿,同比增长111.2%。根据App Annie, Shopee在 2020年第一季强势跻身全球购物类 App下载量前三名。同时斩获东南亚及台湾市场购物类 App 年度总下载量、平均月活数、安卓使用总时长三项冠军,并领跑东南亚两大头部市场,拿下印尼及越南年度购物类 App 下月活量双冠王。其中包括订单商品、物流,支付,数字产品等各方面的业务。为了支持这些互联网化产品,应对越来的越多的业务挑战,于是我们进行了数据仓库的设计和架构建设。 数据仓库挑战当前随着业务发展,数据规模的膨胀和商务智能团队对实时需求的不断增长,业务挑战越来越大: 业务维度而言,业务需求越来越复杂,有需要明细数据查询,又有实时各种维度聚合报表,实时标签培训和查询需求。同时大量业务共享了一些业务逻辑,造成大量业务耦合度高,重复开发。平台架构而言,当前任务越来越多,管理调度,资源管理,数据质量异常监控等也越来越重要。实时化也越来急迫,目前大量业务还是离线任务形式,导致凌晨服务负载压力巨大,同时基于 T+1(天、小时级)架构业务无法满足精细化、实时化运营需要。技术实现而言,现在实时业务大量采用 Spark Structured Streaming 实现,严重依赖 HBase 做 Stateful 需求,开发复杂;在异常故障事故,Task 失败,缺乏 Exactly Once 特性支持,数据易丢失、重复。为了解决上述问题,于是开始了 Flink 实时数仓的探索。 数据仓库架构为了支持这些互联网化产品不断增长的的数据和复杂的业务,Shopee 构建如下图数据仓库架构,从下到上层来看: 最底层是数据收集层,这一层负责实时数据,包括 Binlog、Service Log, Tracking Service Log,经过 Real-time Ingestion 团队数据将会被收集到 Kafka 、Hbase 中。Auto-Ingestion 团队负责数据库数离线日常收集到 HDFS。然后是存储层,这层主要是 Kafka 保存实时消息,加上 HDFS 保存 Hive 数据存储等,HBase 保存维度数据。在存储层上面是 Spark, Flink 计算引擎, Presto SQL 查询引擎。然后是调度管理层,各种资源管理,任务管理,任务调度,管理各种 Spark,Flink 任务。资源管理层上一层是 OLAP 数据存储层,Druid 用于存储时间序列数据,Phoenix(HBase)存储聚合报表数据、维度表数据、标签数据,Elastic Search 存储需要多维度字段索引的数据如广告数据、用户画像等。最上层是应用层,数据报表,数据业务服务,用户画像等。Flink 实时数据数仓实践 ...

June 18, 2020 · 3 min · jiezi

Flink-在快手实时多维分析场景的应用

作者:董亭亭、徐明 摘要:作为短视频分享跟直播的平台,快手有诸多业务场景应用了 Flink,包括短视频、直播的质量监控、用户增长分析、实时数据处理、直播 CDN 调度等。此次主要介绍在快手使用 Flink 在实时多维分析场景的应用与优化。主要内容包括: Flink 在快手应用场景及规模快手实时多维分析平台SlimBase-更省 IO、嵌入式共享 state 存储Tips:点击下方链接可查看作者原版PPT及分享视频~ https://ververica.cn/develope... Flink 在快手应用场景及规模首先看 Flink 在快手的应用场景和规模。 1. 快手应用场景 快手计算链路是从 DB/Binlog 以及 WebService Log 实时入到 Kafka 中,然后接入 Flink 做实时计算,其中包括实时数仓、实时分析以及实时训练,最后的结果存到 Druid、Kudu、HBase 或者 ClickHouse 里面;同时 Kafka 数据实时 Dump 一份到 Hadoop 集群,然后通过 Hive、MapReduce 或者 Spark 来做离线计算;最终实时计算和离线计算的结果数据会用内部自研 BI 工具 KwaiBI 来展现出来。 Flink 在快手典型的应用场景主要分为三大类: 80% 统计监控:实时统计,包括各项数据的指标,监控项报警,用于辅助业务进行实时分析和监控;15% 数据处理:对数据的清洗、拆分、Join 等逻辑处理,例如大 Topic 的数据拆分、清洗;5% 数据处理:实时业务处理,针对特定业务逻辑的实时处理,例如实时调度。 Flink 在快手应用的典型场景案例包括: 快手是分享短视频跟直播的平台,快手短视频、直播的质量监控是通过 Flink 进行实时统计,比如直播观众端、主播端的播放量、卡顿率、开播失败率等跟直播质量相关的多种监控指标;用户增长分析,实时统计各投放渠道拉新情况,根据效果实时调整各渠道的投放量;实时数据处理,广告展现流、点击流实时 Join,客户端日志的拆分等;直播 CDN 调度,实时监控各 CDN 厂商质量,通过 Flink 实时训练调整各个 CDN 厂商流量配比。2. Flink 集群规模 ...

June 18, 2020 · 3 min · jiezi

Apache-Flink-误用之痛

摘要:本文根据 Flink Forward 全球在线会议 · 中文精华版整理而成,围绕着项目的开始、需求分析、开发,以及测试、上线、运维整个生命周期展开,介绍了 Apache Flink 实践中的一些典型误用情况,并给出了相应的更优实践方案。 Flink 实践中最首当其冲的误用就是不按迭代开发的过程操作。最佳实践应该遵循迭代开发的步骤进行,包含以下几个阶段: 项目开始涉及分析开发测试上线维护1. 项目开始在开始开发前,我们需要选择正确的切入方式,以下几种往往是最糟糕的开始: a) 从一个具有挑战性的用例开始(端对端的 Exactly-once、大状态、复杂的业务逻辑、强实时SLA的组合) b) 之前没有流处理经验 c) 不对团队做相关的培训 d) 不利用社区在开发的过程中,其实要认认真真的来规划我们的切入点,首先,要从简单的任务开始循序渐进。要有一定的大数据和流处理的知识积累,尽量参加一些培训,也要利用好社区资源。基于这样的想法,我们就能很快找到切入点。 怎么样去做?社区提供了很多的培训,包括 Flink Forward 和 Vererica 网站上有各种培训课程,大家可以去看。同时,可以充分利用社区。社区还建立了中文的邮件列表,大家可以充分利用中文邮件列表来解决手头的疑难杂症。另外,Stack Overflow 也是个提问的好地方,但在提问前尽量去看一看已有的提问,做到心中有数。 邮件列表:user@flink.apache.com/user-zh@flink.apache.org Stack Overflow:www.stackoverflow.com 2. 设计分析方案设计中的一些常见错误思维,往往是由于没有充分思考需求导致的,比如: a) 不考虑数据一致性和交付保证 b) 不考虑业务升级和应用改进 c) 不考虑业务规模问题 d) 不深入思考实际业务需求我们要认真分析需求,同时认真考虑实际交付情况。提到一致性和交付保障,其实可以通过几个问题来引导大家完成这件事,如下图所示: 第1个问题,是否在乎数据的丢失? 如果不在乎,你可以没有 Checkpoint。 第2个问题,是否在乎结果的正确性? 在很多的场景里面,我们非常关注结果的正确性,比如金融领域,但是另外一些场景比如监控或其他简单的使用场景仅需要一个概要的数据统计。如果不在乎结果的正确性,可以考虑用 at-least-once 的模式配置并使用可回放的数据源。相反,如果结果的准确性十分重要,且下游不关心重复记录,那么仅需设置 exactly-once 模式并使用可回放的数据源。如果下游要求数据不能重复,哪怕数据正确也只能发送一次,这种时候就对 sink 有更进一步的限制,在 exactly-once 的模式下,使用可回放的数据源,并且 sink 需要支持事务。 带着这样的思维方式分析业务,才能非常清晰地知道,怎么去使用 Flink,进而避免一些糟糕的事情发生。 完成分析之后,最终目的是什么?我们为什么要有这种选择,而不是一上来就选一个最好的方案? 因为世界上永远没有“最好”,这里的核心因素就是延迟,要根据业务的延迟和准确性需求来均衡去做选择。 当需求都分析好之后,还需要去思考应用是否需要升级。从一个正常的 Flink 作业来讲,我们有几个问题要考虑。第一个,Flink 作业一般都有状态读取,做升级时需要有 savepoint 机制来保障,将状态存储保留在远端,再恢复到新的作业上去。很多场景下都会有升级的需求,这简单列了几点: ...

June 18, 2020 · 2 min · jiezi

记录一次Flink作业异常的排查过程

本文来自: PerfMa技术社区PerfMa(笨马网络)官网 最近2周开始接手apache flink全链路监控数据的作业,包括指标统计,业务规则匹配等逻辑,计算结果实时写入elasticsearch. 昨天遇到生产环境有作业无法正常重启的问题,我负责对这个问题进行排查跟进。 第一步,基础排查首先拿到jobmanager和taskmanager的日志,我从taskmanager日志中很快发现2个基础类型的报错,一个是npe,一个是索引找不到的异常 elasticsearch sinker在执行写入数据的前后提供回调接口让作业开发人员对异常或者成功写入进行处理,如果在处理异常过程中有异常抛出,那么框架会让该task失败,导致作业重启。 npe很容易修复,索引找不到是创建索引的服务中的一个小bug,这些都是小问题。 重点是在日志中我看到另一个错误: java.lang.OutOfMemoryError: unable to create new native thread at java.lang.Thread.start0(Native Method) at java.lang.Thread.start(Unknown Source) at org.apache.flink.runtime.io.network.api.writer.RecordWriter.<init>(RecordWriter.java:122) at org.apache.flink.runtime.io.network.api.writer.RecordWriter.createRecordWriter(RecordWriter.java:321) at org.apache.flink.streaming.runtime.tasks.StreamTask.createRecordWriter(StreamTask.java:1202) at org.apache.flink.streaming.runtime.tasks.StreamTask.createRecordWriters(StreamTask.java:1170) at org.apache.flink.streaming.runtime.tasks.StreamTask.<init>(StreamTask.java:212) at org.apache.flink.streaming.runtime.tasks.StreamTask.<init>(StreamTask.java:190) at org.apache.flink.streaming.runtime.tasks.OneInputStreamTask.<init>(OneInputStreamTask.java:52) at sun.reflect.GeneratedConstructorAccessor4.newInstance(Unknown Source) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source) at java.lang.reflect.Constructor.newInstance(Unknown Source) at org.apache.flink.runtime.taskmanager.Task.loadAndInstantiateInvokable(Task.java:1405) at org.apache.flink.runtime.taskmanager.Task.run(Task.java:689) at java.lang.Thread.run(Unknown Source)这种异常,一般是nproc设置太小导致的,或者物理内存耗尽,检查完ulimit和内存,发现都很正常,这就比较奇怪了。 第二步、分析jstack和jmapperfma有一个产品叫xland,我也是第一次使用,不得不说,确实牛逼,好用!首先把出问题的taskmanager的线程栈信息和内存dump出来,具体命令: jstatck pid > 生成的文件名jmap -dump:format=b,file=生成的文件名 进程号接着把这两个文件导入xland,xland可以直接看到线程总数,可以方便搜索统计线程数、实例个数等等 最先发现的问题是这个taskmanager 线程总数竟然有17000+,这个数字显然有点大,这个时候我想看一下,哪一种类型的线程比较大,xland可以很方便的搜索,统计,这时候我注意到有一种类型的线程非常多,总数15520 更上层的调用信息看不到了,只看到来自apache http client,根据作业流程,首先想到的就是es sinker的RestHighLevelClient用到这个东西 ...

June 17, 2020 · 1 min · jiezi

Flink流处理API代码详解含多种SourceTransformSink案例Flink学习入门二

大家好,我是后来,我会分享我在学习和工作中遇到的点滴,希望有机会我的某篇文章能够对你有所帮助,所有的文章都会在公众号首发,欢迎大家关注我的公众号" 后来X大数据 ",感谢你的支持与认可。又是一周没更文了,上周末回运城看牙去了,一直都在路上,太累了。说回正题,关于flink的入门在上一篇已经讲过了。 今天主要说一下关于流处理的API,这一篇所有的代码都是scala。 那么我们还得回到上次的WordCount代码,Flink程序看起来像转换数据集合的常规程序。每个程序都包含相同的基本部分: 获得execution environment加载/创建初始数据指定对此数据的转换指定将计算结果放在何处触发程序执行 获取执行环境所以要想处理数据,还得从获取执行环境来说起。StreamExecutionEnvironment是所有Flink程序的基础,所以我们来获取一个执行环境。有以下3种静态方法 getExecutionEnvironment()createLocalEnvironment()createRemoteEnvironment(host: String, port: Int, jarFiles: String*) //获取上下文环境val contextEnv = StreamExecutionEnvironment.getExecutionEnvironment//获取本地环境val localEnv = StreamExecutionEnvironment.createLocalEnvironment(1)//获取集群环境val romoteEnv = StreamExecutionEnvironment.createRemoteEnvironment("bigdata101",3456,2,"/ce.jar")但一般来说,我们只需要使用第一种getExecutionEnvironment(),因为它将根据上下文执行正确的操作;也即是说,它会根据查询运行的方式决定返回什么样的运行环境,你是IDE执行,它会返回本地执行环境,如果你是集群执行,它会返回集群执行环境。 预定义的数据流源好了,获取到环境之后,我们就开始获取数据源,flink自身是支持多数据源的,首先来看几个预定义的数据流源 基于文件 readTextFile(path)- TextInputFormat 逐行读取文本文件,并将其作为字符串返回,只读取一次。readFile(fileInputFormat, path) -根据指定的文件输入格式读取文件,只读取一次。但事实上,上面的2个方法内部都是调用的readFile(fileInputFormat, path, watchType, interval, pathFilter, typeInfo)我们来看看源码:我们选择其中第一个比较简单的方法进入,就看到了下图,发现其实上述的2种方法最终都会落到这个readFile(fileInputFormat, path, watchType, interval, pathFilter)方法上,只不过后面的参数都是默认值了。所以,这些参数当然也可以自己指定。好了,这个方法大家也不常用,所以就简单介绍下,有需要的小伙伴自己试试这些后面的参数。 基于套接字socketTextStream-从套接字读取。元素可以由定界符分隔。这里提到了套接字,这个我在终于懂了TCP协议为什么是可靠的,计算机基础(六)之运输层是讲过的,这里再说一下:套接字 socket = {IP地址 : 端口号},示例:192.168.1.99 :3456代码使用如下: val wordDS: DataStream[String] = contextEnv.socketTextStream("bigdata101",3456)套接字是抽象的,只是为了表示TCP连接而存在。 基于集合fromCollection(Seq)-从Java Java.util.Collection创建数据流。集合中的所有元素必须具有相同的类型。fromCollection(Iterator)-从迭代器创建数据流。该类指定迭代器返回的元素的数据类型。fromElements(elements: _*)-从给定的对象序列创建数据流。所有对象必须具有相同的类型。fromParallelCollection(SplittableIterator)-从迭代器并行创建数据流。该类指定迭代器返回的元素的数据类型。generateSequence(from, to) -并行生成给定间隔中的数字序列。这些预设的数据源使用的也不是很多,可以说是几乎不用。所以大家可以自己尝试一下。当然注意,如果使用 fromCollection(Seq),因为是从Java.util.Collection创建数据流,所以如果你是用scala编程,那么就需要引入 隐式转换 import org.apache.flink.streaming.api.scala._获取数据源Source大家也能发现,以上的方法几乎都是从一个固定的数据源中获取数据,适合自己测试,但在生产中肯定是不能使用的,所以我们来看看正儿八经的数据源:官方支持的source与sink如下: Apache Kafka(源/接收器)Apache Cassandra(接收器)Amazon Kinesis Streams(源/接收器)Elasticsearch(接收器)Hadoop文件系统(接收器)RabbitMQ(源/接收器)Apache NiFi(源/接收器)Twitter Streaming API(源)Google PubSub(源/接收器)加粗的3个日常中比较常用的,那么也发现其实数据源只有kafka,sink有ES和HDFS,那么我们先来说说kafka Source,关于Kafka的安装部署这里就不讲了,自行Google。我们来贴代码与分析。 ...

June 17, 2020 · 4 min · jiezi

Flink-110-Container-环境实战

作者 | 唐云(茶干),阿里巴巴高级开发工程师整理 | 张壮壮(Flink 社区志愿者) 摘要:本文根据 Apache Flink 系列直播整理而成,由阿里巴巴高级开发工程师唐云(茶干)分享。主要内容如下: 容器管理系统的演变Flink on K8S introFlink on K8S实战分享DemoTips:点击下方可查看更多 1.10 系列直播视频~ 1.10系列直播: https://ververica.cn/develope... 本文第一部分将简明扼要地介绍容器管理系统的演变;第二部分是 Flink on K8S 简介,包括集群的部署模式调度原理等等;第三部分是我们这一年以来关于 Flink on K8S 的实战经验分享,介绍我们遇到的问题、踩过的坑;最后一部分是 Demo,将手把手演示集群部署、任务提交等等。 容器管理系统的演变 首先是以一个 Kubernetes 非内核开发人员的角度去探讨其和 YARN 之间的关系。众所周知,Apache Hadoop YARN 可能是在国内用途最广的一个调度系统,主要原因在于 Hadoop HDFS 在国内或者是在整个大数据业界,是一个使用最广泛的存储系统。因此,基于其上的 YARN 也自然而然成为了一个广为使用的一个调度系统,包括早期的 Hadoop MapReduce。随着 YARN 2.0 之后 Framework 的开放,Spark on YARN 以及 Flink on YARN 也可以在 YARN 上进行调度。 当然 YARN 本身也存在一定的局限性。 如资源隔离,因为 YARN 是以 Java 为基础开发的,所以它很多资源方面的隔离有一些受限。另外对 GPU 支持不够,当然现在的 YARN 3.0 已经对 GPU 的调度和管理有一定支持,但之前版本对GPU 支持不是很好。所以在 Apache 基金会之外,CNCF 基金会基于 Native Cloud 调度的 Kubernetes 出现了。 ...

June 10, 2020 · 6 min · jiezi

如何从-0-到-1-参与-Flink-社区

整理:许世伟、秦佳奇(Flink 社区志愿者)校对:秦佳奇、许世伟(Flink 社区志愿者) 摘要:本文根据 Apache Flink 系列直播整理而成,由 Apache Flink Committer,阿里巴巴技术专家付典分享。主要内容如下: 参与开源社区的意义参与开源社区的原则如何参与 Flink 社区如何提交第一个 PRTips:点击下方链接可回顾更多社区成长类教程~ 社区成长: https://ververica.cn/develope...本文首先介绍为何要参与开源社区以及在参与开源社区的过程中需要注意什么,然后重点介绍如何参与 Flink 社区以及在社区里面提交 PR 的整个流程。 一、参与开源社区的意义 目前很多大公司都纷纷拥抱开源,从最初只是开始参与开源社区,到近年科技巨头们又陆续将自己的一些项目开源化。作为一个码农来说,参与开源社区肯定对于自己的职业发展是有着巨大好处的。 另外,参与开源社区,你可以和相关领域里面最优秀的人一起工作交流,快速的提升自己。不管在技术讨论、还是贡献代码方面,所有的过程都是公开的。参与到开源社区的讨论交流中,我相信你看到的不仅是最终代码所呈现出来的结果,而且还能了解到更多的设计思想,做到知其然,知其所以然。在社区中,每个人都希望将自己最好的一面给展示出来,这个无疑是促进自身不断进步的动力。 在享受开源社区带给我们好处的同时,我们也可以反哺开源社区。改了某几行代码,或者修正了文档上面某个小错误,这些都是在为开源社区贡献自己的力量。我们与社区之间要相互 build trust,可以从简单的贡献做起。不要因为对某个领域不熟悉或者说贡献太小而有放弃的想法,这是不太对的。 当我们为开源社区做的贡献足够多之后,可能会得到社区的认可,成为社区的 Contributor、Committer、PMC、Apache Member 等等,这是社区对我们个人能力的一种认可。 总结而言,参与开源的意义在于: 顺势而为无国界导师为世界带来微小而美好的变化业界身份证二、参与开源社区的原则参与开源社区,有两个基础且重要的原则需要大家注意: 公开沟通公开沟通是参与开源社区很重要的原则。任何问题及所有的讨论记录最好都公开化,做到可追溯,尽量避免私下讨论,这样才能更好地发挥社区的力量。 保持尊重在社区里面,要保持相互尊重。社区的贡献是以自愿为基本原则的,在社区的讨论中要避免情绪化,绝对禁止人身攻击。 三、如何参与 Flink 社区1.订阅邮件列表 关于邮件列表的更多具体信息:https://flink.apache.org/comm...参与 Flink 社区,先从订阅邮件列表入手,上面的表格是 Flink 社区常用的几个邮件及邮件用途信息,建议大家先订阅这几个邮件。订阅方式如下: 1.发送邮件到相应的邮件列表进行订阅 xxx-subscribe@flink.apache.org xxx-unsubscribe@flink.apache.org2.回复确认邮件2.参与用户邮件列表讨论■ 2.1 用户邮件提问注意事项事先搜索有无类似问题这几个地方可能有你想要的答案: Apache Pony: https://lists.apache.org/list... Nabble: http://apache-flink-user-mail... StackOverFlow: https://stackoverflow.com/que...问题描述应尽可能详细例如:使用的 Flink 版本、planner、和问题相关的配置、异常 log、复现问题的步骤;如果可能的话,提供可复现问题的最小功能代码(尽可能去除无关代码);尽量不要在邮件里直接贴图片,如果确实有需要,先将图片上传到外部网站,然后把图片链接贴到邮件里。 避免将 Flink 使用问题发到开发邮件尽量用英文在 user 邮件中讨论■ 2.2 用户邮件提问正反面示例反面示例❌ 缺少Flink版本❌ 缺少所用planner❌ 缺少示例代码 ...

June 10, 2020 · 2 min · jiezi

数仓系列-Flink-窗口的应用与实现

作者 | 张俊(OPPO大数据平台研发负责人)整理 | 祝尚(Flink 社区志愿者)校对 | 邹志业(Flink 社区志愿者) 摘要:本文根据 Apache Flink 系列直播整理而成,由 Apache Flink Contributor、OPPO 大数据平台研发负责人张俊老师分享。主要内容如下: 整体思路与学习路径应用场景与编程模型工作流程与实现机制Tips:点击「下方链接」可查看更多数仓系列直播视频~ <u>数仓系列直播: </u>https://ververica.cn/develope...整体思路与学习路径 当我们碰到一项新的技术时,我们应该怎样去学习并应用它呢?在我个人看来,有这样一个学习的路径,应该把它拆成应用和实现两块。首先应该从它的应用入手,然后再深入它的实现。 应用主要分为三个部分,首先应该了解它的应用场景,比如窗口的一些使用场景。然后,进一步地我们去了解它的编程接口,最后再深入了解它的一些抽象概念。因为一个框架或一项技术,肯定有它的编程接口和抽象概念来组成它的编程模型。我们可以通过查看文档的方式来熟悉它的应用。在对应用这三个部分有了初步的了解后,我们就可以通过阅读代码的方式去了解它的一些实现了。 实现部分也分三个阶段,首先从工作流程开始,可以通过 API 层面不断的下钻来了解它的工作流程。接下来是它整体的设计模式,通常对一些框架来说,如果能构建一个比较成熟的生态,一定是在设计模式上有一些独特的地方,使其有一个比较好的扩展性。最后是它的数据结构和算法,因为为了能够处理海量数据并达到高性能,它的数据结构和算法一定有独到之处。我们可以做些深入了解。 以上大概是我们学习的一个路径。从实现的角度可以反哺到应用上来,通常在应用当中,刚接触某个概念的时候会有一些疑惑。当我们对实现有一些了解之后,应用中的这些疑惑就会迎刃而解。 为什么要关心实现举个例子: 看了这个例子我们可能会有些疑惑: ReduceFunction 为什么不用计算每个 key 的聚合值?当 key 基数很大时,如何有效地触发每个 key 窗口计算?窗口计算的中间结果如何存储,何时被清理?窗口计算如何容忍 late data ?当你了解了实现部分再回来看应用这部分,可能就有种醍醐灌顶的感觉。 应用场景与编程模型实时数仓的典型架构 ■ 第一种最简单架构,ODS 层的 Kafka 数据经过 Flink 的 ETL 处理后写入 DW 层的 Kafka,再通过 Flink 聚合写入 ADS 层的 MySQL 中,做这样一个实时报表展现。 缺点:由于 MySQL 存储数据有限,所以聚合的时间粒度不能太细,维度组合不能太多。 ■ 第二种架构相对于第一种引入了 OLAP 引擎,同时也不用 Flink 来做聚合,通过 Druid 的 Rollup 来做聚合。 ...

June 10, 2020 · 3 min · jiezi

直播-阿里快手Databricks网易云音乐国内外大数据大佬齐聚一堂要聊啥

一线开发者同学一直面临着巨大的学习压力,除了需要解决业务上线后日常神出鬼没的bug与难题,还得面对开源软件不断发版更新导致的措手不及。 <p style="text-align:center">于是<p style="text-align:center">黑眼圈日益浓重稀疏的头发间距更大皮肤越来越干燥最后直接躺平</p> <p style="text-align:center">“实在是学不动了!!!”</p> 但是,如果每次发新版的软件都能帮你圈一下重点,再搭配一个详细解读,把新增功能、重大变更、整体优势都一一讲解,这种体验会不会很棒? 6月14日,阿里巴巴计算平台事业部联合阿里云开发者社区共同举办的大数据+AI Meetup 系列第一季即将重磅开启,此次 Meetup 邀请了来自阿里巴巴、Databricks、快手、网易云音乐等国内外多位技术专家齐聚一堂,与你探讨大数据及AI领域的热门话题! Meetup 亮点Flink、Spark、Alink 等大数据热门开源软件核心开发者帮你圈出最新版本重点实时数仓、数据湖、HSAP 架构能干啥一次讲清楚更有一线生产环境实战,春晚快手项目、网易云音乐 Flink + Kafka 落地实践的独家宝贵经验分享<p style="text-align:center">▼ Meetup 完整议程 ▼</p><p style="text-align:center"></p> 本文将分享此次 Meetup 上午半场3位资深技术专家的详细主题简介。 01 深入研究 Apache Spark 3.0 的新功能李潇 | Databricks Spark 研发部主管 演讲简介:Apache Spark 3.0旨在实现更快、更轻松、更智能的目标,本次发布提供了3000多种已解决的JIRA。涵盖以下功能: accelerator-aware scheduling, adaptive query execution, dynamic partition pruning, join hints, new query explain, better ANSI compliance, observable metrics, new UI for structured streaming, new built-in functions, new unified interface for Pandas UDF, and various enhancements in the built-in data sources [e.g., parquet, ORC and JDBC]. ...

June 10, 2020 · 1 min · jiezi

一文详解Flink-ExactlyOnce

前言Flink的 ”精确一次“ 处理语义是,Flink提供了一个强大的的语义保证,也就是说在任何情况下都能保证数据对应用的效果只有一次,不会多也不会少。 那么Flink是如何实现”端到端的精确一次处理“语义的呢?其实做到端到端的精确一次处理主要考虑两个方面: 怎么保证数据不丢失怎么保证数据不重复背景通常情况下,流式计算系统都会为用户提供数据处理的可靠模式功能,用来表明在实际生产运行中会对数据处理做哪些保障。一般来说,流处理引擎通常为用户的应用程序提供三种数据处理语义:最多一次,至少一次和精确一次。 最多一次(At-most-Once):这种语义理解起来很简单,用户的数据只会被处理一次,不管成功还是失败,不会重试也不会重发。至少一次(At-least-Once):这种语义下,系统会保证数据或事件至少被处理一次。如果发生错误或者丢失,那么会从源头重新发送一条然后进入处理系统。所以同一个事件或者消息会被处理很多次。精确一次(Exactly-Once):表示每一条数据只会被精确地处理一次,不多也不少。Exactly-Once是Flink,Spark等流处理系统的核心特性之一,这种语义会保证每一条消息只被流处理系统处理一次。”精确一次“语义是Flink 1.4.0版本引入的一个重要特性,而且,Flink号称支持”端到端的精确一次“语义。这里解释一下”端到端的精确一次“,它指的是Flink应用从Source端开始到Sink端结束,数据必须经过的起始点和结束点。Flink自身是无法保证外部系统”精确一次“语义的,所以Flink若要实现所谓”端到端的精确一次“的要求,那么外部系统必须支持”精确一次“语义,然后借助Flink提供的分布式快照和两阶段提交才能实现。 分布式快照机制Flink提供了失败恢复的容错机制,而这个容错机制的核心就是持续创建分布式数据流的快照来实现,这也为了数据不丢失提供了基础保障。 同Spark相比,Spark仅仅是针对Driver的故障恢复Checkpoint。而Flink的快照可以到算子级别,并且对全局数据也可以做快照。BarrierFlink分布式快照的核心元素之一是Barrier(数据栅栏),可以把Barrier简单理解成为一个标记,该标记是严格有序的,并且随着数据流往下流动。每个Barrier都带有自己的ID,Barrier极其轻量,并不会干扰正常的数据处理。 如上图所示,假如我们有一个从左向右流动的数据流,Flink会依次生成snapshot 1,snapshot 2,snapshot 3....Flink中有一个专门的”协调者“负责收集每个snapshot的位置信息,这个协调者也是高可用的。 Barrier会随着正常数据继续往下流动,每当遇到一个算子,算子会插入一个标识,这个标识的插入时间是上游所有的输入流都接受到了snapshot n。与此同时,当我们sink算子接收到所有上游流发送的Barrier时,那么就表明这一批数据处理完毕,Flink会向协调者发送确认消息,表明当前snapshot n完成了。当所有sink算子都确认这批数据成功处理后,那么本次的snapshot被标识完成。这里就会有一个问题,因为Flink运行在分布式环境中,一个operator的上游会有很多流,每个流的barrier n到达的时间不一致怎么办?这里Flink采取的措施是:快流等慢流 当其中一个流到的早,其他流到的晚。当第一个barrier n到来后,当前的operator会继续等待其他流的barrier n。直到所有barrier n到来后,operator才会把所有的数据向下发送。异步和增量按照上面介绍的机制,每次把快照存储到我们的状态后端时,如果同步进行就会阻塞正常任务,从而引入延迟。因此Flink在做快照存储的时候,可采用异步方式。 此外,由于checkpoint是一个全局状态,用户保存的状态可能非常大,多数达G或者T级别。在这种情况下,checkpoint的创建会非常慢,而且执行时占用的资源也比较多,因此Flink提出了增量快照,也就是说,每次都是进行的全量checkpoint,是基于上次进行更新的。两阶段提交上文提到基于checkpoint的快照操作,快照机制能够保证作业出现fail-over后可以从最新的快照进行恢复,即分布式快照机制可以保证flink系统内部的”精确一次“处理。但是我们实际生产系统中,Flink会对接各种各样的外部系统,比如kafka,HDFS等,一旦Flink作业出现失败,作业会重新消费旧数据,这个时候就会出现重新消费的情况,也就是重复消费。 针对这种情况,Flink在1.4版本引入了一个很重要得功能:两阶段提交,也即是TwoPhaseCommitSinkFunction。两阶段搭配特定得source和sink(特别是0.11版本kafka)使得”精确一次处理语义“成为可能。 在Flink中两阶段提交的实现方式被封装到TwoPhaseCommitSinkFunction这个抽象类中,我们只需要实现其中的beginTransaction,preCommit,commit,abort四个方法就可实现”精确一次“的处理语义,实现的方式可以在官网中查到。 beginTransaction,在开启事务之前,我们在目标文件系统的临时目录中创捷一个临时文件,后面在处理数据时将数据写入此文件。preCommit,在预提交阶段,刷写(flush)文件,然后关闭文件,之后就不能再写入文件了。我们还将为属于下一个检查点的任何后续写入启动新事务。commit,在提交阶段,我们将预提交的文件原子性的移动到真正的目标目录中,这里会增加输出数据可见性的延迟abort,在中止阶段,删除临时文件。 如上图所示,Kafka-Flink-Kafka案例实现”端到端精确一次“语义的过程,整个过程包括: 从kafka读取数据窗口聚合操作将数据写回kafka整个过程可以总结为下面四个阶段: 一旦Flink开始做checkpoint操作,那么就会pre-commit阶段,同时Flink JobManger会将检查点Barrier注入数据流中;当所有的Barrier在算子中成功进行一遍传递,并完成快照,则pre-commit阶段完成。等所有算子完成”预提交“,就会发起一个”提交“的动作,但是任何一个”预提交“失败都会导致Flink回滚到最近的checkpoint;pre-commit完成,必须要确保commit也要成功,上图中的Sink Operators和Kafka Sink会共同来保证。现状目前Flink支持的精确一次Source列表如下表所示,可以使用对应的connector来实现对应语义要求: 数据源语义保证备注Apache Kafkaexactly once需要对应的kafka版本AWS Kinesis Streamsexactly once RabbitMQat most once(v 0.10)/exactly once(v 1.0) Twitter Streamingat most once Collectionsexactly once Filesexactly once Socketsat most once 如果需要实现真正的”端到端精确一次语义“,则需要sink的配合。目前Flink支持的列表如下表所示: 写入目标语义保证备注HDFS rolling sinkexactly once依赖Hadoop版本Elasticsearchat least once kafka producerat least once/exactly once需要kafka 0.11及以上Cassandra sinkat least once/exactly once幂等更新AWS Kinesis Streamsat least once Flie sinksat least once Sockets sinksat least once Standard outputat least once Redis sinkat least once 总结由于强大的异步快照机制和两阶段提交,Flink实现了”端到端的精确一次语义“,在特定的业务场景下十分重要,我们在进行业务开发需要语义保证时,要十分熟悉目前Flink支持的语义特性。 ...

June 10, 2020 · 1 min · jiezi

使用mvn命令创建Flink-Maven项目

1.使用命令行创建Flink Maven Quickstart Scala项目 mvn archetype:generate \ -DarchetypeGroupId=org.apache.flink \ -DarchetypeArtifactId=flink-quickstart-scala \ -DarchetypeVersion=1.10.0 \ -DgroupId=org.apache.flink.quickstart \ -DartifactId=flink-scala-project \ -Dversion=0.1 \ -Dpackage=org.apache.flink.quickstart \ -DinteractiveMode=false2.pom.xml文件内容 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.apache.flink.quickstart</groupId> <artifactId>flink-scala-project</artifactId> <version>0.1</version> <packaging>jar</packaging> <name>Flink Quickstart Job</name> <url>http://www.myorganization.org</url> <repositories> <repository> <id>apache.snapshots</id> <name>Apache Development Snapshot Repository</name> <url>https://repository.apache.org/content/repositories/snapshots/</url> <releases> <enabled>false</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repositories> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <flink.version>1.10.0</flink.version> <scala.binary.version>2.11</scala.binary.version> <scala.version>2.11.12</scala.version> </properties> <dependencies> <!-- Apache Flink dependencies --> <!-- These dependencies are provided, because they should not be packaged into the JAR file. --> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-scala_${scala.binary.version}</artifactId> <version>${flink.version}</version> <scope>provided</scope> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-streaming-scala_${scala.binary.version}</artifactId> <version>${flink.version}</version> <scope>provided</scope> </dependency> <!-- Scala Library, provided by Flink as well. --> <dependency> <groupId>org.scala-lang</groupId> <artifactId>scala-library</artifactId> <version>${scala.version}</version> <scope>provided</scope> </dependency> <!-- Add connector dependencies here. They must be in the default scope (compile). --> <!-- Example: <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka-0.10_${scala.binary.version}</artifactId> <version>${flink.version}</version> </dependency> --> <!-- Add logging framework, to produce console output when running in the IDE. --> <!-- These dependencies are excluded from the application JAR by default. --> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.7.7</version> <scope>runtime</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> <scope>runtime</scope> </dependency> </dependencies> <build> <plugins> <!-- We use the maven-shade plugin to create a fat jar that contains all necessary dependencies. --> <!-- Change the value of <mainClass>...</mainClass> if your program entry point changes. --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.1.1</version> <executions> <!-- Run shade goal on package phase --> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> <artifactSet> <excludes> <exclude>org.apache.flink:force-shading</exclude> <exclude>com.google.code.findbugs:jsr305</exclude> <exclude>org.slf4j:*</exclude> <exclude>log4j:*</exclude> </excludes> </artifactSet> <filters> <filter> <!-- Do not copy the signatures in the META-INF folder. Otherwise, this might cause SecurityExceptions when using the JAR. --> <artifact>*:*</artifact> <excludes> <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"> <mainClass>org.apache.flink.quickstart.StreamingJob</mainClass> </transformer> </transformers> </configuration> </execution> </executions> </plugin> <!-- Java Compiler --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.1</version> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> <!-- Scala Compiler --> <plugin> <groupId>net.alchim31.maven</groupId> <artifactId>scala-maven-plugin</artifactId> <version>3.2.2</version> <executions> <execution> <goals> <goal>compile</goal> <goal>testCompile</goal> </goals> </execution> </executions> <configuration> <args> <arg>-nobootcp</arg> </args> </configuration> </plugin> <!-- Eclipse Scala Integration --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-eclipse-plugin</artifactId> <version>2.8</version> <configuration> <downloadSources>true</downloadSources> <projectnatures> <projectnature>org.scala-ide.sdt.core.scalanature</projectnature> <projectnature>org.eclipse.jdt.core.javanature</projectnature> </projectnatures> <buildcommands> <buildcommand>org.scala-ide.sdt.core.scalabuilder</buildcommand> </buildcommands> <classpathContainers> <classpathContainer>org.scala-ide.sdt.launching.SCALA_CONTAINER</classpathContainer> <classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer> </classpathContainers> <excludes> <exclude>org.scala-lang:scala-library</exclude> <exclude>org.scala-lang:scala-compiler</exclude> </excludes> <sourceIncludes> <sourceInclude>**/*.scala</sourceInclude> <sourceInclude>**/*.java</sourceInclude> </sourceIncludes> </configuration> </plugin> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>build-helper-maven-plugin</artifactId> <version>1.7</version> <executions> <!-- Add src/main/scala to eclipse build path --> <execution> <id>add-source</id> <phase>generate-sources</phase> <goals> <goal>add-source</goal> </goals> <configuration> <sources> <source>src/main/scala</source> </sources> </configuration> </execution> <!-- Add src/test/scala to eclipse build path --> <execution> <id>add-test-source</id> <phase>generate-test-sources</phase> <goals> <goal>add-test-source</goal> </goals> <configuration> <sources> <source>src/test/scala</source> </sources> </configuration> </execution> </executions> </plugin> </plugins> </build></project>3.使用”胖jar“打包 ...

June 6, 2020 · 2 min · jiezi

这场大数据AI-Meetup一次性安排了大数据当下热门话题

6月14日,阿里巴巴计算平台事业部与阿里云开发者社区共同举办的大数据+AI Meetup 系列第一季即将重磅开启,此次 Meetup 邀请了来自阿里巴巴、Databricks、快手、网易云音乐的7位技术专家,集中解读大数据当前热门话题!近年来,随着工业界多年的努力以及新兴技术的不断涌现,数据规模庞大的问题已逐步得到解决,而数据处理的时效性、数据价值的挖掘正成为企业及开发者面临的新的巨大挑战。也因此,大数据计算引擎、AI、数据仓库、数据湖等成为当前无可争议的热门话题。 当前大数据计算引擎各有千秋,如何选择适合自己的?数据仓库、数据湖、HSAP 架构,它们究竟能解决什么问题?机器学习平台那么多,好用的有哪些? 6月14日,阿里巴巴计算平台事业部与阿里云开发者社区共同举办的大数据+AI Meetup 系列第一季即将重磅开启,此次 Meetup 邀请了来自阿里巴巴、Databricks、快手、网易云音乐的7位技术专家,集中解读大数据当前热门话题! <p style="text-align:center">▼ 活动亮点 ▼</p> <p style="text-align:center">> 超豪华嘉宾阵容!多位资深技术专家在线分享对行业趋势的洞察!</p> <p style="text-align:center">> 极丰富干货分享!集结大数据热门议题,一次看完:数据处理、数仓、数据湖、AI 等技术实践与生产应用落地。</p> <p style="text-align:center">> 多种奖品拿到手软!直播间已准备超多精美礼品,现场送送送!预约直播并参与互动即有机会领走哦。</p> 本次 Meetup 您将了解: Spark 3.0 有哪些新功能从 Lambda 架构到 HSAP,数仓未来趋势如何流批一体机器学习算法平台 Alink 易用性的提升Flink + Kafka 在网易云音乐的落地实践数据湖如何解决数据实时入库问题2020 春晚活动中快手实时链路保障独家实践分享Flink 1.11 最新版本功能特性深度解读如何观看: 时间:6月14日 10:00 — 18:00直播预约链接:https://developer.aliyun.com/...报名方式:扫描下方二维码<p style="text-align:center"></p><p style="text-align:center">(扫码报名)</p> 《深入研究 Apache Spark 3.0 的新功能》李潇 | Databricks Spark 研发部主管 嘉宾简介: 李潇,就职于 Databricks,Spark 研发部主管,领导 Spark,Koalas,Databricks runtime,OEM 的研发团队。Apache Spark Committer、PMC 成员。2011 年从佛罗里达大学获得获得了博士学位。曾就职于 IBM,获发明大师称号(Master Inventor),是异步数据库复制和一致性验证的领域专家,发表专利十余篇。(Github: gatorsmile) ...

June 3, 2020 · 1 min · jiezi

Flink-Weekly-每周社区动态更新20200520

大家好,本文为 Flink Weekly 的第十六期,由王雷整理,张成 Review。本期主要内容包括:近期社区开发进展、邮件问题答疑、Flink 最新社区动态及技术文章推荐等。 Flink 开发进展1.Release■ Piotr Nowojski 宣布 release-1.11 分支冻结。 [1]http://apache-flink-mailing-l... ■ 1.10.1 已成功发版,发版日志见下链接。 [2]https://issues.apache.org/jir... ■ 1.10.1 发版后,Seth Wiesman 发现 FLINK-16684 修改了 StreamingFileSink (@PublicEvolving) 的 API,导致 1.10.0 和 1.10.1 之间存在二进制不兼容问题。 [3]http://apache-flink-mailing-l... 2.Dev■ 当用户使用 per-job 模式提交任务时,当前的 History Server 无法聚合的显示这些任务。Gyula 对 History Server 进行了修改,实现了一个可以聚合不同集群任务的看板。 [4]http://apache-flink-mailing-l... 3.FLIP■ [Runtime] Aljoscha Krettek 宣布 FLIP-126 投票通过,FLIP-126 旨在对 Watermark Assigners 进行重构。 [5]http://apache-flink-mailing-l... 4.Discuss■ [Config] Stephan Ewen 发起了将 state.backend.fs.memory-threshold 的默认值从 1K 提升到 100K 的讨论,目的是减少小文件。大家对该改动可能导致 state 变大,从而导致 OOM 的问题进行了讨论。 ...

June 3, 2020 · 2 min · jiezi

Flink-完美搭档数据存储层上的-Pravega

本文将从大数据架构变迁历史,Pravega 简介,Pravega 进阶特性以及车联网使用场景这四个方面介绍 Pravega,重点介绍 DellEMC 为何要研发 Pravega,Pravega 解决了大数据处理平台的哪些痛点以及与 Flink 结合会碰撞出怎样的火花。作者 | 滕昱 DellEMC 研发总监整理 | 赵海凯 DellEMC 实习生 本文将从大数据架构变迁历史,Pravega 简介,Pravega 进阶特性以及车联网使用场景这四个方面介绍 Pravega,重点介绍 DellEMC 为何要研发 Pravega,Pravega 解决了大数据处理平台的哪些痛点以及与 Flink 结合会碰撞出怎样的火花。 大数据架构变迁Lambda 架构之痛 如何有效地提取和提供数据,是大数据处理应用架构是否成功的关键之处。由于处理速度和频率的不同,数据的摄取需要通过两种策略来进行。上图就是典型的 Lambda架构:把大数据处理架构分为批处理和实时流处理两套独立的计算基础架构。 对于实时处理来说,来自传感器,移动设备或者应用日志的数据通常写入消息队列系统(如 Kafka), 消息队列负责为流处理应用提供数据的临时缓冲。然后再使用 Spark Streaming 从 Kafka 中读取数据做实时的流计算。但由于 Kafka 不会一直保存历史数据,因此如果用户的商业逻辑是结合历史数据和实时数据同时做分析,那么这条流水线实际上是没有办法完成的。因此为了补偿,需要额外开辟一条批处理的流水线,即图中" Batch "部分。 对于批处理这条流水线来说,集合了非常多的的开源大数据组件如 ElasticSearch, Amazon S3, HDFS, Cassandra 以及 Spark 等。主要计算逻辑是是通过 Spark 来实现大规模的 Map-Reduce 操作,优点在于结果比较精确,因为可以结合所有历史数据来进行计算分析,缺点在于延迟会比较大。 这套经典的大数据处理架构可以总结出三个问题: 两条流水线处理的延迟相差较大,无法同时结合两条流水线进行迅速的聚合操作,同时结合历史数据和实时数据的处理性能低下。数据存储成本大。而在上图的架构中,相同的数据会在多个存储组件中都存在一份或多份拷贝,数据的冗余无疑会大大增加企业客户的成本。并且开源存储的数据容错和持久化可靠性一直也是值得商榷的地方,对于数据安全敏感的企业用户来说,需要严格保证数据的不丢失。重复开发。同样的处理流程被两条流水线进行了两次,相同的数据仅仅因为处理时间不同而要在不同的框架内分别计算一次,无疑会增加数据开发者重复开发的负担。流式存储的特点在正式介绍 Pravega 之前,首先简单谈谈流式数据存储的一些特点。 如果我们想要统一流批处理的大数据处理架构,其实对存储有混合的要求。 对于来自序列旧部分的历史数据,需要提供高吞吐的读性能,即 catch-up read对于来自序列新部分的实时数据,需要提供低延迟的 append-only 尾写 tailing write 以及尾读 tailing read重构的流式存储架构 ...

June 3, 2020 · 3 min · jiezi

Flink-110-SQLHiveCatalog-与事件时间整合示例

Flink 1.10 与 1.9 相比又是个创新版本,在我们感兴趣的很多方面都有改进,特别是 Flink SQL。本文用根据埋点日志计算 PV、UV 的简单示例来体验 Flink 1.10 的两个重要新特性: 一是 SQL DDL 对事件时间的支持;二是 Hive Metastore 作为 Flink 的元数据存储(即 HiveCatalog)。 这两点将会为我们构建实时数仓提供很大的便利。 添加依赖项示例采用 Hive 版本为 1.1.0,Kafka 版本为 0.11.0.2。 要使 Flink 与 Hive 集成以使用 HiveCatalog,需要先将以下 JAR 包放在 ${FLINK_HOME}/lib 目录下。 flink-connector-hive_2.11-1.10.0.jarflink-shaded-hadoop-2-uber-2.6.5-8.0.jarhive-metastore-1.1.0.jarhive-exec-1.1.0.jarlibfb303-0.9.2.jar后三个 JAR 包都是 Hive 自带的,可以在 ${HIVE_HOME}/lib 目录下找到。前两个可以通过阿里云 Maven 搜索 GAV 找到并手动下载(groupId 都是org.apache.flink)。 再在 pom.xml 内添加相关的 Maven 依赖。 Maven 下载: https://maven.aliyun.com/mvn/...<properties> <scala.bin.version>2.11</scala.bin.version> <flink.version>1.10.0</flink.version> <hive.version>1.1.0</hive.version> </properties> <dependencies> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-table-api-scala_${scala.bin.version}</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-table-api-scala-bridge_${scala.bin.version}</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-table-planner-blink_${scala.bin.version}</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-sql-connector-kafka-0.11_${scala.bin.version}</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-hive_${scala.bin.version}</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-json</artifactId> <version>${flink.version}</version> </dependency> <dependency> <groupId>org.apache.hive</groupId> <artifactId>hive-exec</artifactId> <version>${hive.version}</version> </dependency> </dependencies>最后,找到 Hive 的配置文件 hive-site.xml,准备工作就完成了。 ...

June 3, 2020 · 3 min · jiezi

深度解读-Flink-111流批一体-Hive-数仓

Flink 1.11 中流计算结合 Hive 批处理数仓,给离线数仓带来 Flink 流处理实时且 Exactly-once 的能力。另外,Flink 1.11 完善了 Flink 自身的 Filesystem connector,大大提高了 Flink 的易用性。Flink 1.11 features 已经冻结,流批一体在新版中是浓墨重彩的一笔,在此提前对 Flink 1.11 中流批一体方面的改善进行深度解读,大家可期待正式版本的发布。 首先恭喜 Table/SQL 的 blink planner 成为默认 Planner,撒花、撒花。 Flink 1.11 中流计算结合 Hive 批处理数仓,给离线数仓带来 Flink 流处理实时且 Exactly-once 的能力。另外,Flink 1.11 完善了 Flink 自身的 Filesystem connector,大大提高了 Flink 的易用性。 数仓架构离线数仓 传统的离线数仓是由 Hive 加上 HDFS 的方案,Hive 数仓有着成熟和稳定的大数据分析能力,结合调度和上下游工具,构建一个完整的数据处理分析平台,流程如下: Flume 把数据导入 Hive 数仓调度工具,调度 ETL 作业进行数据处理在 Hive 数仓的表上,可以进行灵活的 Ad-hoc 查询调度工具,调度聚合作业输出到BI层的数据库中这个流程下的问题是: 导入过程不够灵活,这应该是一个灵活 SQL 流计算的过程基于调度作业的级联计算,实时性太差ETL 不能有流式的增量计算实时数仓针对离线数仓的特点,随着实时计算的流行,越来越多的公司引入实时数仓,实时数仓基于 Kafka + Flink streaming,定义全流程的流计算作业,有着秒级甚至毫秒的实时性。 ...

June 3, 2020 · 4 min · jiezi

一文了解Flink-State-Backends

当我们使用Flink进行流式计算时,通常会产生各种形式的中间结果,我们称之为State。有状态产生,就必然涉及到状态的存储,那么Flink中定义了哪些形式的状态存储呢,下面一一给大家介绍一下。State BackendsMemoryStateBackendFsStateBackendRocksDBStateBackendMemoryStateBackend顾名思义,MemoryStateBackend状态后端是将状态数据以Object的形式存放于Java Heap中。 当执行检查点时,MemoryStateBackend会为当前的状态生成snapshot,然后将快照信息作为检查点ack消息的一部分发送给JobManager(master节点),JobManager会将收到的快照数据存放于自己的堆内存中。 MemoryStateBackend默认采用异步snapshots的方式来避免数据流管道阻塞,这是一种比较推荐的方式。当然,我们也可以通过配置来禁用这种方式。 new MemoryStateBackend(MAX_MEM_STATE_SIZE, false); // MAX_MEM_STATE_SIZE表示最大允许的状态容量MemoryStateBackend的使用限制 每个状态的大小默认限制为5MB,可以通过构造函数设置状态大小不管如何配置最大状态大小,都不能超过akka帧大小聚合状态大小必须合乎JobManager的内存大小基于以上这些限制,我们通常建议在如下场景中使用MemoryStateBackend: 本地开发调试无状态作业或者保存少量状态的作业此外,官方建议将托管内存(Managed Memory)设置为0,这样可以确保为JVM上的用户程序分配最大的内存。 FsStateBackendFsStateBackend需要配置一个文件系统URL,如:“hdfs://namenode:40010/flink/checkpoints” or “file:///data/flink/checkpoints”。FsStateBackend将作业执行过程中的动态数据存放在TaskManager的内存当中,当执行检查点时,状态快照数据会被存储在配置的文件系统目录中,还有一部分metadata数据会被存储在JobManager的内存当中。 同样的,FsStateBackend也是默认采用异步snapshot的方式。我们可以通过实例化FsStateBackend来更改快照生成方式。 new FsStateBackend(path, false);官方建议在以下场景中使用FsStateBackend: 作业中包含大状态、长窗口以及大键值状态高可用应用场景同样官方建议将托管内存(Managed Memory)设置为0,这样可以确保为JVM上的用户程序分配最大的内存。 RocksDBStateBackendRocksDBStateBackend同样需要配置一个文件系统URL:“hdfs://namenode:40010/flink/checkpoints” or “file:///data/flink/checkpoints”。 RocksDBStateBackend将作业执行过程中的动态数据存放在RocksDB数据库中,RocksDB数据库默认存储在TaskManager的数据目录下。当执行检查点时,整个RocksDB数据库会被存档到配置的文件系统目录下。只有少量的metadata数据存储在JobManager的内存当中。 同样地,RocksDBStateBackend通常也采用异步snapshot的方式。 使用上的一些限制: 由于RocksDB的JNI bridge API是基于byte[]的,因此可支持的最大key值大小是2^31 byte。这个限制一般情况下不会有问题,但当作业中的状态是基于不断地merge操作生成时,很容易超过这个大小限制,这个时候就会出现检索失败的错误。官方建议在以下场景中使用RocksDBStateBackend: 作业中包含大状态、长窗口以及大键值状态高可用应用场景乍一看,好像跟FsStateBackend没啥区别?其实不是,这里需要注意的是,当我们使用RocksDBStateBackend作为状态存储时,可以维护的状态大小仅仅受限于程序可访问的磁盘空间大小。这就使得我们可以维护比FsStateBackend更大的作业状态。 当然,这也带来一个问题:由于与状态后端之间的所有读写操作都要经过de-/serialization,因此这种方式牺牲了一定的吞吐量。 总结MemoryStateBackend、FsStateBackend都是基于堆的状态存储RocksDBStateBackend是目前唯一的一种支持增量checkpoint的状态后端

June 2, 2020 · 1 min · jiezi

flink-DataStream算子中如何实时更新变量

1.问题描述,如下图:在写机器学习算法时遇到这样一个场景,在第一个map需要用到变量currentCenter,然后我输出的结果需要更新currentCenter(最后一个map),但是没办法更新。因为map函数是并行的,传入的currentCenter实际上是一个复制品,在map中修改currentCenter复制品是不会改变原变量的。2.方案(1)数据库/文件系统使用外部数据库/文件系统,在第一个map函数不断的读取外部数据库/文件系统数据,第二个map函数中不断更新外部数据库/文件数据,可以达到实时动态更新变量的效果。但这样的缺点就是频繁的io开销,相当于将flink退化成了mapreduce的计算模型。pass3.方案(2)迭代流+广播流这里有个很明显的特征,就是我需要在下游的流中更新到上游的流数据,这不就是迭代流吗?不熟悉迭代流的可以查一下官网或看一下我的示例:https://segmentfault.com/a/11...方向已经明确了,我需要对我的实时变量进行迭代流操作。还有一个问题就是我的实时变量是通过输入流的数据和实时变量计算得到的,所以这里就需要把我的迭代流广播到输入流计算,然后生成新的实时变量流继续迭代,大致的流程图如下:成功解决!还有在迭代流中还可以使用windows操作。4.方案(3)使用Flink的DataStreamUtils。实验未成功,成功的大佬分享一下!欢迎查看相关入门博客:https://segmentfault.com/a/11...

May 29, 2020 · 1 min · jiezi

揭秘-Flink-19-新架构Blink-Planner-你会用了吗

本文为 Apache Flink 新版本重大功能特性解读之 Flink SQL 系列文章的开篇,Flink SQL 系列文章由其核心贡献者们分享,涵盖基础知识、实践、调优、内部实现等各个方面,带你由浅入深地全面了解 Flink SQL。 1. 发展历程今年的8月22日 Apache Flink 发布了1.9.0 版本(下文简称1.9),在 Flink 1.9 中,Table 模块迎来了核心架构的升级,引入了阿里巴巴Blink团队贡献的诸多功能,本文对Table 模块的架构进行梳理并介绍如何使用 Blink Planner。 Flink 的 Table 模块 包括 Table API 和 SQL,Table API 是一种类SQL的API,通过Table API,用户可以像操作表一样操作数据,非常直观和方便;SQL作为一种声明式语言,有着标准的语法和规范,用户可以不用关心底层实现即可进行数据的处理,非常易于上手,Flink Table API 和 SQL 的实现上有80%左右的代码是公用的。作为一个流批统一的计算引擎,Flink 的 Runtime 层是统一的,但在 Flink 1.9 之前,Flink API 层 一直分为DataStream API 和 DataSet API, Table API & SQL 位于 DataStream API 和 DataSet API 之上。 ...

September 20, 2019 · 2 min · jiezi

如何在-Apache-Flink-中使用-Python-API

本文根据 Apache Flink 系列直播课程整理而成,由 Apache Flink PMC,阿里巴巴高级技术专家 孙金城 分享。重点为大家介绍 Flink Python API 的现状及未来规划,主要内容包括:Apache Flink Python API 的前世今生和未来发展;Apache Flink Python API 架构及开发环境搭建;Apache Flink Python API 核心算子介绍及应用。 一.Apache Flink Python API 的前世今生和未来发展1.Flink 为什么选择支持 PythonApache Flink 是流批统一的开源大数据计算引擎,在 Flink 1.9.0 版本开启了新的 ML 接口和全新的Python API架构。那么为什么 Flink 要增加对 Python 的支持,下文将进行详细分析。 最流行的开发语言 Python 本身是非常优秀的开发语言,据 RedMonk 数据统计,除 Java 和 JavaScript 之外,受欢迎度排名第三。 RedMonk 是著名的以开发人员为中心的行业分析公司,其更详细的分析信息,大家在拿到我的PPT之后,可以点击链接进行详细查阅。好了,那么Python的火热,与我们今天向大家分享的流批统一的大数据计算引擎,Apache Flink有什么关系呢?带着这个问题,我们大家想想目前与大数据相关的著名的开源组件有哪些呢?比如说最早期的批处理框架Hadoop?流计算平台Storm,最近异常火热的Spark?异或其他领域数仓的Hive,KV存储的HBase?这些都是非常著名的开源项目,那么这些项目都无一例外的进行了Python API的支持。 众多开源项目支持 Python 的生态已相对完善,基于此,Apache Flink 在 1.9 版本中也投入了大量的精力,去推出了一个全新的 Pyflink。除大数据外,人工智能与Python也有十分密切的关系。 ML青睐的语言 ...

September 10, 2019 · 4 min · jiezi

Flink-Window基本概念与实现原理

Window意为窗口。在流处理系统中数据源源不断流入到系统,我们可以逐条处理流入的数据,也可以按一定规则一次处理流中的多条数据。当处理数据时程序需要知道什么时候开始处理、处理哪些数据。窗口提供了这样一种依据,决定了数据何时开始处理。 Flink内置WindowFlink有3个内置Window 以事件数量驱动的Count Window以会话间隔驱动的Session Window以时间驱动的Time Window本文围绕这3个内置窗口展开讨论,我们首先了解这3个窗口在运行时产生的现象,最后再讨论它们的实现原理。 Count Window 计数窗口,采用事件数量作为窗口处理依据。计数窗口分为滚动和滑动两类,使用keyedStream.countWindow实现计数窗口定义。 Tumbling Count Window 滚动计数窗口例子:以用户分组,当每位用户有3次付款事件时计算一次该用户付款总金额。下图中“消息A、B、C、D”代表4位不同用户,我们以A、B、C、D分组并计算金额。 /** 每3个事件,计算窗口内数据 */keyedStream.countWindow(3); Sliding Count Window 滑动计数窗口例子:一位用户每3次付款事件计算最近4次付款事件总金额。 /** 每3个事件,计算最近4个事件消息 */keyedStream.countWindow(4,3); Session Window 会话窗口,采用会话持续时长作为窗口处理依据。设置指定的会话持续时长时间,在这段时间中不再出现会话则认为超出会话时长。 例子:每只股票超过2秒没有交易事件时计算窗口内交易总金额。下图中“消息A、消息B”代表两只不同的股票。 /** 会话持续2秒。当超过2秒不再出现会话认为会话结束 */keyedStream.window(ProcessingTimeSessionWindows.withGap(Time.seconds(2))) Time Window 时间窗口,采用时间作为窗口处理依据。时间窗分为滚动和滑动两类,使用keyedStream.timeWindow实现时间窗定义。 Tumbling Time Window 滚动时间窗口: /** 每1分钟,计算窗口数据 */keyedStream.timeWindow(Time.minutes(1)); Sliding Time Window 滑动时间窗口: /** 每半分钟,计算最近1分钟窗口数据 */keyedStream.timeWindow(Time.minutes(1), Time.seconds(30));Flink Window组件Flink Window使用3个组件协同实现了内置的3个窗口。通过对这3个组件不同的组合,可以满足许多场景的窗口定义。 WindowAssigner组件为数据分配窗口、Trigger组件决定如何处理窗口中的数据、借助Evictor组件实现灵活清理窗口中数据时机。 WindowAssigner 当有数据流入到Window Operator时需要按照一定规则将数据分配给窗口,WindowAssigner为数据分配窗口。下面代码片段是WindowAssigner部分定义,assignWindows方法定义返回的结果是一个集合,也就是说数据允许被分配到多个窗口中。 /*** WindowAssigner关键接口定义 ***/public abstract class WindowAssigner<T, W extends Window> implements Serializable { /** 分配数据到窗口集合并返回 */ public abstract Collection<W> assignWindows(T element, long timestamp, WindowAssignerContext context);}Flink内置WindowAssignerFlink针对不同窗口类型实现了相应的WindowAssigner。Flink 1.7.0继承关系如下图 ...

August 19, 2019 · 5 min · jiezi

福利-Flink-Forward-Asia-2019-由你决定填问卷送周边

2018 年 12 月,Apache Flink Community China 成功举办了国内首届 Flink Forward China,并在诸多合作伙伴的帮助下成功将其打造为规模最大、参与人数最多的 Flink Forward 大会。 今年,Apache Flink 年度最高规格的盛会即将再次拉开帷幕!Flink Forward China 已正式升级为 Flink Forward Asia,并计划于 11 月底举办,规模将逾2000 人。 参与调研送周边为进一步提高会议质量,让 Apache Flink 社区与开发者更近距离地接触,我们诚挚地邀请您参与会前调研,想听什么议题,想见哪位大佬,想要什么礼品,由你决定!福利活动奉上: 点击文末链接,推荐您的小伙伴填写问卷,并在问卷底部的「问卷推荐人」一栏中正确填入您的姓名,可获取相应周边奖励:1. 推荐1-4人填写:Apache Flink 社区限量版专刊 S2 实体书籍2. 推荐5-10人填写:Apache Flink 社区定制马克杯3. 推荐10人以上填写:Apache Flink 社区定制T恤本次问卷调研福利我们首次送出最新定制的 Apache Flink 社区 T 恤、人气最高的社区定制马克杯以及限量纸质版 Apache Flink 第二季专刊《重新定义计算:Apache Flink 实践》。 社区周边展示Apache Flink 社区周边大饱眼福时间到,看看你最想要哪一款! Apache Flink 定制版T恤,小姐姐同款,Meetup 来撞衫! 用 Apache Flink 旗舰款马克杯,喝水都会更开心! ...

July 10, 2019 · 1 min · jiezi

回顾-Apache-Flink-X-Apache-RocketMQ-上海站PPT下载

7 月 6 日,Apache Flink Meetup X Apache RocketMQ · 上海站,来自阿里巴巴、网易的 Flink 技术专家与 Apache RocketMQ 社区大咖一起分享关于 Flink、RocketMQ 的应用实践与前沿技术。 ▼ PPT 下载 ▼ Apache Flink Meetup X Apache RocketMQ · 上海站,嘉宾分享的PPT下载请在后台回复关键字“0706PPT”领取。 《网易云音乐消息队列改造之路与 Apache Flink 应用实践》 林德智 | 网易云音乐 消息队列负责人 岳猛 | Apache Flink Contributor,网易云音乐 实时计算平台研发工程师 本次分享主要介绍了网易云音乐消息队列基于 RocketMQ 的应用以及在消息队列的基础上深度融合的 Flink 流式处理引擎为云音乐提供的实时计算解决方案,分享了在直播,广告,曲库,内容等取得的应用效果。 云音乐消息队列的历史基于 RocketMQ 改造消息队列部分高级特性与 bug 修复RocketMQ 与 Flink 结合应用实践《万亿级消息及流处理引擎 - Apache RocketMQ 的现在和未来》 ...

July 9, 2019 · 1 min · jiezi

应用案例-从Storm到Flink有赞五年实时计算效率提升实践

作者 | 贺飞 公司介绍:有赞是一个商家服务公司,提供全行业全场景的电商解决方案。在有赞,大量的业务场景依赖对实时数据的处理,作为一类基础技术组件,服务着有赞内部几十个业务产品,几百个实时计算任务,其中包括交易数据大屏,商品实时统计分析,日志平台,调用链,风控等多个业务场景,本文将介绍有赞实时计算当前的发展历程和当前的实时计算技术架构。 1.实时计算在有赞发展从技术栈的角度,我们的选择和大多数互联网公司一致,从早期的 Storm,到 JStorm, Spark Streaming 和最近兴起的 Flink。从发展阶段来说,主要经历了两个阶段,起步阶段和平台化阶段;下面将按照下图中的时间线,介绍实时计算在有赞的发展历程。 1.1 起步阶段这里的的起步阶段的基本特征是,缺少整体的实时计算规划,缺乏平台化任务管理,监控,报警工具,用户提交任务直接通过登录 AG 服务器使用命令行命令提交任务到线上集群,很难满足用户对可用性的要求。但是,在起步阶段里积累了内部大量的实时计算场景。 1.1.1 Storm 登场2014 年初,第一个 Storm 应用在有赞内部开始使用,最初的场景是把实时事件的统计从业务逻辑中解耦出来,Storm 应用通过监听 MySQL 的 binlog 更新事件做实时计算,然后将结果更新到 MySQL 或者 Redis 缓存上,供在线系统使用。类似的场景得到了业务开发的认可,逐渐开始支撑起大量的业务场景。早期,用户通过登录一组线上环境的 AG 服务器,通过 Storm 的客户端向 Storm 集群做提交任务等操作, 这样在 2 年多的时间里,Storm 组件积累了近百个实时应用。Storm 也同样暴露出很多问题,主要体现在系统吞吐上,对吞吐量巨大,但是对延迟不敏感的场景,显得力不从心。 1.1.2 引入 Spark Streaming2016 年末,随着 Spark 技术栈的日益成熟,又因为 Storm 引擎本身在吞吐 / 性能上跟 Spark Streaming 技术栈相比有明显劣势,所以从那时候开始,部分业务团队开始尝试新的流式计算引擎。因为有赞离线计算有大量 Spark 任务的使用经验,Spark Streaming 很自然的成为了第一选择,随着前期业务日志系统和埋点日志系统的实时应用的接入,大量业务方也开始逐渐接入。同 Storm 一样,业务方完成实时计算应任务开发后,通过一组 AG 服务器,使用 Spark 客户端,向大数据 Yarn 集群提交任务。 ...

July 4, 2019 · 2 min · jiezi

回顾-Apache-Flink-19-版本新特性强势预告内含PPT下载链接

6月29日,Apache Flink Meetup 北京站圆满落幕,Apache Flink 1.9 版本是自 Flink 1.0 之后变化最大的版本,社区对 Flink 进行大量重构并且加入了很多新 Feature。此次 Meetup 重点解读 Flink 1.9 版本新特性。 ▼ PPT下载 ▼关注Apache Flink 社区公众号Ververica,回复关键字“0629PPT”即可下载Apache Flink Meetup 北京站全部嘉宾分享的PPT. 本期 Meetup 由 Apache Flink PMC 与 Committer 开场,对 Flink 1.9 版本新特性进行全面分享;阿里巴巴技术专家从 Table API 和算法层面分享 Flink 的机器学习生态;还有 Flink on Kubernetes 、Flink 1.9 版本与 Hive 的兼容性解读,以及超过千台集群、日处理条目超过 264 亿条,处理峰值超过 3.6 千万条 / s 的 Flink 在快手的应用实践。 《Apache Flink 1.9 特性解读》 ...

July 3, 2019 · 2 min · jiezi

Apache-Flink-零基础入门一基础概念解析

作者:陈守元、戴资力 一、Apache Flink 的定义、架构及原理Apache Flink 是一个分布式大数据处理引擎,可对有限数据流和无限数据流进行有状态或无状态的计算,能够部署在各种集群环境,对各种规模大小的数据进行快速计算。 1. Flink Application了解 Flink 应用开发需要先理解 Flink 的 Streams、State、Time 等基础处理语义以及 Flink 兼顾灵活性和方便性的多层次 API。 Streams:流,分为有限数据流与无限数据流,unbounded stream 是有始无终的数据流,即无限数据流;而 bounded stream 是限定大小的有始有终的数据集合,即有限数据流,二者的区别在于无限数据流的数据会随时间的推演而持续增加,计算持续进行且不存在结束的状态,相对的有限数据流数据大小固定,计算最终会完成并处于结束的状态。State,状态是计算过程中的数据信息,在容错恢复和 Checkpoint 中有重要的作用,流计算在本质上是 Incremental Processing,因此需要不断查询保持状态;另外,为了确保 Exactly- once 语义,需要数据能够写入到状态中;而持久化存储,能够保证在整个分布式系统运行失败或者挂掉的情况下做到 Exactly- once,这是状态的另外一个价值。Time,分为 Event time、Ingestion time、Processing time,Flink 的无限数据流是一个持续的过程,时间是我们判断业务状态是否滞后,数据处理是否及时的重要依据。API,API 通常分为三层,由上而下可分为 SQL / Table API、DataStream API、ProcessFunction 三层,API 的表达能力及业务抽象能力都非常强大,但越接近 SQL 层,表达能力会逐步减弱,抽象能力会增强,反之,ProcessFunction 层 API 的表达能力非常强,可以进行多种灵活方便的操作,但抽象能力也相对越小。2.Flink Architecture在架构部分,主要分为以下四点: 第一, Flink 具备统一的框架处理有界和无界两种数据流的能力 第二, 部署灵活,Flink 底层支持多种资源调度器,包括 Yarn、Kubernetes 等。Flink 自身带的 Standalone 的调度器,在部署上也十分灵活。 第三, 极高的可伸缩性,可伸缩性对于分布式系统十分重要,阿里巴巴双11大屏采用 Flink 处理海量数据,使用过程中测得 Flink 峰值可达 17 亿/秒。 ...

July 2, 2019 · 4 min · jiezi

用Flink取代Spark-Streaming知乎实时数仓架构演进

作者 | 知乎数据工程团队 “数据智能” (Data Intelligence) 有一个必须且基础的环节,就是数据仓库的建设,同时,数据仓库也是公司数据发展到一定规模后必然会提供的一种基础服务。从智能商业的角度来讲,数据的结果代表了用户的反馈,获取结果的及时性就显得尤为重要,快速的获取数据反馈能够帮助公司更快的做出决策,更好的进行产品迭代,实时数仓在这一过程中起到了不可替代的作用。 本文主要讲述知乎的实时数仓实践以及架构的演进,这包括以下几个方面: 实时数仓 1.0 版本,主题:ETL 逻辑实时化,技术方案:Spark Streaming。实时数仓 2.0 版本,主题:数据分层,指标计算实时化,技术方案:Flink Streaming。实时数仓未来展望:Streaming SQL 平台化,元信息管理系统化,结果验收自动化。实时数仓 1.0 版本1.0 版本的实时数仓主要是对流量数据做实时 ETL,并不计算实时指标,也未建立起实时数仓体系,实时场景比较单一,对实时数据流的处理主要是为了提升数据平台的服务能力。实时数据的处理向上依赖数据的收集,向下关系到数据的查询和可视化,下图是实时数仓 1.0 版本的整体数据架构图。 第一部分是数据采集,由三端 SDK 采集数据并通过 Log Collector Server 发送到 Kafka。第二部分是数据 ETL,主要完成对原始数据的清洗和加工并分实时和离线导入 Druid。第三部分是数据可视化,由 Druid 负责计算指标并通过 Web Server 配合前端完成数据可视化。 其中第一、三部分的相关内容请分别参考:知乎客户端埋点流程、模型和平台技术,Druid 与知乎数据分析平台,此处我们详细介绍第二部分。由于实时数据流的稳定性不如离线数据流,当实时流出现问题后需要离线数据重刷历史数据,因此实时处理部分我们采用了 lambda 架构。 Lambda 架构有高容错、低延时和可扩展的特点,为了实现这一设计,我们将 ETL 工作分为两部分:Streaming ETL 和 Batch ETL。 Streaming ETL这一部分我会介绍实时计算框架的选择、数据正确性的保证、以及 Streaming 中一些通用的 ETL 逻辑,最后还会介绍 Spark Streaming 在实时 ETL 中的稳定性实践。 计算框架选择在 2016 年年初,业界用的比较多的实时计算框架有 Storm 和 Spark Streaming。Storm 是纯流式框架,Spark Streaming 用 Micro Batch 模拟流式计算,前者比后者更实时,后者比前者吞吐量大且生态系统更完善,考虑到知乎的日志量以及初期对实时性的要求,我们选择了 Spark Streaming 作为实时数据的处理框架。 ...

June 28, 2019 · 3 min · jiezi

用Flink取代Spark-Streaming知乎实时数仓架构演进

作者 | 知乎数据工程团队 “数据智能” (Data Intelligence) 有一个必须且基础的环节,就是数据仓库的建设,同时,数据仓库也是公司数据发展到一定规模后必然会提供的一种基础服务。从智能商业的角度来讲,数据的结果代表了用户的反馈,获取结果的及时性就显得尤为重要,快速的获取数据反馈能够帮助公司更快的做出决策,更好的进行产品迭代,实时数仓在这一过程中起到了不可替代的作用。 本文主要讲述知乎的实时数仓实践以及架构的演进,这包括以下几个方面: 实时数仓 1.0 版本,主题:ETL 逻辑实时化,技术方案:Spark Streaming。实时数仓 2.0 版本,主题:数据分层,指标计算实时化,技术方案:Flink Streaming。实时数仓未来展望:Streaming SQL 平台化,元信息管理系统化,结果验收自动化。实时数仓 1.0 版本1.0 版本的实时数仓主要是对流量数据做实时 ETL,并不计算实时指标,也未建立起实时数仓体系,实时场景比较单一,对实时数据流的处理主要是为了提升数据平台的服务能力。实时数据的处理向上依赖数据的收集,向下关系到数据的查询和可视化,下图是实时数仓 1.0 版本的整体数据架构图。 第一部分是数据采集,由三端 SDK 采集数据并通过 Log Collector Server 发送到 Kafka。第二部分是数据 ETL,主要完成对原始数据的清洗和加工并分实时和离线导入 Druid。第三部分是数据可视化,由 Druid 负责计算指标并通过 Web Server 配合前端完成数据可视化。 其中第一、三部分的相关内容请分别参考:知乎客户端埋点流程、模型和平台技术,Druid 与知乎数据分析平台,此处我们详细介绍第二部分。由于实时数据流的稳定性不如离线数据流,当实时流出现问题后需要离线数据重刷历史数据,因此实时处理部分我们采用了 lambda 架构。 Lambda 架构有高容错、低延时和可扩展的特点,为了实现这一设计,我们将 ETL 工作分为两部分:Streaming ETL 和 Batch ETL。 Streaming ETL这一部分我会介绍实时计算框架的选择、数据正确性的保证、以及 Streaming 中一些通用的 ETL 逻辑,最后还会介绍 Spark Streaming 在实时 ETL 中的稳定性实践。 计算框架选择在 2016 年年初,业界用的比较多的实时计算框架有 Storm 和 Spark Streaming。Storm 是纯流式框架,Spark Streaming 用 Micro Batch 模拟流式计算,前者比后者更实时,后者比前者吞吐量大且生态系统更完善,考虑到知乎的日志量以及初期对实时性的要求,我们选择了 Spark Streaming 作为实时数据的处理框架。 ...

June 27, 2019 · 3 min · jiezi

原理解析-深入了解-Apache-Flink-的网络协议栈

作者:Nico Kruber 翻译:曹英杰 Flink 的网络协议栈是组成 flink-runtime 模块的核心组件之一,是每个 Flink 作业的核心。它连接所有 TaskManager 的各个子任务(Subtask),因此,对于 Flink 作业的性能包括吞吐与延迟都至关重要。与 TaskManager 和 JobManager 之间通过基于 Akka 的 RPC 通信的控制通道不同,TaskManager 之间的网络协议栈依赖于更加底层的 Netty API。 本文将首先介绍 Flink 暴露给流算子(Stream operator)的高层抽象,然后详细介绍 Flink 网络协议栈的物理实现和各种优化、优化的效果以及 Flink 在吞吐量和延迟之间的权衡。 1.逻辑视图Flink 的网络协议栈为彼此通信的子任务提供以下逻辑视图,例如在 A 通过 keyBy() 操作进行数据 Shuffle : 这一过程建立在以下三种基本概念的基础上: ▼ 子任务输出类型(ResultPartitionType):Pipelined(有限的或无限的):一旦产生数据就可以持续向下游发送有限数据流或无限数据流。Blocking:仅在生成完整结果后向下游发送数据。 ▼ 调度策略:同时调度所有任务(Eager):同时部署作业的所有子任务(用于流作业)。上游产生第一条记录部署下游(Lazy):一旦任何生产者生成任何输出,就立即部署下游任务。上游产生完整数据部署下游:当任何或所有生产者生成完整数据后,部署下游任务。 ▼ 数据传输:高吞吐:Flink 不是一个一个地发送每条记录,而是将若干记录缓冲到其网络缓冲区中并一次性发送它们。这降低了每条记录的发送成本因此提高了吞吐量。低延迟:当网络缓冲区超过一定的时间未被填满时会触发超时发送,通过减小超时时间,可以通过牺牲一定的吞吐来获取更低的延迟。 我们将在下面深入 Flink 网络协议栈的物理实现时看到关于吞吐延迟的优化。对于这一部分,让我们详细说明输出类型与调度策略。首先,需要知道的是子任务的输出类型和调度策略是紧密关联的,只有两者的一些特定组合才是有效的。 Pipelined 结果是流式输出,需要目标 Subtask 正在运行以便接收数据。因此需要在上游 Task 产生数据之前或者产生第一条数据的时候调度下游目标 Task 运行。批处理作业生成有界结果数据,而流式处理作业产生无限结果数据。 批处理作业也可能以阻塞方式产生结果,具体取决于所使用的算子和连接模式。在这种情况下,必须等待上游 Task 先生成完整的结果,然后才能调度下游的接收 Task 运行。这能够提高批处理作业的效率并且占用更少的资源。 下表总结了 Task 输出类型以及调度策略的有效组合: ...

June 25, 2019 · 3 min · jiezi

入门教程-5分钟从零构建第一个-Flink-应用

本文转载自 Jark’s Blog ,作者伍翀(云邪),Apache Flink Committer,阿里巴巴高级开发工程师。本文将从开发环境准备、创建 Maven 项目,编写 Flink 程序、运行程序等方面讲述如何迅速搭建第一个 Flink 应用。在本文中,我们将从零开始,教您如何构建第一个 Flink 应用程序。开发环境准备Flink 可以运行在 Linux, Max OS X, 或者是 Windows 上。为了开发 Flink 应用程序,在本地机器上需要有 Java 8.x 和 maven 环境。 如果有 Java 8 环境,运行下面的命令会输出如下版本信息: $ java -versionjava version "1.8.0_65"Java(TM) SE Runtime Environment (build 1.8.0_65-b17)Java HotSpot(TM) 64-Bit Server VM (build 25.65-b01, mixed mode)如果有 maven 环境,运行下面的命令会输出如下版本信息:$ mvn -versionApache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-18T02:33:14+08:00)Maven home: /Users/wuchong/dev/mavenJava version: 1.8.0_65, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk1.8.0_65.jdk/Contents/Home/jreDefault locale: zh_CN, platform encoding: UTF-8OS name: "mac os x", version: "10.13.6", arch: "x86_64", family: "mac"另外我们推荐使用 ItelliJ IDEA (社区免费版已够用)作为 Flink 应用程序的开发 IDE。Eclipse 虽然也可以,但是 Eclipse 在 Scala 和 Java 混合型项目下会有些已知问题,所以不太推荐 Eclipse。下一章节,我们会介绍如何创建一个 Flink 工程并将其导入 ItelliJ IDEA。创建 Maven 项目我们将使用 Flink Maven Archetype 来创建我们的项目结构和一些初始的默认依赖。在你的工作目录下,运行如下命令来创建项目: ...

June 20, 2019 · 2 min · jiezi

Blink-有何特别之处菜鸟供应链场景最佳实践

作者:晨笙、缘桥菜鸟供应链业务链路长、节点多、实体多,使得技术团队在建设供应链实时数仓的过程中,面临着诸多挑战,如:如何实现实时变Key统计?如何实现实时超时统计?如何进行有效地资源优化?如何提升多实时流关联效率?如何提升实时作业的开发效率? 而 Blink 能否解决这些问题?下面一起来深入了解。背景菜鸟从2017年4月开始探索 Blink(即 Apache Flink 的阿里内部版本),2017年7月开始在线上环境使用 Blink,作为我们的主流实时计算引擎。 为什么短短几个月的探索之后,我们就选择Blink作为我们主要的实时计算引擎呢? 在效率上,Blink 提供 DataStream、TableAPI、SQL 三种开发模式,强大的 SQL 模式已经满足大部分业务场景,配合半智能资源优化、智能倾斜优化、智能作业压测等功能,可以极大地提升实时作业的开发效率;在性能上,诸如MiniBatch&MicroBatch、维表 Async&Cache、利用 Niagara 进行本地状态管理等内部优化方案,可以极大地提升实时作业的性能;在保障上,Blink 自带的 Failover 恢复机制,能够实现线程级的恢复,可以做到分钟级恢复,配合 Kmonitor 监控平台、烽火台预警平台,可以有效地实现实时作业的数据保障。 接下来,我将结合供应链业务的一些业务场景,简要说明,Blink 如何解决我们遇到的一些实际问题。 回撤机制订单履行是供应链业务中最常见的物流场景。什么是订单履行呢?当商家 ERP 推单给菜鸟之后,菜鸟履行系统会实时计算出每笔订单的出库、揽收、签收等节点的预计时间,配送公司需要按照各节点的预计时间进行订单的配送。为了保证订单的准点履约,我们经常需要统计每家配送公司每天各个节点的预计单量,便于配送公司提前准备产能。 看似很简单的实时统计加工,我们在开发过程中遇到了什么问题呢?履行重算!当物流订单的上游某个节点延迟时,履行系统会自动重算该笔订单下游所有节点的预计时间。比如某个物流订单出库晚点后,其后的预计揽收时间、预计签收时间都会重算。而对于大部分的实时计算引擎来说,并不能很友好的支持这种变 Key 统计的问题。以前,数据量没那么大的时候,还可以通过 OLAP 数据库来解决这类场景,当量上来后, OLAP 方案的成本、性能都是很大的问题。 除了 OLAP 方案,我们提倡采用 Blink 已经内置的 Retraction 机制,来解决这类变 Key 统计的问题,这也是我们在2017年初就开始尝试 Blink 的重要原因。Blink 的Retraction 机制,使用 State 在内存或者外部存储设备中对数据进行统计处理,当上游数据源对某些汇总 Key 的数据做更新时,Blink 会主动给下游下发一个删除消息从而“撤回”之前的那条消息,并用最新下发的消息对表做更新操作。Retraction的实现细节,可以参见:Retraction for Flink Streaming。 下面是一个简化后的案例,供了解Blink Retraction的内部计算过程: 对于上述案例,可以通过 Blink 提供的强大的、灵活的、简易的 SQL 开发模式来实现,只需要几行 SQL 即可完成。 ...

June 17, 2019 · 2 min · jiezi

如何从小白进化成-Apache-Flink-技术专家9节基础课程免费公开

随着数据量的爆发,AI走上风口,典型的大数据业务场景下数据业务最通用的做法是:选用批计算的技术处理全量数据,采用流计算的技术处理实时增量数据。在生产环境中,用户通常采用批处理和流处理两套计算引擎来支持这两种场景。弊端就是需要写两套代码,维护两套引擎,毫无疑问,这种架构带来了额外的负担与成本。 面对全量数据和增量数据,能否用一套统一的大数据引擎技术来处理? Apache Flink 被业界公认为最好的流计算引擎,其计算能力不仅仅局限于做流处理,而是一套兼具流、批、机器学习等多种计算功能的大数据引擎,用户只需根据业务逻辑开发一套代码,无论是全量数据还是增量数据,亦或者实时处理,一套方案即可全部支持。为了让大家更全面地了解 Apache Flink 背后的技术以及应用实践,今天,我们首次免费公开 Apache Flink 系列视频课程。 为什么要收藏 Apache Flink 系列课程?2018年市场调查报告显示 Apache Flink 是2018年开源大数据生态中发展“最快”的引擎,相较于2017年增长了125% 。Flink 的社区生态在不断发展壮大,在中国,越来越多的互联网公司在生产环境中采用Flink解决实时计算、流计算、风控等问题,因而,学习 Flink 迫在眉睫。 此次免费公开课共分为9个课时,课程内容包含 Flink 的基础架构、应用场景、集群部署、运行机制、编程范式,为你系统地拆分讲解大数据计算开发引擎Flink。 1.1 为什么要学习 Apache Flink? 关键词:Flink 的重要性 课程开篇由阿里巴巴高级产品专家,实时计算产品团队负责人陈守元(巴真)开讲,从开设Apache Flink 系列课程的初衷、Apache Flink 的定义/架构/原理以及学前准备与学习方法与你分享如何高效学习 Flink 系列课程。 1.2 Flink 基本概念 关键词:Apache Flink PMC、有状态的流式处理 本节课程由 Apache Flink PMC、Ververica Software Engineer 戴资力与你探讨 Flink 作为有状态的流式处理引擎的核心概念应当如何理解,Flink 与其他大数据引擎的区别是什么?为什么要使用 Flink 以及有状态的流式处理引擎面临哪些挑战? 1.3 Flink 安装部署、环境配置及运行应用程序 关键词:开发 Flink 必经第一课 破解“知易行难”的方法是实战,第三节内容由阿里巴巴高级开发工程师沙晟阳带你从Flink开发环境的部署、配置、运行,以及不同模式的应用场景入手,示范如何快速正确安装应用Flink,并为你提供了实际应用中可能出现的问题与相应的解决方案。 1.4 DataStream API 编程 ...

June 14, 2019 · 1 min · jiezi

360深度实践Flink-与-Storm-协议级对比

作者:张馨予 本文从数据传输和数据可靠性的角度出发,对比测试了 Storm 与 Flink 在流处理上的性能,并对测试结果进行分析,给出在使用 Flink 时提高性能的建议。 Apache Storm、Apache Spark 和 Apache Flink 都是开源社区中非常活跃的分布式计算平台,在很多公司可能同时使用着其中两种甚至三种。对于实时计算来说,Storm 与 Flink 的底层计算引擎是基于流的,本质上是一条一条的数据进行处理,且处理的模式是流水线模式,即所有的处理进程同时存在,数据在这些进程之间流动处理。而 Spark 是基于批量数据的处理,即一小批一小批的数据进行处理,且处理的逻辑在一批数据准备好之后才会进行计算。在本文中,我们把同样基于流处理的 Storm 和 Flink 拿来做对比测试分析。 在我们做测试之前,调研了一些已有的大数据平台性能测试报告,比如,雅虎的 Streaming-benchmarks,或者 Intel 的 HiBench 等等。除此之外,还有很多的论文也从不同的角度对分布式计算平台进行了测试。虽然这些测试 case 各有不同的侧重点,但他们都用到了同样的两个指标,即吞吐和延迟。吞吐表示单位时间内所能处理的数据量,是可以通过增大并发来提高的。延迟代表处理一条数据所需要的时间,与吞吐量成反比关系。 在我们设计计算逻辑时,首先考虑一下流处理的计算模型。上图是一个简单的流计算模型,在 Source 中将数据取出,发往下游 Task ,并在 Task 中进行处理,最后输出。对于这样的一个计算模型,延迟时间由三部分组成:数据传输时间、 Task 计算时间和数据排队时间。我们假设资源足够,数据不用排队。则延迟时间就只由数据传输时间和 Task 计算时间组成。而在 Task 中处理所需要的时间与用户的逻辑息息相关,所以对于一个计算平台来说,数据传输的时间才更能反映这个计算平台的能力。因此,我们在设计测试 Case 时,为了更好的体现出数据传输的能力,Task 中没有设计任何计算逻辑。 在确定数据源时,我们主要考虑是在进程中直接生成数据,这种方法在很多之前的测试标准中也同样有使用。这样做是因为数据的产生不会受到外界数据源系统的性能限制。但由于在我们公司内部大部分的实时计算数据都来源于 kafka ,所以我们增加了从 kafka 中读取数据的测试。 对于数据传输方式,可以分为两种:进程间的数据传输和进程内的数据传输。 进程间的数据传输是指这条数据会经过序列化、网络传输和反序列化三个步骤。在 Flink 中,2个处理逻辑分布在不同的 TaskManager 上,这两个处理逻辑之间的数据传输就可以叫做进程间的数据传输。Flink 网络传输是采用的 Netty 技术。在 Storm 中,进程间的数据传输是 worker 之间的数据传输。早版本的 storm 网络传输使用的 ZeroMQ,现在也改成了 Netty。 ...

June 13, 2019 · 2 min · jiezi

Flink-全网最全资源视频博客PPT入门实战源码解析问答等持续更新

Flink 学习项目代码https://github.com/zhisheng17/flink-learning http://www.54tianzhisheng.cn/2019/12/31/Flink-resources/ 麻烦路过的各位亲给这个项目点个 star,太不易了,写了这么多,算是对我坚持下来的一种鼓励吧! 本项目结构 博客1、Flink 从0到1学习 —— Apache Flink 介绍 2、Flink 从0到1学习 —— Mac 上搭建 Flink 1.6.0 环境并构建运行简单程序入门 3、Flink 从0到1学习 —— Flink 配置文件详解 4、Flink 从0到1学习 —— Data Source 介绍 5、Flink 从0到1学习 —— 如何自定义 Data Source ? 6、Flink 从0到1学习 —— Data Sink 介绍 7、Flink 从0到1学习 —— 如何自定义 Data Sink ? 8、Flink 从0到1学习 —— Flink Data transformation(转换) 9、Flink 从0到1学习 —— 介绍 Flink 中的 Stream Windows 10、Flink 从0到1学习 —— Flink 中的几种 Time 详解 ...

June 3, 2019 · 4 min · jiezi

谈谈流计算中的『Exactly-Once』特性

作者:宝牛 本文翻译自 streaml.io 网站上的一篇博文:“Exactly once is NOT exactly the same” ,分析了流计算系统中常说的『Exactly Once』特性,主要观点是:『精确一次』并不保证是完全一样。主要内容如下: 背景1.1. 最多一次(At-most-once)1.2. 至少一次(At-least-once)1.3. 精确一次(Exactly-once)『精确一次』是真正的『精确一次』吗?分布式快照与至少一次事件传递和重复数据删除的比较结论参考目前市面上使用较多的流计算系统有 Apache Storm,Apache Flink, Heron, Apache Kafka (Kafka Streams) 和 Apache Spark (Spark Streaming)。关于流计算系统有个被广泛讨论的特性是『exactly-once』语义,很多系统宣称已经支持了这一特性。但是,到底什么是『exactly-once』,怎么样才算是实现了『exactly-once』,人们存在很多误解和歧义。接下来我们做下分析。 一、背景流处理(有时称为事件处理)可以简单地描述为是对无界数据或事件的连续处理。流或事件处理应用程序可以或多或少地被描述为有向图,并且通常被描述为有向无环图(DAG)。在这样的图中,每个边表示数据或事件流,每个顶点表示运算符,会使用程序中定义的逻辑处理来自相邻边的数据或事件。有两种特殊类型的顶点,通常称为 sources 和 sinks。sources读取外部数据/事件到应用程序中,而 sinks 通常会收集应用程序生成的结果。下图是流式应用程序的示例。 A typical stream processing topology 流处理引擎通常允许用户指定可靠性模式或处理语义,以指示它将为整个应用程序中的数据处理提供哪些保证。这些保证是有意义的,因为你始终会遇到由于网络,机器等可能导致数据丢失的故障。流处理引擎通常为应用程序提供了三种数据处理语义:最多一次、至少一次和精确一次。 如下是对这些不同处理语义的宽松定义: 最多一次(At-most-once)这本质上是一『尽力而为』的方法。保证数据或事件最多由应用程序中的所有算子处理一次。 这意味着如果数据在被流应用程序完全处理之前发生丢失,则不会进行其他重试或者重新发送。下图中的例子说明了这种情况。 At-most-once processing semantics 至少一次(At-least-once)应用程序中的所有算子都保证数据或事件至少被处理一次。这通常意味着如果事件在流应用程序完全处理之前丢失,则将从源头重放或重新传输事件。然而,由于事件是可以被重传的,因此一个事件有时会被处理多次,这就是所谓的至少一次。 下图的例子描述了这种情况:第一个算子最初未能成功处理事件,然后在重试时成功,接着在第二次重试时也成功了,其实是没有必要的。 At-least-once processing semantics 精确一次(Exactly-once)即使是在各种故障的情况下,流应用程序中的所有算子都保证事件只会被『精确一次』的处理。(也有文章将 Exactly-once 翻译为:完全一次,恰好一次) 通常使用两种流行的机制来实现『精确一次』处理语义。 分布式快照 / 状态检查点至少一次事件传递和对重复数据去重实现『精确一次』的分布式快照/状态检查点方法受到 Chandy-Lamport 分布式快照算法的启发[1]。通过这种机制,流应用程序中每个算子的所有状态都会定期做 checkpoint。如果是在系统中的任何地方发生失败,每个算子的所有状态都回滚到最新的全局一致 checkpoint 点。在回滚期间,将暂停所有处理。源也会重置为与最近 checkpoint 相对应的正确偏移量。整个流应用程序基本上是回到最近一次的一致状态,然后程序可以从该状态重新启动。下图描述了这种 checkpoint 机制的基础知识。 ...

May 31, 2019 · 1 min · jiezi

Apache-Flink-Time-Window-深度解析

作者:邱从贤 1、 Window & Time 介绍Apache Flink(以下简称 Flink) 是一个天然支持无限流数据处理的分布式计算框架,在 Flink 中 Window 可以将无限流切分成有限流,是处理有限流的核心组件,现在 Flink 中 Window 可以是时间驱动的(Time Window),也可以是数据驱动的(Count Window)。 下面的代码是在 Flink 中使用 Window 的两个示例 2、 Window API 使用从第一部分我们已经知道 Window 的一些基本概念,以及相关 API,下面我们以一个实际例子来看看怎么使用 Window 相关的 API。 代码来自 flink-examples 上面的例子中我们首先会对每条数据进行时间抽取,然后进行 keyby,接着依次调用 window(),evictor(), trigger() 以及 maxBy()。下面我们重点来看 window(), evictor() 和 trigger() 这几个方法。 2.1 WindowAssigner, Evictor 以及 Trigger window 方法接收的输入是一个WindowAssigner, WindowAssigner 负责将每条输入的数据分发到正确的 window 中(一条数据可能同时分发到多个 Window 中),Flink 提供了几种通用的 WindowAssigner:tumbling window(窗口间的元素无重复),sliding window(窗口间的元素可能重复),session window 以及 global window。如果需要自己定制数据分发策略,则可以实现一个 class,继承自 WindowAssigner。 ...

May 6, 2019 · 2 min · jiezi

Deploy-Apache-Flink-Natively-on-YARNKubernetes

作者:任春德 Apache Flink作为下一代大数据计算引擎,在迅速发展强大中,其内部架构也在不断优化重构,以适应更多运行时环境和更大计算规模,Flink Improvement Proposals-6重新设计了在各集群管理系统(Standalone/YARN/Kubernetes等)上资源调度的统一架构,本文将介绍资源调度的架构发展及其清晰分层等设计特点,YARN上per-Job和session两种模式的实现,以及正在讨论开发的与K8S云原生融合的详细设计。 本文内容如下: Apache Flink Standalone ClusterApache Flink 与 YARN 的原生融合Apache Flink 与 K8S 的原生融合小结Apache Flink Standalone Cluster如图1,Flink的Standalone集群部署是主从架构,其中主JobManager(简称JM)负责Job的计算单元Task调度,TaskManager(简称TM)向JobManager汇报并负责在其内部用线程执行Task。 之所以是Standalone,是因为其不依赖其他底层资源调度系统,直接部署启动在各自的裸机器节点上,虽然可以用一些自动化运维工具方便地部署和管理,但是存在以下几个问题: 隔离:多Job运行在一个集群,可能同一TM上执行不同Job的Task,其线程所用资源(cpu/mem)无法控制,相互影响,甚至一个Task造成整个TM的Out Of Memory,使其之上的Job都受影响;多个Job的调度也在同一个JM中,同样存在被有问题Job影响的问题。多租户的资源用量(quota)管理:无法控制用户的Job资源使用总量,缺乏租户间的资源协调管理。集群的可用性:虽然JM可以部署有Standby,支持High Available,但JM、TM进程缺乏被看护,难免因以上隔离等问题造成过多进程宕掉,整个集群不可用。集群的可运维:版本升级,扩缩容等都需要复杂的运维操作。为了解决以上问题,需要将Flink跑在流行成熟的资源调度系统上,如YARN、Kubernetes、Mesos,如何实现呢? Flink 与 YARN 的原生融合Apache Flink Standalone Cluster on YARN简单有效的一种部署方式是利用YARN自身支持的特性,将Flink Standalone部署到YARN集群上,如图2(Apache Flink Standalone Cluster ON YARN), 多个Job可以相应地起多个YARN Application,每个app是一个standalone cluster,各自独立运行,而且依靠YARN本身支持的cgroups等隔离手段,避免了多任务间的相互影响,隔离问题迎刃而解。不同用户的App也可以运行在不同的YARN调度队列中,通过queue quota管理能力解决多租户的问题。同时可以利用YARN对App进程的重启重试再调度的策略,使Flink Standalone Cluster高可用。简单的参数、配置文件修改,通过YARN的distributed cache分发Flink jar,就可以方便的升级和扩缩容。虽然解决了以上问题,但是每个(少量)Job起一个Standalone Cluster,难以达到高效的资源利用,因为: Cluster的规模(多少个TM)是在启动YARN App时参数静态指定的,Flink自身的编译优化使其较难在运行前预估资源的需求,那就难以合理化TM数量,多了资源浪费,少了影响Job执行速度甚至无法运行。每个TM拥有的资源大小也是参数静态指定,同样难以预估实际需要,不能针对不同的Task资源需求来动态申请不同大小的TM,只能设置相同规格大小的TM,那就难以恰好放置整数个Task,剩余的部分资源浪费。App的启动(1.Submit YARN App)和Flink Job的提交(7.Submit Job)需要2阶段完成,会使每个任务的提交效率低,造成集群的资源流转率也会降低。大规模YARN集群中Flink Job越多,资源浪费的会更可观,成本损失越大,而且不只是on YARN存在以上问题,Standalone直接运行于其他资源调度系统之上,也是有相同问题,所以阿里巴巴实时计算率先在YARN实际生产经验上改进了Flink的资源利用模型,后续与社区讨论设计实现了一套通用的架构,适用于不同的资源调度系统。 FLIP-6 - Deployment and Process ModelFLIP-6全面记录了此次部署架构的重构,新的模块如图3。类似MapReduce-1架构向YARN+MapReduce-2的升级,将资源调度与Job计算逻辑单元(Task)的调度分成2层,使两个模块(系统)——ResourceManager(RM)和JobManager(JM)各司其职,与底层资源调度系统的耦合降低(只需实现不同plugable的ResourceManager即可),减少逻辑复杂度降低开发维护难度,优化JM实现资源按Task所需申请,解决了Standalone on YARN/K8S的资源利用率低的问题,同时还有利于集群和Job规模的扩展。 ...

May 6, 2019 · 1 min · jiezi

Apache-Flink®生态所面临的机遇与挑战

作者:简锋 引言在谈生态之前,我们来聊聊什么是生态。生态是指在某个特定领域,以某个组件为核心衍生出来其他多个组件,这些组件可以间接或者直接用到这个核心组件,然后辅助这个核心组件共同完成一个更大或者更特殊的任务。Flink生态圈就是指以Flink为核心的生态圈,Flink属于大数据生态里的计算环节,只做计算,不做存储。但是在实际工作当中,你会发现往往单独用Flink是不够的。比如你的数据是从哪里读出来,Flink计算完之后数据又将存到哪里,又怎么消费这些数据。如何利用Flink来完成某个垂直领域的特殊任务等等。这些涉及到上下游,或者更高抽象的任务都需要一个强大的生态圈来完成。 Flink生态的现状在讲清楚了什么是生态之后,我们来聊聊目前Flink生态的现状。整体而言Flink生态还处于相对初级的阶段。Flink生态目前主要侧重于各种上下游的connector和对各种集群的支持。 截至目前Flink支持的connector有:Kafka,Cassandra,Elasticsearch,Kinesis,RabbitMQ,JDBC,HDFS等等,基本支持所有主流数据源。在集群支持方面,目前Flink支持Standalone和YARN。基于目前生态的状况,Flink仍然主要应用于流数据的计算。如果要用Flink要做其他一些场景(机器学习,交互式分析)就会比较复杂,用户体验上还有很大的提升空间。这也正是Flink生态所面临的挑战和机遇。 Flink生态的挑战和机遇Flink致力于作为一个批流统一的大数据计算平台,还有很多潜力没有发挥出来,要完全发挥出它的潜力,就需要一个强大的生态系统。总的来说我们可以从2个维度来看这个生态系统: 横向维度。 横向维度的生态主要是为构建一个端到端的解决方案。比如连接上下游数据源的各种connector,与下游机器学习框架的整合,与下游BI工具的整合,方便提交和运维Flink Job的工具,提供更好交互式分析体验的Notebook。纵向维度。纵向维度是指更加抽象化Flink的计算引擎以适应各种计算场景。比如批流计算的统一,更高计算抽象层Table API,复杂事件处理引擎(CEP),更高机器学习计算框架(Flink ML),对各种集群框架的适配等等。下图是对整个Flink生态在横向和纵向2个维度的描述。 接下来我会对几个主要的生态点进行逐个阐述 Flink对Hive的集成和支持Apache Hive是一个有将近10年历史的Apache顶级项目。项目最初在MapReduce引擎的基础上封装了SQL,用户不再需要写复杂的MapReduce Job,而只需写简单熟悉的SQL语句,用户的SQL会被翻译成一个或多个MapReduce Job。随着项目的不断演进,Hive的计算引擎发展成可以插拔式,比如,现在Hive就支持MR, Tez, Spark 3种计算引擎。Apache Hive现在已经成为Hadoop生态圈中事实上数据仓库的标准,很多公司的数据仓库系统已经在Hive上运转了很多年。 Flink作为一个批流统一的计算框架,与Hive的集成就变得很自然了。比如通过Flink来做实时ETL,构建实时数据仓库,然后用Hive SQL做实时数据的查询。 Flink社区已经创建了 FLINK-10556 来对Hive更好的集成和支持。主要实现的功能有以下几点: 允许Flink访问Hive的元数据允许Flink访问Hive的表数据Flink兼容Hive的数据类型Flink可以使用Hive UDF可以在Flink里使用Hive SQL(包括DML和DDL)Flink社区正在逐渐实现以上功能。如果你想提前体验以上功能,可以试用阿里巴巴开源的Blink。开源的Blink已经在元数据(meta data)和数据层将Flink和Hive对接和打通, 用户可以直接用Flink SQL去查询Hive的数据,真正能够做到在Hive引擎和Flink引擎之间的自由切换。为了打通元数据,Blink重构了Flink catalog的实现,并且增加了两种catalog,一个是基于内存存储的FlinkInMemoryCatalog,另外一个是能够桥接Hive MetaStore的HiveCatalog。有了这个HiveCatalog,Flink作业就能读取Hive的MetaData。为了打通数据,Blink实现了HiveTableSource,使得Flink job可以直接读取Hive中普通表和分区表的数据。因此,通过这个版本,用户可以使用Flink SQL读取已有的Hive meta和data,做数据处理。未来阿里巴巴将在Flink上继续加大对Hive兼容性的支持,包括支持Hive特有的query,data type,和Hive UDF等等,这些改进都会陆续回馈到Flink社区。 Flink对交互式分析的支持批处理是流处理之外另一个更大的应用场景。而交互式分析又是批处理的一个大类,特别对于数据分析师和数据科学家,交互式分析尤为重要。 对于交互式分析,Flink本身需要做进一步的改进,以提高Flink在交互式分析方面的性能要求。比如 FLINK-11199,现在在同一个Flink App中的多个Job之间是没法共享数据的,每个Job的DAG是独立的,FLINK-11199 就是要解决这个问题,从而对交互式分析提供更友好的支持。 此外,我们需要提供一个交互式分析的平台让数据分析师/数据科学家更高效得使用Flink。在这方面Apache Zeppelin已经做了很多工作。 Apache Zeppelin也是Apache的顶级项目,Zeppelin提供一个交互式开发环境,支持Scala,Python,SQL等多种语言,此外Zeppelin天然具有极强的可扩展性,支持多种大数据引擎,比如Spark,Hive,Pig等等。阿里巴巴做了大量的工作让Zeppelin能够更好的支持Flink。用户可以直接在Zeppelin里面写Flink代码(Scala或者SQL),而不用在本地打包,然后用bin/flink脚本来手动提交Job,在Zeppelin里你可以直接提交Job,然后看到Job的结果,Job结果既可以是文本形式,也可以是可视化出来,特别对于SQL的结果,可视化尤为显得重要。下面这些是Zeppelin对Flink支持的一些要点: 支持3种运行模式:Local, Remote和Yarn支持运行Scala,Batch Sql和Stream Sql支持可视化静态table和动态table自动关联Job URL支持Cancel Job支持Flink job的savepoint支持ZeppelinContext的高级功能,比如创建控件提供3个tutorial notes: Streaming ETL, Flink Batch Tutorial, Flink Stream Tutorial这些改动有些是在Flink上的,有些是在Zeppelin上的。在这些改动全部推回Flink和Zeppelin社区之前,大家可以使用这个Zeppelin Docker Image (Blink开源文档里的examples中有具体如何下载安装的细节)来测试和使用这些功能。为了方便用户试用,我们在这一版zeppelin中提供3个built-in的Flink tutorial的例子: 一个是做Streaming ETL的例子, 另外两个分别是做Flink Batch, Flink Stream的基础样例。具体如何使用,可以参考以下2个链接 ...

May 5, 2019 · 1 min · jiezi

阿里巴巴为什么选择Apache-Flink

作者:王峰 整理:韩非 本文主要整理自云栖大会阿里巴巴计算平台事业部资深技术专家王峰(花名:莫问)在云栖大会‘开发者生态峰会’上发表的演讲。 伴随着海量增长的数据,数字化时代的未来感扑面而至。不论是结绳记事的小数据时代,还是我们正在经历的大数据时代,计算的边界正在被无限拓宽,而数据的价值,再也难以被计算。时下,谈及大数据,不得不提到最热门的下一代大数据计算引擎Apache Flink(以下简称Flink)。本文将结合Flink的前世今生,从业务角度出发,向大家娓娓道来:为什么阿里选择了Flink? 合抱之木,生于毫末随着人工智能时代的降临,数据量的爆发,在典型的大数据的业务场景下数据业务最通用的做法是:选用批处理的技术处理全量数据,采用流式计算处理实时增量数据。在绝大多数的业务场景之下,用户的业务逻辑在批处理和流处理之中往往是相同的。但是,用户用于批处理和流处理的两套计算引擎是不同的。因此,用户通常需要写两套代码。毫无疑问,这带来了一些额外的负担和成本。阿里巴巴的商品数据处理就经常需要面对增量和全量两套不同的业务流程问题,所以阿里就在想,我们能不能有一套统一的大数据引擎技术,用户只需要根据自己的业务逻辑开发一套代码。这样在各种不同的场景下,不管是全量数据还是增量数据,亦或者实时处理,一套方案即可全部支持,这就是阿里选择Flink的背景和初衷。 目前开源大数据计算引擎有很多选择,流计算如Storm、Samza、Flink、Kafka Stream等,批处理如Spark、Hive、Pig、Flink等。而同时支持流处理和批处理的计算引擎,只有两种选择:一个是Apache Spark,一个是Apache Flink。 从技术,生态等各方面的综合考虑,首先,Spark的技术理念是基于批来模拟流的计算。而Flink则完全相反,它采用的是基于流计算来模拟批计算。 从技术发展方向看,用批来模拟流有一定的技术局限性,并且这个局限性可能很难突破。而Flink基于流来模拟批,在技术上有更好的扩展性。从长远来看,阿里决定用Flink做一个统一的、通用的大数据引擎作为未来的选型。 Flink是一个低延迟、高吞吐、统一的大数据计算引擎。在阿里巴巴的生产环境中,Flink的计算平台可以实现毫秒级的延迟情况下,每秒钟处理上亿次的消息或者事件。同时Flink提供了一个Exactly-once的一致性语义。保证了数据的正确性。这样就使得Flink大数据引擎可以提供金融级的数据处理能力。 Flink在阿里的现状基于Apache Flink在阿里巴巴搭建的平台于2016年正式上线,并从阿里巴巴的搜索和推荐这两大场景开始实现。目前阿里巴巴所有的业务,包括阿里巴巴所有子公司都采用了基于Flink搭建的实时计算平台。同时Flink计算平台运行在开源的Hadoop集群之上。采用Hadoop的YARN做为资源管理调度,以 HDFS作为数据存储。因此,Flink可以和开源大数据软件Hadoop无缝对接。 目前,这套基于Flink搭建的实时计算平台不仅服务于阿里巴巴集团内部,而且通过阿里云的云产品API向整个开发者生态提供基于Flink的云产品支持。 Flink在阿里巴巴的大规模应用,表现如何?规模:一个系统是否成熟,规模是重要指标,Flink最初上线阿里巴巴只有数百台服务器,目前规模已达上万台,此等规模在全球范围内也是屈指可数;状态数据:基于Flink,内部积累起来的状态数据已经是PB级别规模;Events:如今每天在Flink的计算平台上,处理的数据已经超过万亿条;TPS:在峰值期间可以承担每秒超过4.72亿次的访问,最典型的应用场景是阿里巴巴双11大屏; Flink的发展之路接下来从开源技术的角度,来谈一谈Apache Flink是如何诞生的,它是如何成长的?以及在成长的这个关键的时间点阿里是如何进入的?并对它做出了那些贡献和支持? Flink诞生于欧洲的一个大数据研究项目StratoSphere。该项目是柏林工业大学的一个研究性项目。早期,Flink是做Batch计算的,但是在2014年,StratoSphere里面的核心成员孵化出Flink,同年将Flink捐赠Apache,并在后来成为Apache的顶级大数据项目,同时Flink计算的主流方向被定位为Streaming,即用流式计算来做所有大数据的计算,这就是Flink技术诞生的背景。 2014年Flink作为主攻流计算的大数据引擎开始在开源大数据行业内崭露头角。区别于Storm、Spark Streaming以及其他流式计算引擎的是:它不仅是一个高吞吐、低延迟的计算引擎,同时还提供很多高级的功能。比如它提供了有状态的计算,支持状态管理,支持强一致性的数据语义以及支持Event Time,WaterMark对消息乱序的处理。 Flink核心概念以及基本理念Flink最区别于其他流计算引擎的,其实就是状态管理。 什么是状态?例如开发一套流计算的系统或者任务做数据处理,可能经常要对数据进行统计,如Sum、Count、Min、Max,这些值是需要存储的。因为要不断更新,这些值或者变量就可以理解为一种状态。如果数据源是在读取Kafka、RocketMQ,可能要记录读取到什么位置,并记录Offset,这些Offset变量都是要计算的状态。 Flink提供了内置的状态管理,可以把这些状态存储在Flink内部,而不需要把它存储在外部系统。这样做的好处是第一降低了计算引擎对外部系统的依赖以及部署,使运维更加简单;第二,对性能带来了极大的提升:如果通过外部去访问,如Redis,HBase,它一定是通过网络及RPC。如果通过Flink内部去访问,它只通过自身的进程去访问这些变量。同时Flink会定期将这些状态做Checkpoint持久化,把Checkpoint存储到一个分布式的持久化系统中,比如HDFS。这样的话,当Flink的任务出现任何故障时,它都会从最近的一次Checkpoint将整个流的状态进行恢复,然后继续运行它的流处理。对用户没有任何数据上的影响。 Flink是如何做到在Checkpoint恢复过程中没有任何数据的丢失和数据的冗余?来保证精准计算的? 这其中原因是Flink利用了一套非常经典的Chandy-Lamport算法,它的核心思想是把这个流计算看成一个流式的拓扑,定期从这个拓扑的头部Source点开始插入特殊的Barriers,从上游开始不断的向下游广播这个Barriers。每一个节点收到所有的Barriers,会将State做一次Snapshot,当每个节点都做完Snapshot之后,整个拓扑就算完整的做完了一次Checkpoint。接下来不管出现任何故障,都会从最近的Checkpoint进行恢复。 Flink利用这套经典的算法,保证了强一致性的语义。这也是Flink与其他无状态流计算引擎的核心区别。 下面介绍Flink是如何解决乱序问题的。比如星球大战的播放顺序,如果按照上映的时间观看,可能会发现故事在跳跃。 在流计算中,与这个例子是非常类似的。所有消息到来的时间,和它真正发生在源头,在线系统Log当中的时间是不一致的。在流处理当中,希望是按消息真正发生在源头的顺序进行处理,不希望是真正到达程序里的时间来处理。Flink提供了Event Time和WaterMark的一些先进技术来解决乱序的问题。使得用户可以有序的处理这个消息。这是Flink一个很重要的特点。 接下来要介绍的是Flink启动时的核心理念和核心概念,这是Flink发展的第一个阶段;第二个阶段时间是2015年和2017年,这个阶段也是Flink发展以及阿里巴巴介入的时间。故事源于2015年年中,我们在搜索事业部的一次调研。当时阿里有自己的批处理技术和流计算技术,有自研的,也有开源的。但是,为了思考下一代大数据引擎的方向以及未来趋势,我们做了很多新技术的调研。 结合大量调研结果,我们最后得出的结论是:解决通用大数据计算需求,批流融合的计算引擎,才是大数据技术的发展方向,并且最终我们选择了Flink。 但2015年的Flink还不够成熟,不管是规模还是稳定性尚未经历实践。最后我们决定在阿里内部建立一个Flink分支,对Flink做大量的修改和完善,让其适应阿里巴巴这种超大规模的业务场景。在这个过程当中,我们团队不仅对Flink在性能和稳定性上做出了很多改进和优化,同时在核心架构和功能上也进行了大量创新和改进,并将其贡献给社区,例如:Flink新的分布式架构,增量Checkpoint机制,基于Credit-based的网络流控机制和Streaming SQL等。 阿里巴巴对Flink社区的贡献我们举两个设计案例,第一个是阿里巴巴重构了Flink的分布式架构,将Flink的Job调度和资源管理做了一个清晰的分层和解耦。这样做的首要好处是Flink可以原生的跑在各种不同的开源资源管理器上。经过这套分布式架构的改进,Flink可以原生地跑在Hadoop Yarn和Kubernetes这两个最常见的资源管理系统之上。同时将Flink的任务调度从集中式调度改为了分布式调度,这样Flink就可以支持更大规模的集群,以及得到更好的资源隔离。 另一个是实现了增量的Checkpoint机制,因为Flink提供了有状态的计算和定期的Checkpoint机制,如果内部的数据越来越多,不停地做Checkpoint, Checkpoint会越来越大,最后可能导致做不出来。提供了增量的Checkpoint后,Flink会自动地发现哪些数据是增量变化,哪些数据是被修改了。同时只将这些修改的数据进行持久化。这样Checkpoint不会随着时间的运行而越来越难做,整个系统的性能会非常地平稳,这也是我们贡献给社区的一个很重大的特性。 经过2015年到2017年对Flink Streaming的能力完善,Flink社区也逐渐成熟起来。Flink也成为在Streaming领域最主流的计算引擎。因为Flink最早期想做一个流批统一的大数据引擎,2018年已经启动这项工作,为了实现这个目标,阿里巴巴提出了新的统一API架构,统一SQL解决方案,同时流计算的各种功能得到完善后,我们认为批计算也需要各种各样的完善。无论在任务调度层,还是在数据Shuffle层,在容错性,易用性上,都需要完善很多工作。 篇幅原因,下面主要和大家分享两点: 统一 API Stack统一 SQL方案先来看下目前Flink API Stack的一个现状,调研过Flink或者使用过Flink的开发者应该知道。Flink有2套基础的API,一套是DataStream,一套是DataSet。DataStream API是针对流式处理的用户提供,DataSet API是针对批处理用户提供,但是这两套API的执行路径是完全不一样的,甚至需要生成不同的Task去执行。所以这跟得到统一的API是有冲突的,而且这个也是不完善的,不是最终的解法。在Runtime之上首先是要有一个批流统一融合的基础API层,我们希望可以统一API层。 因此,我们在新架构中将采用一个DAG(有限无环图)API,作为一个批流统一的API层。对于这个有限无环图,批计算和流计算不需要泾渭分明的表达出来。只需要让开发者在不同的节点,不同的边上定义不同的属性,来规划数据是流属性还是批属性。整个拓扑是可以融合批流统一的语义表达,整个计算无需区分是流计算还是批计算,只需要表达自己的需求。有了这套API后,Flink的API Stack将得到统一。 ...

May 5, 2019 · 1 min · jiezi

深度剖析阿里巴巴对Apache-Flink的优化与改进

本文主要从两个层面深度剖析:阿里巴巴对Flink究竟做了哪些优化? 取之开源,用之开源一、SQL层 为了能够真正做到用户根据自己的业务逻辑开发一套代码,能够同时运行在多种不同的场景,Flink首先需要给用户提供一个统一的API。在经过一番调研之后,阿里巴巴实时计算认为SQL是一个非常适合的选择。在批处理领域,SQL已经经历了几十年的考验,是公认的经典。在流计算领域,近年来也不断有流表二象性、流是表的ChangeLog等理论出现。在这些理论基础之上,阿里巴巴提出了动态表的概念,使得流计算也可以像批处理一样使用SQL来描述,并且逻辑等价。这样一来,用户就可以使用SQL来描述自己的业务逻辑,相同的查询语句在执行时可以是一个批处理任务,也可以是一个高吞吐低延迟的流计算任务,甚至是先使用批处理技术进行历史数据的计算,然后自动的转成流计算任务处理最新的实时数据。在这种声明式的API之下,引擎有了更多的选择和优化空间。接下来,我们将介绍其中几个比较重要的优化。 首先是对SQL层的技术架构进行升级和替换。调研过Flink或者使用过Flink的开发者应该知道,Flink有两套基础的API,一套是DataStream,另一套是DataSet。DataStream API是针对流式处理的用户提供,DataSet API是针对批处理用户提供,但是这两套API的执行路径是完全不一样的,甚至需要生成不同的Task去执行。Flink原生的SQL层在经过一系列优化之后,会根据用户希望是批处理还是流处理的不同选择,去调用DataSet或者是DataStream API。这就会造成用户在日常开发和优化中,经常要面临两套几乎完全独立的技术栈,很多事情可能需要重复的去做两遍。这样也会导致在一边的技术栈上做的优化,另外一边就享受不到。因此阿里巴巴在SQL层提出了全新的Quyer Processor,它主要包括一个流和批可以尽量做到复用的优化层(Query Optimizer)以及基于相同接口的算子层(Query Executor)。这样一来, 80%以上的工作可以做到两边复用,比如一些公共的优化规则,基础数据结构等等。同时,流和批也会各自保留自己一些独特的优化和算子,以满足不同的作业行为。 在SQL层的技术架构统一之后,阿里巴巴开始寻求一种更高效的基础数据结构,以便让Blink在SQL层的执行更加高效。在原生Flink SQL中,都统一使用了一种叫Row的数据结构,它完全由JAVA的一些对象构成关系数据库中的一行。假如现在的一行数据由一个整型,一个浮点型以及一个字符串组成,那么Row当中就会包含一个JAVA的Integer、Double和String。众所周知,这些JAVA的对象在堆内有不少的额外开销,同时在访问这些数据的过程中也会引入不必要的装箱拆箱操作。基于这些问题,阿里巴巴提出了一种全新的数据结构BinaryRow,它和原来的Row一样也是表示一个关系数据中的一行,但与之不同的是,它完全使用二进制数据来存储这些数据。在上述例子中,三个不同类型的字段统一由JAVA的byte[]来表示。这会带来诸多好处: 首先在存储空间上,去掉了很多无谓的额外消耗,使得对象的存储更为紧凑;其次在和网络或者状态存储打交道的时候,也可以省略掉很多不必要的序列化反序列化开销;最后在去掉各种不必要的装箱拆箱操作之后,整个执行代码对GC也更加友好。通过引入这样一个高效的基础数据结构,整个SQL层的执行效率得到了一倍以上的提升。 在算子的实现层面,阿里巴巴引入了更广范围的代码生成技术。得益于技术架构和基础数据结构的统一,很多代码生成技术得以达到更广范围的复用。同时由于SQL的强类型保证,用户可以预先知道算子需要处理的数据的类型,从而可以生成更有针对性更高效的执行代码。在原生Flink SQL中,只有类似a > 2或者c + d这样的简单表达式才会应用代码生成技术,在阿里巴巴优化之后,有一些算子会进行整体的代码生成,比如排序、聚合等。这使得用户可以更加灵活的去控制算子的逻辑,也可以直接将最终运行代码嵌入到类当中,去掉了昂贵的函数调用开销。一些应用代码生成技术的基础数据结构和算法,比如排序算法,基于二进制数据的HashMap等,也可以在流和批的算子之间进行共享和复用,让用户真正享受到了技术和架构的统一带来的好处。在针对批处理的某些场景进行数据结构或者算法的优化之后,流计算的性能也能够得到提升。接下来,我们聊聊阿里巴巴在Runtime层对Flink又大刀阔斧地进行了哪些改进。 二、Runtime层 为了让Flink在Alibaba的大规模生产环境中生根发芽,实时计算团队如期遇到了各种挑战,首当其冲的就是如何让Flink与其他集群管理系统进行整合。Flink原生集群管理模式尚未完善,也无法原生地使用其他其他相对成熟的集群管理系统。基于此,一系列棘手的问题接连浮现:多租户之间资源如何协调?如何动态的申请和释放资源?如何指定不同资源类型? 为了解决这个问题,实时计算团队经历大量的调研与分析,最终选择的方案是改造Flink资源调度系统,让Flink可以原生地跑在Yarn集群之上;并且重构Master架构,让一个Job对应一个Master,从此Master不再是集群瓶颈。以此为契机,阿里巴巴和社区联手推出了全新的Flip-6架构,让Flink资源管理变成可插拔的架构,为Flink的可持续发展打下了坚实的基础。如今Flink可以无缝运行在YARN、Mesos和K8s之上,正是这个架构重要性的有力说明。 解决了Flink集群大规模部署问题后,接下来的就是可靠和稳定性,为了保证Flink在生产环境中的高可用,阿里巴巴着重改善了Flink的FailOver机制。首先是Master的FailOver,Flink原生的Master FailOver会重启所有的Job,改善后Master任何FailOver都不会影响Job的正常运行;其次引入了Region-based的Task FailOver,尽量减少任何Task的FailOver对用户造成的影响。有了这些改进的保驾护航,阿里巴巴的大量业务方开始把实时计算迁移到Flink上运行。 Stateful Streaming是Flink的最大亮点,基于Chandy-Lamport算法的Checkpoint机制让Flink具备Exactly Once一致性的计算能力,但在早期Flink版本中Checkpoint的性能在大规模数据量下存在一定瓶颈,阿里巴巴也在Checkpoint上进行了大量改- 进,比如: 增量Checkpoint机制:阿里巴巴生产环境中遇到大JOB有几十TB State是常事,做一次全量CP地动山摇,成本很高,因此阿里巴巴研发了增量Checkpoint机制,从此之后CP从暴风骤雨变成了细水长流;Checkpoint小文件合并:都是规模惹的祸,随着整个集群Flink JOB越来越多,CP文件数也水涨船高,最后压的HDFS NameNode不堪重负,阿里巴巴通过把若干CP小文件合并成一个大文件的组织方式,最终把NameNode的压力减少了几十倍。 虽然说所有的数据可以放在State中,但由于一些历史的原因,用户依然有一些数据需要存放在像HBase等一些外部KV存储中,用户在Flink Job需要访问这些外部的数据,但是由于Flink一直都是单线程处理模型,导致访问外部数据的延迟成为整个系统的瓶颈,显然异步访问是解决这个问题的直接手段,但是让用户在UDF中写多线程同时还要保证ExactlyOnce语义,却并非易事。阿里巴巴在Flink中提出了AsyncOperator,让用户在Flink JOB中写异步调用和写“Hello Word”一样简单 ,这个让Flink Job的吞吐有了很大的飞跃。 Flink在设计上是一套批流统一的计算引擎,在使用过快如闪电的流计算之后,批用户也开始有兴趣入住Flink小区。但批计算也带来了新的挑战,首先在任务调度方面,阿里巴巴引入了更加灵活的调度机制,能够根据任务之间的依赖关系进行更加高效的调度;其次就是数据Shuffle,Flink原生的Shuffle Service和TM绑定,任务执行完之后要依旧保持TM无法释放资源;还有就是原有的Batch shuffle没有对文件进行合并,所以基本无法在生产中使用。阿里巴巴开发了Yarn Shuffle Service功能的同时解决了以上两个问题。在开发Yarn Shuffle Service的时候,阿里巴巴发现开发一套新的Shuffle Service非常不便,需要侵入Flink代码的很多地方,为了让其他开发者方便的扩展不同Shuffle,阿里巴巴同时改造了Flink Shuffle架构,让Flink的Shuffle变成可插拔的架构。目前阿里巴巴的搜索业务已经在使用Flink Batch Job,并且已经开始服务于生产。 经过3年多打磨,Blink已经在阿里巴巴开始茁壮生长,但是对Runtime的优化和改进是永无止境的,一大波改进和优化正在路上。

April 30, 2019 · 1 min · jiezi

Apache-Flink-SQL概览

(https://github.com/sunjincheng121/flink-study/blob/test/docs/sql/SQL.md) 作者: 孙金城,淘宝花名 金竹 本篇核心目标是让大家概要了解一个完整的Apache Flink SQL Job的组成部分,以及Apache Flink SQL所提供的核心算子的语义,最后会应用Tumble Window编写一个End-to-End的页面访问的统计示例。 Apache Flink SQL Job的组成我们做任何数据计算都离不开读取原始数据,计算逻辑和写入计算结果数据三部分,当然基于Apache Flink SQL编写的计算Job也离不开这个三部分,如下所所示: 如上所示,一个完整的Apache Flink SQL Job 由如下三部分: Source Operator - Soruce operator是对外部数据源的抽象, 目前Apache Flink内置了很多常用的数据源实现,比如上图提到的Kafka。Query Operators - 查询算子主要完成如图的Query Logic,目前支持了Union,Join,Projection,Difference, Intersection以及window等大多数传统数据库支持的操作。Sink Operator - Sink operator 是对外结果表的抽象,目前Apache Flink也内置了很多常用的结果表的抽象,比如上图提到的Kafka。Apache Flink SQL 核心算子SQL是Structured Quevy Language的缩写,最初是由美国计算机科学家Donald D. Chamberlin和Raymond F. Boyce在20世纪70年代早期从Early History of SQL中了解关系模型后在IBM开发的。该版本最初称为[SEQUEL: A Structured English Query Language](结构化英语查询语言),旨在操纵和检索存储在IBM原始准关系数据库管理系统System R中的数据。直到1986年,ANSI和ISO标准组正式采用了标准的"数据库语言SQL"语言定义。Apache Flink SQL 核心算子的语义设计也参考了1992、2011等ANSI-SQL标准。接下来我们将简单为大家介绍Apache Flink SQL 每一个算子的语义。 SELECTSELECT 用于从数据集/流中选择数据,语法遵循ANSI-SQL标准,语义是关系代数中的投影(Projection),对关系进行垂直分割,消去某些列。 ...

April 30, 2019 · 3 min · jiezi

流计算框架-Flink-与-Storm-的性能对比

(备注:原文链接https://mp.weixin.qq.com/s/b8...) 作者:孙梦瑶 概述: 将分布式实时计算框架 Flink 与 Storm 进行性能对比,为实时计算平台和业务提供数据参考。 1. 背景Apache Flink 和 Apache Storm 是当前业界广泛使用的两个分布式实时计算框架。其中 Apache Storm(以下简称“Storm”)在美团点评实时计算业务中已有较为成熟的运用(可参考 Storm 的可靠性保证测试),有管理平台、常用 API 和相应的文档,大量实时作业基于 Storm 构建。而 Apache Flink(以下简称“Flink”)在近期倍受关注,具有高吞吐、低延迟、高可靠和精确计算等特性,对事件窗口有很好的支持,目前在美团点评实时计算业务中也已有一定应用。 为深入熟悉了解 Flink 框架,验证其稳定性和可靠性,评估其实时处理性能,识别该体系中的缺点,找到其性能瓶颈并进行优化,给用户提供最适合的实时计算引擎,我们以实践经验丰富的 Storm 框架作为对照,进行了一系列实验测试 Flink 框架的性能,计算 Flink 作为确保“至少一次”和“恰好一次”语义的实时计算框架时对资源的消耗,为实时计算平台资源规划、框架选择、性能调优等决策及 Flink 平台的建设提出建议并提供数据支持,为后续的 SLA 建设提供一定参考。 Flink 与 Storm 两个框架对比: StormFlink状态管理无状态,需用户自行进行状态管理有状态窗口支持对事件窗口支持较弱,缓存整个窗口的所有数据,窗口结束时一起计算窗口支持较为完善,自带一些窗口聚合方法,并且会自动管理窗口状态。消息投递At Most Once At Least OnceAt Most Once At Least OnceExactly Once容错方式ACK机制 :对每个消息进行全链路跟踪,失败或超时进行重发。检查点机制 :通过分布式一致性快照机制,对数据流和算子状态进行保存。在发生错误时,使系统能够进行回滚。应用现状在美团点评实时计算业务中已有较为成熟的运用,有管理平台、常用 API 和相应的文档,大量实时作业基于 Storm 构建。在美团点评实时计算业务中已有一定应用,但是管理平台、API 及文档等仍需进一步完善。<br/> 2. 测试目标评估不同场景、不同数据压力下 Flink 和 Storm 两个实时计算框架目前的性能表现,获取其详细性能数据并找到处理性能的极限;了解不同配置对 Flink 性能影响的程度,分析各种配置的适用场景,从而得出调优建议。 ...

April 29, 2019 · 5 min · jiezi

一文了解-Apache-Flink-核心技术

作者:伍翀Apache Flink 介绍Apache Flink (以下简称Flink)是近年来越来越流行的一款开源大数据计算引擎,它同时支持了批处理和流处理,也能用来做一些基于事件的应用。使用官网的语句来介绍 Flink 就是 "Stateful Computations Over Streams"。 首先 Flink 是一个纯流式的计算引擎,它的基本数据模型是数据流。流可以是无边界的无限流,即一般意义上的流处理。也可以是有边界的有限流,这样就是批处理。因此 Flink 用一套架构同时支持了流处理和批处理。其次,Flink 的一个优势是支持有状态的计算。如果处理一个事件(或一条数据)的结果只跟事件本身的内容有关,称为无状态处理;反之结果还和之前处理过的事件有关,称为有状态处理。稍微复杂一点的数据处理,比如说基本的聚合,数据流之间的关联都是有状态处理。 Apache Flink 基石Apache Flink 之所以能越来越受欢迎,我们认为离不开它最重要的四个基石:Checkpoint、State、Time、Window。 首先是Checkpoint机制,这是 Flink 最重要的一个特性。Flink 基于 Chandy-Lamport 算法实现了分布式一致性的快照,从而提供了 exactly-once 的语义。在 Flink 之前的流计算系统(如 Strom,Samza)都没有很好地解决 exactly-once 的问题。提供了一致性的语义之后,Flink 为了让用户在编程时能够更轻松、更容易地去管理状态,引入了托管状态(managed state)并提供了 API 接口,让用户使用起来感觉就像在用 Java 的集合类一样。除此之外,Flink 还实现了 watermark 的机制,解决了基于事件时间处理时的数据乱序和数据迟到的问题。最后,流计算中的计算一般都会基于窗口来计算,所以 Flink 提供了一套开箱即用的窗口操作,包括滚动窗口、滑动窗口、会话窗口,还支持非常灵活的自定义窗口以满足特殊业务的需求。 Flink API 历史变迁 在 Flink 1.0.0 时期,加入了 State API,即 ValueState、ReducingState、ListState 等等。State API 可以认为是 Flink 里程碑式的创新,它能够让用户像使用 Java 集合一样地使用 Flink State,却能够自动享受到状态的一致性保证,不会因为故障而丢失状态。包括后来 Apache Beam 的 State API 也从中借鉴了很多。 ...

April 29, 2019 · 2 min · jiezi

flink

官方:https://flink.apache.org 逻辑架构 部署架构基于yarn的部署 HA:job manager单点Standalone : Zookeeper对于 Yarn Cluaster 模式来说,Flink 就要依靠 Yarn 本身来对 JobManager 做 HA 了。其实这里完全是 Yarn 的机制。对于 Yarn Cluster 模式来说,JobManager 和 TaskManager 都是被 Yarn 启动在 Yarn 的 Container 中。此时的 JobManager,其实应该称之为 Flink Application Master。也就说它的故障恢复,就完全依靠着 Yarn 中的 ResourceManager(和 MapReduce 的 AppMaster 一样)。 运行架构client: 当用户提交一个Flink程序时,会首先创建一个Client,该Client首先会对用户提交的Flink程序进行预处理,并提交到Flink集群中处理,所以Client需要从用户提交的Flink程序配置中获取JobManager的地址,并建立到JobManager的连接,将Flink Job提交给JobManager。Flink程序=》JobGraph(Flink Dataflow:多个JobVertex组成的DAG,一个JobGraph包含了一个Flink程序的如下信息:JobID、Job名称、配置信息、一组JobVertex等)。jobmanager:它负责接收Flink Job,调度组成Job的多个Task的执行。同时,JobManager还负责收集Job的状态信息,并管理Flink集群中从节点TaskManager。JobManager所负责的各项管理功能,它接收到并处理的事件主要包括:RegisterTaskManager,SubmitJob,CancelJob,UpdateTaskExecutionState,RequestNextInputSplit,JobStatusChangedworker JVM进程多线程,task slot内存隔离资源单位,一个job的的多讴歌subtask可以共享slot, 计算模式在 Hadoop 中 Map 和 Reduce 是两个独立调度的 Task,并且都会去占用计算资源。对 Flink 来说 MapReduce 是一个 Pipeline 的 Task,只占用一个计算资源 https://ci.apache.org/project...以上有4个源4个map3个reduce。在2个TM(每个3个slots)的并行执行方式如下其中每个可并行的有一个JV和并行和EV.比如source会在一个JV中保含4个EV,ExecutionGraph还包含IntermediateResult和IntermediateResultPartition。前者跟踪IntermediateDataSet的状态,后者是每个分区的状态。 ...

April 29, 2019 · 1 min · jiezi

下比拼生态和未来Spark和Flink哪家强

前文对 Spark 和 Flink 的引擎做了对比。对用户来说引擎并不是考虑数据产品的唯一方面。开发和运维相关的工具和环境,技术支持,社区等等,对能不能在引擎上面做出东西来都很重要。这些构成了一个产品的生态。可以说引擎决定了功能和性能的极限,而生态能让这些能力真正发挥出作用。概 况 Spark 是最活跃的 Apache 项目之一。从 2014 年左右开始得到广泛关注。Spark 的开源社区一度达到上千的活跃贡献者。最主要推动者是 Databricks,由最初的 Spark 创造者们成立的公司。今年 6 月的 Spark+AI 峰会参加人数超过 4000。 Spark 因为在引擎方面比 MapReduce 全面占优,经过几年发展和 Hadoop 生态结合较好,已经被广泛视为 Hadoop MapReduce 引擎的取代者。 Flink 也是 Apache 顶级项目,创始者们成立了 Data Artisans。社区规模还无法和 Spark 相比。不过在业界,特别是流处理方面,有不错的口碑。在大规模流处理方面走在最前沿,也是需求最强的几个美国公司,包括 Netflix、 LinkedIn、Uber、Lyft 等,除 LinkedIn 有自己的 Samza 外,都已经采用 Flink 作为流处理引擎或者有了较大投入。 阿里集团在 Flink 社区也有较大影响力。最近 Flink 1.3 到 1.5 里都有几个重磅功能是阿里和 Data Artisans 合作或者独立开发的。阿里还有可能是世界上最大的流计算集群,也是在 Flink 的基础上开发的。 Unified Analytic platform最近的 Spark+AI 峰会上, Databricks 主打的主题是统一分析平台(Unified Analytics Platform)。三大新发布:Databricks delta、Databricks Runtime for ML和 ML flow,都是围绕这一主题。随着近年来机器学习(包括深度学习)在数据处理中占比越来越高,可以说 Databricks 又一次把握住了时代的脉搏。 ...

April 28, 2019 · 2 min · jiezi

阿里巴巴果然开始拥有预测未来的能力了

文 | 史中 顶灯闪烁,笛声响彻。 救护车载着病人,冲向茫茫车海,在时间的赛道上狂奔。 高德地图、GPS 卫星导航、路面磁感线圈、1300 个路口摄像头同时开动,为这辆救护车勘探最快路线; GPS 传回实时数据,后台根据辅助数据纠偏,锚定救护车每一刻的精确位置; 救护车将要经过的沿途,车辆情况被实时计算。确保路口绿灯提前亮起,在救护车通过之前,刚好所有社会车辆已经行驶一空。 这不是演习,这是杭州城市大脑每天都在执行的任务。依靠计算,一辆救护车到达医院的速度,平均缩短了 50%。在这座城市,靠鸣笛和闯红灯开道的悲壮彻底成为历史。 说人同蝼蚁,其实并不为过。两百多万辆车奔跑在城市里,他们的行踪像风里的落叶一样叵测。但通过对 1300个路口的摄像头的实时计算,城市大脑就可以精确地预测出未来十五分钟、未来半小时那哪个路段将会拥堵,从而第一时间指挥路口信号灯“变换姿势”。 计算在帮人类追赶时间。 中哥今天要说的,就是这个精致而坚固的“大数据实时计算引擎"。 你可能从未听说过这个引擎,甚至在此刻之前都不知道它的存在,但你很可能早已成为这个引擎服务的一员: 一年一度的双11,无数人涌进天猫,每个人都能用 0.1 秒搜索到自己理想的商品,在智能推荐中发现适合的宝贝,背后正是依赖这个引擎; 双11庆典现场,大屏上那个跳动的总成交量数字,只是背后所有数据的冰山一角。几十亿种商品的实时库存、价格、优惠数据得以分秒不慢地同步给屏幕前的你,也同样依赖这个引擎。 从某种意义上来说,只要给这个计算引擎足够的资源,无论面对多么庞大复杂的系统,我们都可以用几乎忽略不计的时间看到真相——这大大快于人类最聪明的大脑。 这是我们亲手创造的“先知“ 重器难成。为了这个先知一般的“大数据实时计算引擎”,阿里巴巴最核心的技术人,已经耗费了将近五年时间。 让人感慨的是,这个承载了一个个城市的交通,扛起了一条条生产线,担负了一个国家十几亿人购物的强大引擎之所以的诞生在阿里巴巴,最初并不是为了满足什么需要,而仅仅是因为它“看上去很美”。 这是一个鲜为人知的故事。 (1) 1999年,阿里巴巴在杭州成立。 同样在1999年,蒋晓伟正在美国攻读理论物理博士。作为一个初三就立志要探索宇宙秘密的年轻人,到目前为止他的人生堪称完美。 就在一个崭新的物理学家即将出炉的时候,命运开始展现它的波云诡谲。蒋晓伟突然被自己的导师“忽悠”到了一家非常有希望的互联网初创公司。理由是:“在30岁之前先财富自由,以后爱怎么学物理就怎么学物理。” 一年之后,互联网泡沫破裂。然而,蒋晓伟却留在了这片战场。2002年,他加入微软,2010年他加入 Facebook。弹指挥间,直到回国加入阿里巴巴之前,他已经从物理学家成功转型成为数据库和计算资源调度系统专家。 他还记得,自己加入阿里的时间是 2014年12月29日。这是一年中可以办理入职的最后一天。 “为什么选最后一天?” “因为看上去比较有美感。” “。。。” 目测,蒋晓伟是我见过的第一个用物理公式般的美感对待人生的人。甚至,他给自己的花名都想叫做“量子”,后来思考了一下,觉得量子不太像个人名,才改为谐音“量仔”。 蒋晓伟 蒋晓伟入职的是阿里巴巴集团搜索团队。你可能会问:纳尼?阿里巴巴还有搜索团队?当然有,而且还极其重要。举个搜索引擎的日常: 当你在淘宝搜索框里输入“杜蕾斯”的时候,搜索引擎就马上行动,从亿万卖家出售中的宝贝里帮你找到合适的 TT(及其他产品),然后按照推荐顺序排列在搜索结果里。 注意,有趣的硬核要来了: 如果,商家的 TT 价格永远不改,库存永远无限,优惠促销方案永远不变,那么搜索团队只需要做一个最简单的查询系统就行了。 但是,现实中商家会随时调整价格和优惠,某一款激情大颗粒也可能因为太受欢迎,上架十秒就卖到缺货。在淘宝网上,你会发现真实的状态是:每时每刻都有无数卖家的产品参数在改动。 所以,搜索引擎的挑战就是,要根据每时每刻最新的数据库来瞬间算出最适合呈现给你的搜索结果。 相信我,只有用最新鲜的数据算出的结果,才能让屏幕对面的你露出心满意足的表情: 面对这种现实,一个最稳妥的方式就是,搜索引擎用把现在的数据库全部算一遍,给出结果。 但是,这会耗费大量的计算力。毕竟这一秒相对于上一秒来说,可能发生参数变动的宝贝只有十个,而没有参数变动的宝贝有十万个。 那么,你自然会想:“有没有一种方法,让我只计算改动的部分,再通过特别的数学运算和之前的结果融合,就能达到和计算全量数据一样的效果呢?” 有的,这就叫"流式计算"。 打个最简单的比方: 你负责把椰汁平分给10个妹纸。刚开始你有10瓶椰汁,于是你一人分了一个。后来,你又得到了10瓶椰汁,这时候椰汁的总数变成了 20 瓶,平均每个妹纸应该得到两个。 但你没有必要把之前分给妹纸的椰汁收回来,重新每人给两个;而是可以让每个妹纸手上拿着之前的那瓶椰汁的基础上,每人再补发一瓶。 通过这个例子,我猜你已经感受到了“流式计算”的激荡。当然,实际的数据库运算比“分椰汁”复杂得多。 ...

April 28, 2019 · 2 min · jiezi

上Spark-VS-Flink-–-下一代大数据计算引擎之争谁主沉浮

作者简介王海涛,曾经在微软的 SQL Server和大数据平台组工作多年。带领团队建立了微软对内的 Spark 服务,主打 Spark Streaming。去年加入阿里实时计算部门,参与改进阿里基于 Apache Flink 的Blink 平台。 导读: 做大数据绝对躲不过的一个热门话题就是实时流计算,而提到实时流计算,就不得不提 Spark 和 Flink。Spark 从 2014 年左右开始迅速流行,刚推出时除了在某些场景比 Hadoop MapReduce 带来几十到上百倍的性能提升外,还提出了用一个统一的引擎支持批处理、流处理、交互式查询、机器学习等常见的数据处理场景。凭借高性能和全面的场景支持,Spark 早已成为众多大数据开发者的最爱。正在 Spark 如日中天高速发展的时候,2016 年左右 Flink 开始进入大众的视野并逐渐广为人知。在人们开始使用 Spark 之后,发现 Spark 虽然支持各种常见场景,但并不是每一种都同样好用。数据流的实时处理就是其中相对较弱的一环。Flink 凭借更优的流处理引擎,同时也支持各种处理场景,成为 Spark 的有力挑战者。当然,Spark 也在不断增强其实时流处理能力,在今年 2 月份发布的 2.3 版本中引入了持续流式处理模型,可将流处理延迟降低至毫秒级别。 本文对 Spark 和 Flink 的技术与场景进行了全面分析与对比,且看下一代大数据计算引擎之争,谁主沉浮? 下一代大数据计算引擎自从数据处理需求超过了传统数据库能有效处理的数据量之后,Hadoop 等各种基于 MapReduce 的海量数据处理系统应运而生。从2004 年 Google 发表 MapReduce 论文开始,经过近10年的发展,基于 Hadoop 开源生态或者其它相应系统的海量数据处理已经成为业界的基本需求。 但是,很多机构在开发自己的数据处理系统时都会发现需要面临一系列的问题。从数据中获取价值需要的投入远远超过预期。常见的问题包括: 非常陡峭的学习曲线。刚接触这个领域的人经常会被需要学习的技术的数量砸晕。不像经过几十年发展的数据库一个系统可以解决大部分数据处理需求, Hadoop 等大数据生态里的一个系统往往在一些数据处理场景上比较擅长,另一些场景凑合能用,还有一些场景完全无法满足需求。结果就是需要好几个系统来处理不同的场景。 (来源:https://mapr.com/developercen...) 上图是一个典型的lambda架构,只是包含了批处理和流处理两种场景,就已经牵涉到至少四五种技术了,还不算每种技术的可替代选择。再加上实时查询,交互式分析,机器学习等场景,每个场景都有几种技术可以选择,每个技术涵盖的领域还有不同方式的重叠。结果就是一个业务经常需要使用四五种以上的技术才能支持好一个完整的数据处理流程。加上调研选型,需要了解的数目还要多得多。 下图是大数据领域的全景。有没有晕? 大数据和 AI 全景 – 2018 (来源:http://mattturck.com/bigdata2...) ...

April 28, 2019 · 2 min · jiezi

携程基于Flink的实时特征平台

作者:刘康 本文来自7月26日在上海举行的 Flink Meetup 会议,分享来自于刘康,目前在大数据平台部从事模型生命周期相关平台开发,现在主要负责基于flink开发实时模型特征计算平台。熟悉分布式计算,在模型部署及运维方面有丰富实战经验和深入的理解,对模型的算法及训练有一定的了解。本文主要内容如下: 在公司实时特征开发的现状基础上,说明实时特征平台的开发背景、目标以及现状选择Flink作为平台计算引擎的原因Flink的实践:有代表性的使用示例、为兼容Aerospike(平台的存储介质)的开发以及碰到的坑当前效果&未来规划一、在公司实时特征开发的现状基础上,说明实时特征平台的开发背景、目标以及现状1、原实时特征作业的开发运维;1.1、选择实时计算平台:依据项目的性能指标要求(latency,throughput等),在已有的实时计算平台:Storm Spark flink进行选择 1.2主要的开发运维过程: 80%以上的作业需要用到消息队列数据源,但是消息队列为非结构化数据且没有统一的数据字典。所以需要通过消费对应的topic,解析消息并确定所需的内容基于需求中的场景,设计开发计算逻辑在实时数据不能完全满足数据需求的情况,另外开发单独的离线作业以及融合逻辑;例如:在需要30天数据的场景下,但消息队列中只有七天内的数据时(kafka中消息的默认保留时间),剩下23天就需要用离线数据来补充。 设计开发数据的校验和纠错逻辑消息的传输需要依赖网络,消息丢失和超时难以完全避免,所以需要有一个校验和纠错的逻辑。 测试上线监控和预警2、原实时特征作业的开发痛点消息队列数据源结构没有统一的数据字典特征计算逻辑高度定制化,开发测试周期长实时数据不能满足需求时,需要定制离线作业和融合逻辑校验和纠错方案没有形成最佳实践,实际效果比较依赖个人能力监控和预警方案需要基于业务逻辑定制3、基于整理的痛点,确定下来的平台目标实时数据字典:提供统一的数据源注册、管理功能,支持单一结构消息的topic和包含多种不同结构消息的topic逻辑抽象:抽象为SQL,减少工作量&降低使用门槛特征融合:提供融合特征的功能,解决实时特征不能完全满足数据需求的情况数据校验和纠错:提供利用离线数据校验和纠错实时特征的功能实时计算延迟:ms级实时计算容错:端到端 exactly-once统一的监控预警和HA方案4、特征平台系统架构 现在的架构是标准lamda架构,离线部分由spark sql + dataX组成。现在使用的是KV存储系统Aerospike,跟redis的主要区别是使用SSD作为主存,我们压测下来大部分场景读写性能跟redis在同一个数据量级。 实时部分:使用flink作为计算引擎,介绍一下用户的使用方式: 注册数据源:目前支持的实时数据源主要是Kafka和Aerospike,其中Aerospike中的数据如果是在平台上配置的离线或者实时特征,会进行自动注册。Kafka数据源需要上传对应的schemaSample文件计算逻辑:通过SQL表达定义输出:定义输出的Aerospike表和可能需要的Kafka Topic,用于推送Update或者Insert的数据的key用户完成上面的操作后,平台将所有信息写入到json配置文件。下一步平台将配置文件和之前准备好的flinkTemplate.jar(包含所有平台所需的flink功能)提交给yarn,启动flink job。 5、平台功能展示1)平台功能展示-数据源注册 2)实时特征编辑-基本信息 3)实时特征编辑-数据源选择 4)实时特征编辑-SQL计算 5)实时特征编辑-选择输出 二、选择Flink的原因我们下面一个我们说一下我们选择flink来做这个特征平台的原因。 分为三个维度:最高延迟、容错、sql功能成熟度 延迟:storm和flink是纯流式,最低可以达到毫秒级的延迟。spark的纯流式机制是continuous模式,也可以达最低毫秒级的延迟容错:storm使用异或ack的模式,支持atLeastOnce。消息重复解决不。spark通过checkpoint和WAL来提供exactlyOnce。flink通过checkpoint和SavePoint来做到exactlyOnce。sql成熟度:storm现在的版本中SQL还在一个实验阶段,不支持聚合和join。spark现在可以提供绝大部分功能,不支持distinct、limit和聚合结果的order by。flink现在社区版中提供的sql,不支持distinct aggregate 三、Flink实践1、实⽤示例 2、兼容开发:flink现在没有对Aerospike提供读写支持,所以需要二次开发 3、碰到的坑 四、平台当前效果&未来规划当前效果:将实时特征上线周期从原平均3天-5天降至小时级。未来规划: 完善特征平台的功能:融合特征等简化步骤,提高用户体验根据需求,进一步完善SQL的功能例如支持win的开始时间offset,可以通过countTrigger的win等下一步的规划是通过sql或者DSL来描述模型部署和模型训练

April 26, 2019 · 1 min · jiezi

Flink在美团的实践与应用

作者: 刘迪珊 本文整理自8月11日在北京举行的Flink Meetup,分享嘉宾刘迪珊(2015年加入美团数据平台。致力于打造高效、易用的实时计算平台,探索不同场景下实时应用的企业级解决方案及统⼀化服务)。 美团实时计算平台现状和背景实时平台架构 上图呈现的是当前美团实时计算平台的简要架构。最底层是数据缓存层,可以看到美团测的所有日志类的数据,都是通过统一的日志收集系统收集到Kafka。Kafka作为最大的数据中转层,支撑了美团线上的大量业务,包括离线拉取,以及部分实时处理业务等。在数据缓存层之上,是一个引擎层,这一层的左侧是我们目前提供的实时计算引擎,包括Storm和Flink。Storm在此之前是 standalone 模式的部署方式,Flink由于其现在运行的环境,美团选择的是On YARN模式,除了计算引擎之外,我们还提供一些实时存储功能,用于存储计算的中间状态、计算的结果、以及维度数据等,目前这一类存储包含Hbase、Redis以及ES。在计算引擎之上,是趋于五花八门的一层,这一层主要面向数据开发的同学。实时数据开发面临诸多问题,例如在程序的调试调优方面就要比普通的程序开发困难很多。在数据平台这一层,美团面向用户提供的实时计算平台,不仅可以托管作业,还可以实现调优诊断以及监控报警,此外还有实时数据的检索以及权限管理等功能。除了提供面向数据开发同学的实时计算平台,美团现在正在做的事情还包括构建元数据中心。这也是未来我们想做SQL的一个前提,元数据中心是承载实时流系统的一个重要环节,我们可以把它理解为实时系统中的大脑,它可以存储数据的Schema,Meta。架构的最顶层就是我们现在实时计算平台支撑的业务,不仅包含线上业务日志的实时查询和检索,还涵盖当下十分热门的实时机器学习。机器学习经常会涉及到搜索和推荐场景,这两个场景最显著特点:一、会产生海量实时数据;二、流量的QPS相当高。此时就需要实时计算平台承载部分实时特征的提取工作,实现应用的搜索推荐服务。还有一类是比较常见的场景,包括实时的特征聚合,斑马Watcher(可以认为是一个监控类的服务),实时数仓等。 以上就是美团目前实时计算平台的简要架构。 实时平台现状美团实时计算平台的现状是作业量现在已经达到了近万,集群的节点的规模是千级别的,天级消息量已经达到了万亿级,高峰期的消息量能够达到千万条每秒。 痛点和问题美团在调研使用Flink之前遇到了一些痛点和问题: 实时计算精确性问题:在调研使用Flink之前美团很大规模的作业是基于Storm去开发的,Storm主要的计算语义是At-Least-Once,这种语义在保证正确性上实际上是有一些问题的,在Trident之前Storm是无状态的处理。虽然Storm Trident提供了一个维护状态的精确的开发,但是它是基于串行的Batch提交的,那么遇到问题在处理性能上可能会有一点瓶颈。并且Trident是基于微批的处理,在延迟上没有达到比较高的要求,所以不能满足一些对延迟比较高需求的业务。流处理中的状态管理问题:基于之前的流处理过程中状态管理的问题是非常大的一类问题。状态管理除了会影响到比如说计算状态的一致性,还会影响到实时计算处理的性能以及故障恢复时候的能力。而Flink最突出的一个优势就是状态管理。实时计算表义能力的局限性:在实时计算之前很多公司大部分的数据开发还是面向离线的场景,近几年实时的场景也慢慢火热起来了。那与离线的处理不同的是,实时的场景下,数据处理的表意能力可能有一定的限制,比如说他要进行精确计算以及时间窗口都是需要在此之上去开发很多功能性的东西。开发调试成本高:近千结点的集群上已经跑了近万的作业,分布式的处理的引擎,手工写代码的方式,给数据开发的同学也带来了很高开发和调试的成本,再去维护的时候,运维成本也比较高。Flink探索关注点在上面这些痛点和问题的背景下,美团从去年开始进行Flink的探索,关注点主要有以下4个方面: ExactlyOnce计算能力状态管理能力窗口/Join/时间处理等等SQL/TableAPIFlink在美团的实践下面带大家来看一下,美团从去年投入生产过程中都遇到了哪些问题,以及一些解决方案,分为下面三个部分: 稳定性实践稳定性实践-资源隔离1.资源隔离的考虑:分场景、按业务 高峰期不同,运维时间不同;可靠性、延迟需求不同;应用场景,重要性不同;2.资源隔离的策略: YARN打标签,节点物理隔离;离线DataNode与实时计算节点的隔离; 稳定性实践-智能调度 智能调度目的也是为了解决资源不均的问题,现在普通的调度策略就是基于CPU,基于内存去调度的。除此之外,在生产过程中也发现了一些其他的问题,比如说Flink是会依赖本地磁盘,进行依赖本地磁盘做本地的状态的存储,所以磁盘IO,还有磁盘的容量,也是一类考虑的问题点,除此之外还包括网卡流量,因为每个业务的流量的状态是不一样的,分配进来会导致流量的高峰,把某一个网卡打满,从而影响其他业务,所以期望的话是说做一些智能调度化的事情。目前暂时能做到的是从cpu和内存两方面,未来会从其他方面做一些更优的调度策略。 稳定性实践-故障容错1.节点/网络故障 JobManagerHA自动拉起与Storm不同的是,知道Storm在遇到异常的时候是非常简单粗暴的,比如说有发生了异常,可能用户没有在代码中进行比较规范的异常处理,但是没有关系,因为worker会重启作业还会继续执行,并且他保证的是At-Least-Once这样的语义,比如说一个网络超时的异常对他而言影响可能并没有那么大,但是Flink不同的是他对异常的容忍度是非常的苛刻的,那时候就考虑的是比如说会发生节点或者是网络的故障,那JobManager单点问题可能就是一个瓶颈,JobManager那个如果挂掉的话,那么可能对整个作业的影响就是不可回复的,所以考虑了做HA,另外一个就是会去考虑一些由于运维的因素而导致的那作业,还有除此之外,可能有一些用户作业是没有开启CheckPoint,但如果是因为节点或者是网络故障导致挂掉,希望会在平台内层做一些自动拉起的策略,去保证作业运行的稳定性。 2.上下游容错 FlinkKafka08异常重试我们的数据源主要是Kafka,读写Kafka是一类非常常见的实时流处理避不开的一个内容,而Kafka本身的集群规模是非常比较大的,因此节点的故障出现是一个常态问题,在此基础上我们对节点故障进行了一些容错,比如说节点挂掉或者是数据均衡的时候,Leader会切换,那本身Flink的读写对Leader的切换容忍度没有那么高,在此基础上我们对一些特定场景的,以及一些特有的异常做的一些优化,进行了一些重试。 3.容灾 多机房流热备容灾可能大家对考虑的并不多,比如说有没有可能一个机房的所有的节点都挂掉了,或者是无法访问了,虽然它是一个小概率的事件,但它也是会发生的。所以现在也会考虑做多机房的一些部署,包括还有Kafka的一些热备。 Flink平台化Flink平台化-作业管理在实践过程中,为了解决作业管理的一些问题,减少用户开发的一些成本,我们做了一些平台化的工作,下图是一个作业提交的界面展示,包括作业的配置,作业生命周期的管理,报警的一些配置,延迟的展示,都是集成在实时计算平台的。 Flink平台化-监控报警在监控上我们也做了一些事情,对于实时作业来讲,对监控的要求会更高,比如说在作业延迟的时候对业务的影响也比较大,所以做了一些延迟的报警,包括作业状态的报警,比如说作业存活的状态,以及作业运行的状态,还有未来会做一些自定义Metrics的报警。自定义Metrics是未来会考虑基于作业处理本身的内容性,做一些可配置化的一些报警。 Flink平台化-调优诊断实时计算引擎提供统一日志和Metrics方案为业务提供按条件过滤的日志检索为业务提供自定义时间跨度的指标查询基于日志和指标,为业务提供可配置的报警另外就是刚刚提到说在开发实时作业的时候,调优和诊断是一个比较难的痛点,就是用户不是很难去查看分布式的日志,所以也提供了一套统一的解决方案。这套解决方案主要是针对日志和Metrics,会在针对引擎那一层做一些日志和Metrics的上报,那么它会通过统一的日志收集系统,将这些原始的日志,还有Metrics汇集到Kafka那一层。今后Kafka这一层大家可以发现它有两个下游,一方面是做日志到ES的数据同步,目的的话是说能够进入日志中心去做一些日志的检索,另外一方面是通过一些聚合处理流转到写入到OpenTSDB把数据做依赖,这份聚合后的数据会做一些查询,一方面是Metrics的查询展示,另外一方面就是包括实做的一些相关的报警。 下图是当前某一个作业的一个可支持跨天维度的Metrics的一个查询的页面。可以看到说如果是能够通过纵向的对比,可以发现除了作业在某一个时间点是因为什么情况导致的?比如说延迟啊这样容易帮用户判断一些他的做作业的一些问题。除了作业的运行状态之外,也会先就是采集一些节点的基本信息作为横向的对比 下图是当前的日志的一些查询,它记录了,因为作业在挂掉之后,每一个ApplicationID可能会变化,那么基于作业唯一的唯一的主键作业名去搜集了所有的作业,从创建之初到当前运行的日志,那么可以允许用户的跨Application的日志查询。 生态建设为了适配这两类MQ做了不同的事情,对于线上的MQ,期望去做一次同步多次消费,目的是避免对线上的业务造成影响,对于的生产类的Kafka就是线下的Kafka,做了一些地址的地址的屏蔽,还有基础基础的一些配置,包括一些权限的管理,还有指标的采集。 Flink在美团的应用下面会给大家讲两个Flink在美团的真实使用的案例。第一个是Petra,Petra其实是一个实时指标的一个聚合的系统,它其实是面向公司的一个统一化的解决方案。它主要面向的业务场景就是基于业务的时间去统计,还有计算一些实时的指标,要求的话是低时延,他还有一个就是说,因为它是面向的是通用的业务,由于业务可能是各自会有各自不同的维度,每一个业务可能包含了包括应用通道机房,还有其他的各自应用各个业务特有的一些维度,而且这些维度可能涉及到比较多,另外一个就是说它可能是就是业务需要去做一些复合的指标的计算,比如说最常见的交易成功率,他可能需要去计算支付的成功数,还有和下单数的比例。另外一个就是说统一化的指标聚合可能面向的还是一个系统,比如说是一些B端或者是R段的一些监控类的系统,那么系统对于指标系统的诉求,就是说我希望指标聚合能够最真最实时最精确的能够产生一些结果,数据保证说它的下游系统能够真实的监控到当前的信息。右边图是我当一个Metrics展示的一个事例。可以看到其他其实跟刚刚讲也是比较类似的,就是说包含了业务的不同维度的一些指标汇聚的结果。 Petra实时指标聚合1.业务场景: 基于业务时间(事件时间)多业务维度:如应用、通道、机房等复合指标计算:如交易成功率=支付成功数/下单数低延迟:秒级结果输出 2.Exactlyonce的精确性保障 Flinkcheckpoint机制3.维度计算中数据倾斜 热点key散列4.对晚到数据的容忍能力 窗口的设置与资源的权衡 在用Flink去做实时指标复核的系统的时候,着重从这几方面去考虑了。第一个方面是说精确的计算,包括使用了FLink和CheckPoint的机制去保证说我能做到不丢不重的计算,第一个首先是由统一化的Metrics流入到一个预聚合的模块,预聚合的模块主要去做一些初始化的一些聚合,其中的为什么会分预聚合和全量聚合主要的解决一类问题,包括就刚刚那位同学问的一个问题,就是数据倾斜的问题,比如说在热点K发生的时候,当前的解决方案也是通过预聚合的方式去做一些缓冲,让尽量把K去打散,再聚合全量聚合模块去做汇聚。那其实也是只能解决一部分问题,所以后面也考虑说在性能的优化上包括去探索状态存储的性能。下面的话还是包含晚到数据的容忍能力,因为指标汇聚可能刚刚也提到说要包含一些复合的指标,那么符合的指标所依赖的数据可能来自于不同的流,即便来自于同一个流,可能每一个数据上报的时候,可能也会有晚到的情况发生,那时候需要去对数据关联做晚到的容忍,容忍的一方面是说可以设置晚到的Lateness的延迟,另一方面是可以设置窗口的长度,但是其实在现实的应用场景上,其实还有一方面考虑就是说除了去尽量的去拉长时间,还要考虑真正的计算成本,所以在这方面也做了一些权衡,那么指标基本就是经过全量聚合之后,聚合结果会回写Kafka,经过数据同步的模块写到OpenTSDB去做,最后去grafana那做指标的展示,另一方面可能去应用到通过Facebook包同步的模块去同步到报警的系统里面去做一些指标,基于指标的报警。 下图是现在提供的产品化的Petra的一个展示的机示意图,可以看到目前的话就是定义了某一些常用的算子,以及维度的配置,允许用户进行配置话的处理,直接去能够获取到他期望要的指标的一个展示和汇聚的结果。目前还在探索说为Petra基于Sql做一些事情,因为很多用户也比较就是在就是习惯上也可以倾向于说我要去写Sql去完成这样的统计,所以也会基于此说依赖Flink的本身的对SQl还有TableAPI的支持,也会在Sql的场景上进行一些探索。 MLX机器学习平台第二类应用就是机器学习的一个场景,机器学习的场景可能会依赖离线的特征数据以及实时的特征数据。一个是基于现有的离线场景下的特征提取,经过了批处理,流转到了离线的集群。另外一个就是近线模式,近线模式出的数据就是现有的从日志收集系统流转过来的统一的日志,经过Flink的处理,就是包括流的关联以及特征的提取,再做模型的训练,流转到最终的训练的集群,训练的集群会产出P的特征,还有都是Delta的特征,最终将这些特征影响到线上的线上的特征的一个训练的一个服务上。这是一个比较常见的,比如说比较就是通用的也是比较通用的一个场景,目前的话主要应用的方可能包含了搜索还有推荐,以及一些其他的业务。 未来展望未来的话可能也是通过也是期望在这三方面进行做一些更多的事情,刚刚也提到了包括状态的管理,第一个是状态的统一的,比如说Sql化的统一的管理,希望有统一的配置,帮用户去选择一些期望的回滚点。另外一个就是大状态的性能优化,因为比如说像做一些流量数据的双流的关联的时候,现在也遇到了一些性能瓶颈的问题,对于说啊基于内存型的状态,基于内存型的数据的处理,以及基于RocksDB的状态的处理,做过性能的比较,发现其实性能的差异还是有一些大的,所以希望说在基于RocksDBBackend的上面能够去尽量去更多的做一些优化,从而提升作业处理的性能。第二方面就是Sql,Sql的话应该是每一个位就是当前可能各个公司都在做的一个方向,因为之前也有对Sql做一些探索,包括提供了基于Storm的一些Sql的表示,但是可能对于之前的话对于与语义的表达可能会有一些欠缺,所以希望说在基于Flink可去解决这些方面的事情,以及包括Sql的并发度的一些配置的优化,包括Sql的查询的一些优化,都希望说在Flink未来能够去优化更多的东西,去真正能使Sql应用到生产的环境。 另外一方面的话就是会进行新的场景的也在做新的场景的一些探索,期望是比如说包括刚刚也提到说除了流式的处理,也期望说把离线的场景下的数据进行一些合并,通过统一的Sql的API去提供给业务做更多的服务,包括流处理,还有批处理的结合。

April 26, 2019 · 1 min · jiezi

Flink大数据计算的机遇与挑战

作者: 王绍翾(大沙) 本文来自于王绍翾在2018年08月11日Flink China Meetup。王绍翾,花名“大沙”,加州大学圣迭戈分校计算机工程的博士,Apache Flink Commiter。目前在阿里负责Flink平台以及生态的一些工作。 本文内容如下: 流计算核心技术Flink是德国data Artisans创造的,早期Flink主要是做偏批计算的,但是Spark在批处理上已经有一定优势,正面竞争没什么意义,于是改变方向,基于chandy-lamport算法开始做流计算,完成后完美的解决了低延迟问题和状态管理。 低延迟,快速容错低延迟是Flink源生的,当然保证了快速容错。大数据计算中job总是会失败,所以需要能够快速的恢复。如果平时延迟很低,但是job一失败,恢复几分钟,肯定是无法接受的。 通用的API,易用性Flink有了基础的能力后,开始考虑通用的API,最开始的时候有了一些Java和Scala的一些API。但是发展到一定程度之后,因为API不只是开放于开发,而是所有用户。怎么样更容易的满足用户的需求和支持用户,这是流计算的很核心的一点。 弹性,高性能弹性,高性能是大数据不变的主题。怎么样确保引擎在上千台机器不出问题的运行,scalability很重要,包括Spark早期到一定规模遇到很多问题,当然Blink已经完美的解决了所有问题。在性能上,Flink不仅是在流计算还是批处理上已经有了绝对的优势。 流和批的统一Flink的早期interface是非常弱的,包括Spark早期也是,于是流计算的社区开始讨论流计算的SQL到底是什么样子的,于是形成了两派风格,一派是认为Streaming SQL是一种different SQL跟Batch Sql,另一派推的SQL跟Batch SQL是完全一致的。 为什么会说完全一致?流计算跟批计算一个基本的区别是,都是计算,但是流计算需要提前看到结果,这需要将结果提前发出,但是后面过来的数据会对前面的结果进行修正,所以流计算跟批计算比较大的区别就是数据提前发出和数据修正,最终保证数据正确。 怎么来处理这个问题: 首先要告诉用户API,怎么样去计算完全是用户的语义另外两点就是什么时候发出去,什么时候修正,这些跟SQL本身描述是没什么关系的所以传统的ANSI SQL是完全可以描述流计算的,Flink SQL的语义就是ANSI SQL用户要什么?高性能高级分析容易开发开箱即用低延迟 我们说的是大数据,而不仅仅是流计算。对于功能型的用户,更关心的是易用性,如何做好分析,如何更好的开发,如何更容易上手。我没学过计算机,但是学的是其他任何的一个行业可能是统计,生物,建筑,金融……,怎么样才能更快的开发出来。 假如老板说,今天要部署Flink了,于是给了你50台机器,到了第二天,你部署完毕了,作业跑起来了,老板吓呆了,觉得你KPI非常的棒。所以开箱即用,更容易的去开发对用户来说非常需要的。 传统的批计算要追求performance,目前流计算对performance需求越来越大。 一.Flink的现状和未来知道了用户想要的,我们看Flink现状。 Flink目前被广泛的用于超低延迟流计算场景中,但是Flink在批处理上其实已经有非常高的处理性能,并且在API上流和批是统一的,在性能上和易用性上都有不错的表现。 带着已知的事情和一点点未知的事情,来看看Flink能做的一些事情:流计算已经非常成熟,批计算,AI的计算,包括TF ON Flink,training也好,prediction也好,任何计算。另外还有很大的一块IOT,Hadoop Summit 中强调各种数据中,流的也好,批的也好,最终IOT的数据最大。虽然不是每个公司都会接触IOT,但它绝对是一个很大的future。 1.阿里巴巴的BlinkBlink1.0实际上是enterprise版的Flink,主要专注与流计算上。 Blink2.0是一个统一的引擎,支持流处理和批处理,在其他方面,例如AI方面做了很大的改进,在batch性能上已经远超Spark。回馈社区也是这个版本。 2.Flink SQL Engine的架构我们先看一眼Flink SQL Engine,从上面开始有Query的API,有Query Optimization,下来会翻译到DataSteam或者DataSet算子,然后Runtime,在各个集群上运行。这个架构在里面展开DataSteam和DataSet,可以看到几个比较大的问题: 在设计上,从来没想过统一起来。最终Query Optimization翻译完之后到DataStream或者DataSet是完全两条独立的pipline,而且往下的代码是全完不复用的再一个可以看批计算,DataSet下面还有一个Optimized Plan,这两层优化给统一带来很大的困难 3.Blink SQL Engine的架构我们把整个的SQL Engine换成上图所示。从上层开始的API,到下面的Query Processor包括了Query Optimizer和Query Executor,当做完这些发现,代码大量的减少并被复用,一个job用同样的SQL只需要标识是Batch Mode还是Stream Mode,就会得到一样的结果。 从API开始,翻译成Logical Plan经过Optimizer,再到类似写DataStream的这种Physical Plan,我们可以看到在Optimizer之前的批跟流完全一样,SQL一样,Logical Plan也一样。即用户脑子里想的东西,在批和流中一模一样。 二.优化流计算的挑战和机遇在Optimizer之后,流和批有些不一样。 批和流在一样的地方就是一些简单的filter,predicate,projection还有joining reorder。 区别就是在流计算我们不去支持sort,因为每条数据一来,就要对之前的数据更新,就好比我让在座的各位称个体重,排个序,突然在座的哪位去上个厕所,体重变了,会影响很多人的排序,就需要改变大量的结果。所以在流上不去考虑类似sort的东西。但是流上因为有state的使用,怎么样把它的性能变得很高,减少Retraction,怎么样让用户的SLA用MicroBatch去优化。 流计算上一旦变成SQL,就得跑标准的SQL测试,TPC-H,TPC-DS。我们看这个TPCH13,这个是测试的是用一张Customer表和一张Order表,需要做一次join和count。 ...

April 25, 2019 · 1 min · jiezi

Flink状态管理和容错机制介绍

作者: 施晓罡 本文来自2018年8月11日在北京举行的 Flink Meetup会议,分享来自于施晓罡,目前在阿里大数据团队部从事Blink方面的研发,现在主要负责Blink状态管理和容错相关技术的研发 本文主要内容如下: 有状态的流数据处理;Flink中的状态接口;状态管理和容错机制实现;阿里相关工作介绍;一.有状态的流数据处理1.1什么是有状态的计算计算任务的结果不仅仅依赖于输入,还依赖于它的当前状态,其实大多数的计算都是有状态的计算。 比如wordcount,给一些word,其计算它的count,这是一个很常见的业务场景。count做为输出,在计算的过程中要不断的把输入累加到count上去,那么count就是一个state。 1.2.传统的流计算系统缺少对于程序状态的有效支持状态数据的存储和访问;状态数据的备份和恢复;状态数据的划分和动态扩容;在传统的批处理中,数据是划分为块分片去完成的,然后每一个Task去处理一个分片。当分片执行完成后,把输出聚合起来就是最终的结果。在这个过程当中,对于state的需求还是比较小的。 对于流计算而言,对State有非常高的要求,因为在流系统中输入是一个无限制的流,会运行很长一段时间,甚至运行几天或者几个月都不会停机。在这个过程当中,就需要将状态数据很好的管理起来。很不幸的是,在传统的流计算系统中,对状态管理支持并不是很完善。比如storm,没有任何程序状态的支持,一种可选的方案是storm+hbase这样的方式去实现,把这状态数据存放在Hbase中,计算的时候再次从Hbase读取状态数据,做更新在写入进去。这样就会有如下几个问题 流计算系统的任务和Hbase的数据存储有可能不在同一台机器上,导致性能会很差。这样经常会做远端的访问,走网络和存储;备份和恢复是比较困难,因为Hbase是没有回滚的,要做到Exactly onces很困难。在分布式环境下,如果程序出现故障,只能重启Storm,那么Hbase的数据也就无法回滚到之前的状态。比如广告计费的这种场景,Storm+Hbase是是行不通的,出现的问题是钱可能就会多算,解决以上的办法是Storm+mysql,通过mysql的回滚解决一致性的问题。但是架构会变得非常复杂。性能也会很差,要commit确保数据的一致性。对于storm而言状态数据的划分和动态扩容也是非常难做,一个很严重的问题是所有用户都会在strom上重复的做这些工作,比如搜索,广告都要在做一遍,由此限制了部门的业务发展。1.3.Flink丰富的状态访问和高效的容错机制Flink在最早设计的时候就意识到了这个问题,并提供了丰富的状态访问和容错机制。如下图所示: 二.Flink中的状态管理2.1.按照数据的划分和扩张方式,Flink中大致分为2类:Keyed StatesOperator States 2.1.1.Keyed StatesKeyed States的使用 Flink也提供了Keyed States多种数据结构类型 Keyed States的动态扩容 2.1.2.Operator StateOperator States的使用 Operator States的数据结构不像Keyed States丰富,现在只支持List Operator States多种扩展方式 Operator States的动态扩展是非常灵活的,现提供了3种扩展,下面分别介绍: ListState:并发度在改变的时候,会将并发上的每个List都取出,然后把这些List合并到一个新的List,然后根据元素的个数在均匀分配给新的Task;UnionListState:相比于ListState更加灵活,把划分的方式交给用户去做,当改变并发的时候,会将原来的List拼接起来。然后不做划分,直接交给用户;BroadcastState:如大表和小表做Join时,小表可以直接广播给大表的分区,在每个并发上的数据都是完全一致的。做的更新也相同,当改变并发的时候,把这些数据COPY到新的Task即可以上是Flink Operator States提供的3种扩展方式,用户可以根据自己的需求做选择。 使用Checkpoint提高程序的可靠性 用户可以根据的程序里面的配置将checkpoint打开,给定一个时间间隔后,框架会按照时间间隔给程序的状态进行备份。当发生故障时,Flink会将所有Task的状态一起恢复到Checkpoint的状态。从哪个位置开始重新执行。 Flink也提供了多种正确性的保障,包括: AT LEAST ONCE;Exactly once; 备份为保存在State中的程序状态数据 Flink也提供了一套机制,允许把这些状态放到内存当中。做Checkpoint的时候,由Flink去完成恢复。 从已停止作业的运行状态中恢复 当组件升级的时候,需要停止当前作业。这个时候需要从之前停止的作业当中恢复,Flink提供了2种机制恢复作业: Savepoint:是一种特殊的checkpoint,只不过不像checkpoint定期的从系统中去触发的,它是用户通过命令触发,存储格式和checkpoint也是不相同的,会将数据按照一个标准的格式存储,不管配置什么样,Flink都会从这个checkpoint恢复,是用来做版本升级一个非常好的工具;External Checkpoint:对已有checkpoint的一种扩展,就是说做完一次内部的一次Checkpoint后,还会在用户给定的一个目录中,多存储一份checkpoint的数据; 三.状态管理和容错机制实现下面介绍一下状态管理和容错机制实现方式,Flink提供了3种不同的StateBackend MemoryStateBackendFsStateBackendRockDBStateBackend 用户可以根据自己的需求选择,如果数据量较小,可以存放到MemoryStateBackend和FsStateBackend中,如果数据量较大,可以放到RockDB中。 下面介绍HeapKeyedStateBackend和RockDBKeyedStateBackend 第一,HeapKeyedStateBackend 第二,RockDBKeyedStateBackend Checkpoint的执行流程Checkpoint的执行流程是按照Chandy-Lamport算法实现的。 Checkpoint Barrier的对齐 全量Checkpoint全量Checkpoint会在每个节点做备份数据时,只需要将数据都便利一遍,然后写到外部存储中,这种情况会影响备份性能。在此基础上做了优化。 ...

April 25, 2019 · 1 min · jiezi

Jstorm到Flink-在今日头条的迁移实践

作者:张光辉 本文将为大家展示字节跳动公司怎么把Storm从Jstorm迁移到Flink的整个过程以及后续的计划。你可以借此了解字节跳动公司引入Flink的背景以及Flink集群的构建过程。字节跳动公司是如何兼容以前的Jstorm作业以及基于Flink做一个任务管理平台的呢?本文将一一为你揭开这些神秘的面纱。 本文内容如下: 引入Flink的背景Flink集群的构建过程构建流式管理平台引入Flink的背景下面这幅图展示的是字节跳动公司的业务场景 首先,应用层有广告,也有AB测,也有推送和数据仓库的一些业务。然后在使用J storm的过程中,增加了一层模板主要应用于storm的计算模型,使用的语言是python。所以说中间相对抽象了一个schema,跑在最下面一层J storm计算引擎的上面。 字节跳动公司有很多J-storm集群,在当时17年7月份的时候,也就是在计划迁移到Flink之前,J storm集群的规模大概是下图所示的规模级别,当时已经有5000台机器左右了。 接下来,介绍下迁移Flink的整个过程。先详细地介绍一下当时J-Storm是怎么用的。 上面是一个word count的例子:左边是一个目录结构,这个目录结构在resources下面,里面的Spout/Bolt的逻辑都是一些python脚本写的。然后在最外层还有一个topology_online.yaml配置文件。这个配置文件是用来干什么的?就是把所有的Spout和Bolt串联起来构成一个有向无关图,也就是DAG图。这就是使用J storm时的整个目录结构,大部分用户都是这样用的。右边是Spout和Bolt的逻辑,其实是抽象出来了一个函数,就在这里面写业务方面的函数,然后将tuple_batch也就是上游流下来的数据去做一些计算逻辑。 下面详细介绍一下配置文件的信息,其实我们有整个拓扑结构拓扑的信息,比如说作业名叫什么,作业需要多少资源,需要多少work数。这里面会有单个的spout和Bolt的配置信息,比如是消费的topic还是一些并发度? 除了这些信息还有整个这个数据流的流转,比如说spout的输出,输出messsage的消息等等。最后还有整个的Spout到Bolt之间的shuffle逻辑。这就是我们之前Jstorm的整个使用方式。最后会把整个目录结构里面的内容去解析出来,根据配置文件把整个storm的拓扑结构构建出来,然后提交到集群上面去跑。 使用Jstorm集群遇到了什么问题呢?第一个问题,因为我们当时是用使用python写的代码,整个集群是没有内存隔离的,job和work之间是没有内存限制的。比如说在实际过程中会经常遇到一个用户,他可能代码写的有问题导致一个work可能占了70G内存,把机器的内存占了1/3。第二个问题就是说业务团队之间没有扩大管理,预算和审核是无头绪的。我们当时都是都是跑在一个大集群上面,然后个别业务是单独跑在一些小集群,但是我们每次都是资源不足,也没办法梳理这个预算。 第三个问题就是集群过多,运维平台化做得不太好,都是靠人来运维的。这个时候集群多了基本上是管不过来的。 第四个问题就是说我们用python写的代码,有些性能比较差。但是我们在Storm的基础上面去推广这个Java也比较难,因为我们部分同事实际上是不认可Java的,因为他觉得java开发速度太慢了。 我们当时想解决上面的问题,一个思路是把Jstorm放在yarn上面,直接把Jstorm在yarn上面兼容做这一套。后来因为知道阿里在用Flink所以去调研Flink,发现了Flink的一些优势,所以想尝试用Flink解决存在的问题。 使用Flink首先第一个问题可以成功解决,因为Flink作业是跑在yarn上面的,这就解决了内存隔离的问题。然后Yarn也是支持队列的,我们可以根据业务去划分队列,这样我们的扩大预算审核的问题得到解决了。我们也不需要自己运维一个集群了,因为有yarn去管理我们的资源,这样也节省了运维成员。在此基础上还可以做一些物理隔离队列,其实物理隔离队列现在也遇到了问题。因为物理隔离队列只是说这个机器隔离了,但是相当于是机柜也没有隔离网络带宽也没有隔离,所以说即使是物理隔离队列,现在也遇到比如说和离线作业共用机柜的时候,这个机柜的出口带宽被打满的问题。针对这些问题,我们后续可能想在这个离线离线集群上面做QOS这种流量级别的方式来解决这个问题。 Flink实际上是可以兼容Storm的,比如说之前的历史作业是可以迁移过来的,不需要维护两套计算引擎。Flink支持一些高优先级的API比如说支持SQL以及窗口等特性包括说checkpoint。我们头条的业务对exactly-once的需求不是特别的强烈。 以上就是Flink的优势,于是我们就决定从J storm往Flink去迁移。 Flink集群的构建过程在迁移的过程中,第一件事情是先把Flink集群建立起来。一开始肯定都是追求稳定性,比如说把离线的yarn集群隔离开,然后不依赖于HDFS也可以把Hdfs线上的name node, name space隔离出来。然后我们梳理了原来storm上面的作业,哪些作业属于不同的业务,然后映射到不同的队列里面去,最后把一些特殊的队列也隔离开来。这是我们准备这个Fink集群的时候考虑的几个点。 下面就考虑Flink怎么兼容J storm,然后把它迁移过来。 我们当时Flink用的是1.32版本,因为Flink有Flink-storm这个工程,它能把Storm作业转化成Flink作业,我们就借鉴这些技术上实现了一个Flink –jstorm。相当于把一个J storm的拓扑结构转化成了一个Flink job。只做完这件事情是不够的,因为我们有一系列的外围工具需要去对齐。比如说之前提交作业的时候是通过一个脚本提交的让用户去屏蔽一些其他的参数。使用 flink的话我们同样也是需要构建这么一个脚本,然后去提交Flink Job,最后停止flink Job。第三点是构建flink job外围工具,自动注册报警,比如说消费延迟报警,自动注册这个Dashboard以及一些log service,所有的这些为外围工具都要和原来的服务去对齐。 对齐完之后,我们需要构建一个迁移脚本,迁移的过程中最困难的是资源配置这一块。因为原来Storm用了多少资源,Storm怎么配,这对于迁移的用户来说,如果是第一次做肯定是不了解这些东西。因此我们写这么一个脚本,帮用户生成它Flink集群里面对应的资源使用情况。这些工作做完了之后,我们就开始去迁移。到现在为止,整体迁移完了,还剩下十个左右的作业没有迁移完。现在集群规模达到了大概是6000多台。 在迁移的过程中我们有一些其他优化,比如说J storm是能够支持task和work维度的重启的,Flink这一块做得不是特别好。我们在这方面做了一些优化实现了一个single task和single tm粒度的重启,这样就解决部分作业因为task重启导致整个作业全部重启。 构建流式管理平台 迁移完之后,我们又构建了一个流式管理平台。这个平台是为了解决实际过程中遇到了一些问题,比如说整个机群挂了无法确定哪些作业在上面跑着,也通知不到具体的用户,有些用户作业都不知道自己提交了哪些作业。我们构建流式作业的时候目标实际上就是和其他的管理平台是一样的,比如说我们提供一些界面操作,然后提供一个版本管理,就是为了方便方便用户升级和回滚的操作,我们还提供了一站式的查问题的工具:把一些用户需要的信息都聚合在一个页面上面,防止用户不断跳来跳去以及避免不同系统之间的切换。有一些历史记录之前不管是跑在yarn上面还是跑到storm上面,我一个作业被别人kill到了,其实我都是不知道的。针对这个问题我们提供了一些历史操作记录的一些目标。 设计这个管理平台的时候,我们考虑到提供这么一个前端管理平台可能只是针对公司内部的一部分产品,其他的产品也做了自己的一套前端。他们可以用一个模板,根据自己的逻辑去生成一个storm任务。基于此,我们把整个管理平台抽象了两层:最上一层实际上相当于一个面向用户或者说是类似于前端的一个产品。中间这一层实际上是一个类似于提交作业调度任务,这一层只负责提任务,然后停任务,管理生命周期以及因为故障导致作业失败了,将作业重新拉起来。这是中间层TSS层做的事情。 这样,我们就可以对接到所有的前端平台。通过一个RPC进行TSS通信,就把所有的底层的服务和Filnk和Yarn还有HDFS这些交互的底层的逻辑完全屏蔽开来了。 接下来,用户写一个作业就比较简单了,流程如下: 第一步用户先要生成自己的一个作业模板,我们这边通过maven提供的脚本架去生成一些作业的schema,这个作业执行完之后,它会把帮你把一些porm文件,还有一些类似于kafkasource这种常规的组件都帮你准备好,然后你直接在这个模板里面填自己的主要逻辑就可以了。因为我们写Java程序遇到最多的一个问题就是包冲突问题。所以porm文件帮助用户把一些可能冲突的一些jar包都给以exclude掉,这样包冲突的概率会越来越小。 我们测试作业基本上是用IDEA或者local模式去测试,也提供了一个脚本去提交作业,通过这个脚本提交到stage环境上面。在提交注册在平台上面去注册这个作业,然后添加一些配置信息。 下面是一个代码版本管理的界面: 把整个作业提交之后如下图所示: ...

April 25, 2019 · 1 min · jiezi

Flink在饿了么的应用与实践

本文作者:易伟平(饿了么) 整理:姬平(阿里巴巴实时计算部) 本文将为大家展示饿了么大数据平台在实时计算方面所做的工作,以及计算引擎的演变之路,你可以借此了解Storm、Spark、Flink的优缺点。如何选择一个合适的实时计算引擎?Flink凭借何种优势成为饿了么首选?本文将带你一一解开谜题。平台现状下面是目前饿了么平台现状架构图: 来源于多个数据源的数据写到 kafka 里,计算引擎主要是 Storm , Spark 和 Flink,计算引擎出来的结果数据再落地到各种存储上。 目前 Storm 任务大概有100多个,Spark任务有50个左右,Flink暂时还比较少。 目前我们集群规模每天数据量有60TB,计算次数有1000000000,节点有400个。这里要提一下,Spark 和 Flink都是 on yarn 的,其中Flink onyarn主要是用作任务间 jobmanager 隔离, Storm 是 standalone 模式。 应用场景1.一致性语义在讲述我们应用场景之前,先强调实时计算一个重要概念, 一致性语义: 1) at-most-once:即 fire and forget,我们通常写一个 java 的应用,不去考虑源头的 offset 管理,也不去考虑下游的幂等性的话,就是简单的at-most-once,数据来了,不管中间状态怎样,写数据的状态怎样,也没有ack机制。 2) at-least-once: 重发机制,重发数据保证每条数据至少处理一次。 3) exactly-once: 使用粗 checkpoint 粒度控制来实现 exactly-once,我们讲的 exactly-once 大多数指计算引擎内的 exactly-once,即每一步的 operator 内部的状态是否可以重放;上一次的 job 如果挂了,能否从上一次的状态顺利恢复,没有涉及到输出到 sink 的幂等性概念。 4) at-least-one + idempotent = exactly-one:如果我们能保证说下游有幂等性的操作,比如基于mysql实现 update on duplicate key;或者你用es, cassandra之类的话,可以通过主键key去实现upset的语义, 保证at-least-once的同时,再加上幂等性就是exactly-once。 ...

April 25, 2019 · 3 min · jiezi

聊聊flink-jdbc的ParameterValuesProvider

序本文主要研究一下flink jdbc的ParameterValuesProvider ParameterValuesProviderflink-jdbc_2.11-1.8.0-sources.jar!/org/apache/flink/api/java/io/jdbc/split/ParameterValuesProvider.java /** * This interface is used by the {@link JDBCInputFormat} to compute the list of parallel query to run (i.e. splits). * Each query will be parameterized using a row of the matrix provided by each {@link ParameterValuesProvider} * implementation. */public interface ParameterValuesProvider { /** Returns the necessary parameters array to use for query in parallel a table. */ Serializable[][] getParameterValues();}ParameterValuesProvider接口定义了getParameterValues方法,用于返回并行表查询所需的参数,该参数主要是用于将一个大的sql查询分为几个分段查询用于并行处理;它有两个实现类分别是GenericParameterValuesProvider及NumericBetweenParametersProviderGenericParameterValuesProviderflink-jdbc_2.11-1.8.0-sources.jar!/org/apache/flink/api/java/io/jdbc/split/GenericParameterValuesProvider.java /** * This splits generator actually does nothing but wrapping the query parameters * computed by the user before creating the {@link JDBCInputFormat} instance. */public class GenericParameterValuesProvider implements ParameterValuesProvider { private final Serializable[][] parameters; public GenericParameterValuesProvider(Serializable[][] parameters) { this.parameters = parameters; } @Override public Serializable[][] getParameterValues(){ //do nothing...precomputed externally return parameters; }}GenericParameterValuesProvider实际上没有做其他事情,它实现的getParameterValues方法返回的值是构造器要求输入的NumericBetweenParametersProviderflink-jdbc_2.11-1.8.0-sources.jar!/org/apache/flink/api/java/io/jdbc/split/NumericBetweenParametersProvider.java ...

April 23, 2019 · 12 min · jiezi

袋鼠云研发手记 | 开源·数栈-扩展FlinkSQL实现流与维表的join

作为一家创新驱动的科技公司,袋鼠云每年研发投入达数千万,公司80%员工都是技术人员,袋鼠云产品家族包括企业级一站式数据中台PaaS数栈、交互式数据可视化大屏开发平台Easy[V]等产品也在迅速迭代。在进行产品研发的过程中,技术小哥哥们能文能武,不断提升产品性能和体验的同时,也把这些提升和优化过程记录下来,现录入“袋鼠云研发手记”专栏中,以和业内童鞋们分享交流。下为“袋鼠云研发手记”专栏第三期,本期作者为袋鼠云数栈引擎团队。袋鼠云数栈引擎团队袋鼠云数栈引擎团队拥有多名专家级别,经验丰富的后端开发工程师,分别支撑公司大数栈产品线的不同子项目的开发需求,从项目中提取并开源了FlinkX(基于Flink的数据同步),Jlogstash(logstash 的java 版本实现),FlinkStreamSQL(扩展原生FlinkSQL,实现流与维表的join)多个项目。在长期的项目实践与产品迭代过程中,团队成员在 Hadoop技术栈上不断深耕探索,积累了丰富的经验与最佳实践。第三期数栈·开源 拓展FlinkSQL实现流与维表的joinFlinkStreamSQL 已经开源在Github上 目前已获380+Star1、为什么要扩展FlinkSQL?实时计算需要完全SQL化SQL是数据处理中使用最广泛的语言。它允许用户简明扼要地声明他们的业务逻辑。大数据批计算使用SQL很常见,但是支持SQL的实时计算并不多。其实,用SQL开发实时任务可以极大降低数据开发的门槛,在袋鼠云数栈-实时计算模块,我们决定实现完全SQL化。数据计算采用SQL的优势☑ 声明式。用户只需要表达我想要什么,至于怎么计算那是系统的事情,用户不用关心。☑ 自动调优。查询优化器可以为用户的 SQL 生成最有的执行计划。用户不需要了解它,就能自动享受优化器带来的性能提升。☑ 易于理解。很多不同行业不同领域的人都懂 SQL,SQL 的学习门槛很低,用 SQL 作为跨团队的开发语言可以很大地提高效率。☑ 稳定。SQL 是一个拥有几十年历史的语言,是一个非常稳定的语言,很少有变动。所以当我们升级引擎的版本时,甚至替换成另一个引擎,都可以做到兼容地、平滑地升级。实时计算还需要流与维表的JOIN在实时计算的世界里不只是流与流的JOIN,还需要流与维表的JOIN在实时计算的世界里不只是流与流的JOIN,还需要流与维表的JOIN。在去年,袋鼠云数栈V3.0版本研发期间,当时最新版本——flink1.6中FlinkSQL,已经将SQL的优势应用到Flink引擎中,但还未支持流与维表的JOIN。关于FlinkSQLFlinkSQL于2017年7月开始面向阿里巴巴集团开放流计算服务的,虽然是一个非常年轻的产品,但是到双11期间已经支撑了数千个作业,在双11期间,Blink 作业的处理峰值达到了5+亿每秒,而其中仅 Flink SQL 作业的处理总峰值就达到了3亿/秒。参考链接:https://yq.aliyun.com/article…这里先解释下什么是维表;维表是动态表,表里所存储的数据有可能不变,也有可能定时更新,但是更新频率不是很频繁。在业务开发中一般的维表数据存储在关系型数据库如mysql,oracle等,也可能存储在hbase,redis等nosql数据库。2、所以要用FlinkSQL实现流与维表的join 分两步:一、用Flink api实现维表的功能要实现维表功能就要用到 Flink Aysnc I/O 这个功能,是由阿里巴巴贡献给Apache Flink的。Async I/O 是由阿里巴巴贡献给社区的,于1.2版本引入,主要目的是为了解决与外部系统交互时网络延迟成为了系统瓶颈的问题。具体介绍可以看这篇文章:http://wuchong.me/blog/2017/0…对应到Flink 的api就是RichAsyncFunction 这个抽象类,继层这个抽象类实现里面的open(初始化),asyncInvoke(数据异步调用),close(停止的一些操作)方法,最主要的是实现asyncInvoke 里面的方法。流与维表的join会碰到两个问题:第一个是性能问题。因为流速要是很快,每一条数据都需要到维表做下join,但是维表的数据是存在第三方存储系统,如果实时访问第三方存储系统,不仅join的性能会差,每次都要走网络io;还会给第三方存储系统带来很大的压力,有可能会把第三方存储系统搞挂掉。所以解决的方法就是维表里的数据要缓存,可以全量缓存,这个主要是维表数据不大的情况,还有一个是LRU缓存,维表数据量比较大的情况。LRU维表的实现第二个问题是流延迟过来的数据这么跟之前的维表数据做关联。这个就涉及到维表数据需要存储快照数据,所以这样的场景用HBase 做维表是比较适合的,因为HBase 是天生支持数据多版本的。ALL维表的实现二、解析流与维表join的SQL语法转化成底层的FlinkAPI因为FlinkSQL已经做了大部分SQL场景,我们不可能在去解析SQL的所有语法,在把他转化成底层FlinkAPI。所以我们做的就是解析SQL语法,来找到join表里有没有维表,如果有维表,那我们会把这个join的维表的语句单独拆来,用Flink的TableAPI和StreamAPi 生成新DataStream,在把这个DataStream与其他的表在做join这样就能用SQL来实现流与维表的join语法了。SQL解析的工具就是用Apache calcite,Flink也是用这个框架做SQL解析的。所以所有语法都是可以解析的。1. DEMO SQLCalcite解析Insert into语句,拆分出子语句3. Calcite继续解析select语句Calcite继续解析select语句Calcite继续解析select语句

April 18, 2019 · 1 min · jiezi

技本功丨用短平快的方式告诉你:Flink-SQL的扩展实现

2019年1月28日,阿里云宣布开源“计算王牌”实时计算平台Blink回馈给ApacheFlink社区。官方称,计算延迟已经降到毫秒级,也就是你在浏览网页的时候,眨了一下眼睛,淘宝、天猫处理的信息已经刷新了17亿次。作为一家对技术有追求、有渴望的公司,怎么少得了为Flink社区做些贡献呢?夫子说首先,本文所述均基于flink 1.5.4。我们为什么扩展Flink-SQL?由于Flink 本身SQL语法并不提供在对接输入源和输出目的的SQL语法。数据开发在使用的过程中需要根据其提供的Api接口编写Source和 Sink, 异常繁琐,不仅需要了解FLink 各类Operator的API,还需要对各个组件的相关调用方式有了解(比如kafka,redis,mongo,hbase等),并且在需要关联到外部数据源的时候没有提供SQL相关的实现方式,因此数据开发直接使用Flink编写SQL作为实时的数据分析时需要较大的额外工作量。我们的目的是在使用Flink-SQL的时候只需要关心做什么,而不需要关心怎么做。不需要过多的关心程序的实现,专注于业务逻辑。接下来,我们一起来看下Flink-SQL的扩展实现吧!01扩展了哪些flink相关sql(1)创建源表语句(2)创建输出表语句(3)创建自定义函数(4)维表关联02各个模块是如何翻译到flink的实现( 1 ) 如何将创建源表的sql语句转换为flink的operator;Flink中表的都会映射到Table这个类。然后调用注册方法将Table注册到environment。StreamTableEnvironment.registerTable(tableName, table);当前我们只支持kafka数据源。Flink本身有读取kafka 的实现类, FlinkKafkaConsumer09,所以只需要根据指定参数实例化出该对象。并调用注册方法注册即可。另外需要注意在flink sql经常会需要用到rowtime, proctime, 所以我们在注册表结构的时候额外添加rowtime,proctime。当需要用到rowtime的使用需要额外指定DataStream.watermarks(assignTimestampsAndWatermarks),自定义watermark主要做两个事情:1:如何从Row中获取时间字段。 2:设定最大延迟时间。( 2 ) 如何将创建的输出表sql语句转换为flink的operator;Flink输出Operator的基类是OutputFormat, 我们这里继承的是RichOutputFormat, 该抽象类继承OutputFormat,额外实现了获取运行环境的方法getRuntimeContext(), 方便于我们之后自定义metric等操作。我们以输出到mysql插件mysql-sink为例,分两部分:将create table 解析出表名称,字段信息,mysql连接信息。该部分使用正则表达式的方式将create table 语句转换为内部的一个实现类。该类存储了表名称,字段信息,插件类型,插件连接信息。继承RichOutputFormat将数据写到对应的外部数据源。主要是实现writeRecord方法,在mysql插件中其实就是调用jdbc 实现插入或者更新方法。( 3) 如何将自定义函数语句转换为flink的operator;Flink对udf提供两种类型的实现方式:(1)继承ScalarFunction(2)继承TableFunction需要做的将用户提供的jar添加到URLClassLoader, 并加载指定的class (实现上述接口的类路径),然后调用TableEnvironment.registerFunction(funcName, udfFunc);即完成了udf的注册。之后即可使用改定义的udf;( 4 ) 维表功能是如何实现的?流计算中一个常见的需求就是为数据流补齐字段。因为数据采集端采集到的数据往往比较有限,在做数据分析之前,就要先将所需的维度信息补全,但是当前flink并未提供join外部数据源的SQL功能。实现该功能需要注意的几个问题:(1)维表的数据是不断变化的在实现的时候需要支持定时更新内存中的缓存的外部数据源,比如使用LRU等策略。(2)IO吞吐问题如果每接收到一条数据就串行到外部数据源去获取对应的关联记录的话,网络延迟将会是系统最大的瓶颈。这里我们选择阿里贡献给flink社区的算子RichAsyncFunction。该算子使用异步的方式从外部数据源获取数据,大大减少了花费在网络请求上的时间。(3)如何将sql 中包含的维表解析到flink operator 为了从sql中解析出指定的维表和过滤条件, 使用正则明显不是一个合适的办法。需要匹配各种可能性。将是一个无穷无尽的过程。查看flink本身对sql的解析。它使用了calcite做为sql解析的工作。将sql解析出一个语法树,通过迭代的方式,搜索到对应的维表;然后将维表和非维表结构分开。通过上述步骤可以通过SQL完成常用的从kafka源表,join外部数据源,写入到指定的外部目的结构中。

March 28, 2019 · 1 min · jiezi

聊聊flink的KvStateRegistryGateway

序本文主要研究一下flink的KvStateRegistryGatewayKvStateRegistryGatewayflink-1.7.2/flink-runtime/src/main/java/org/apache/flink/runtime/jobmaster/KvStateRegistryGateway.javapublic interface KvStateRegistryGateway { /** * Notifies that queryable state has been registered. * * @param jobId identifying the job for which to register a key value state * @param jobVertexId JobVertexID the KvState instance belongs to. * @param keyGroupRange Key group range the KvState instance belongs to. * @param registrationName Name under which the KvState has been registered. * @param kvStateId ID of the registered KvState instance. * @param kvStateServerAddress Server address where to find the KvState instance. * @return Future acknowledge if the key-value state has been registered / CompletableFuture<Acknowledge> notifyKvStateRegistered( final JobID jobId, final JobVertexID jobVertexId, final KeyGroupRange keyGroupRange, final String registrationName, final KvStateID kvStateId, final InetSocketAddress kvStateServerAddress); /* * Notifies that queryable state has been unregistered. * * @param jobId identifying the job for which to unregister a key value state * @param jobVertexId JobVertexID the KvState instance belongs to. * @param keyGroupRange Key group index the KvState instance belongs to. * @param registrationName Name under which the KvState has been registered. * @return Future acknowledge if the key-value state has been unregistered / CompletableFuture<Acknowledge> notifyKvStateUnregistered( final JobID jobId, final JobVertexID jobVertexId, final KeyGroupRange keyGroupRange, final String registrationName);}KvStateRegistryGateway接口定义了notifyKvStateRegistered、notifyKvStateUnregistered两个方法;JobMaster实现了这两个方法JobMasterflink-1.7.2/flink-runtime/src/main/java/org/apache/flink/runtime/jobmaster/JobMaster.javapublic class JobMaster extends FencedRpcEndpoint<JobMasterId> implements JobMasterGateway { /* Default names for Flink’s distributed components. / public static final String JOB_MANAGER_NAME = “jobmanager”; public static final String ARCHIVE_NAME = “archive”; // ———————————————————————— private final JobMasterConfiguration jobMasterConfiguration; private final ResourceID resourceId; private final JobGraph jobGraph; private final Time rpcTimeout; private final HighAvailabilityServices highAvailabilityServices; private final BlobServer blobServer; private final JobManagerJobMetricGroupFactory jobMetricGroupFactory; private final HeartbeatManager<AccumulatorReport, Void> taskManagerHeartbeatManager; private final HeartbeatManager<Void, Void> resourceManagerHeartbeatManager; private final ScheduledExecutorService scheduledExecutorService; private final OnCompletionActions jobCompletionActions; private final FatalErrorHandler fatalErrorHandler; private final ClassLoader userCodeLoader; private final SlotPool slotPool; private final SlotPoolGateway slotPoolGateway; private final RestartStrategy restartStrategy; // ——— BackPressure ——– private final BackPressureStatsTracker backPressureStatsTracker; // ——— ResourceManager ——– private final LeaderRetrievalService resourceManagerLeaderRetriever; // ——— TaskManagers ——– private final Map<ResourceID, Tuple2<TaskManagerLocation, TaskExecutorGateway>> registeredTaskManagers; // ——– Mutable fields ——— private ExecutionGraph executionGraph; @Nullable private JobManagerJobStatusListener jobStatusListener; @Nullable private JobManagerJobMetricGroup jobManagerJobMetricGroup; @Nullable private String lastInternalSavepoint; @Nullable private ResourceManagerAddress resourceManagerAddress; @Nullable private ResourceManagerConnection resourceManagerConnection; @Nullable private EstablishedResourceManagerConnection establishedResourceManagerConnection; //…… @Override public CompletableFuture<Acknowledge> notifyKvStateRegistered( final JobID jobId, final JobVertexID jobVertexId, final KeyGroupRange keyGroupRange, final String registrationName, final KvStateID kvStateId, final InetSocketAddress kvStateServerAddress) { if (jobGraph.getJobID().equals(jobId)) { if (log.isDebugEnabled()) { log.debug(“Key value state registered for job {} under name {}.”, jobGraph.getJobID(), registrationName); } try { executionGraph.getKvStateLocationRegistry().notifyKvStateRegistered( jobVertexId, keyGroupRange, registrationName, kvStateId, kvStateServerAddress); return CompletableFuture.completedFuture(Acknowledge.get()); } catch (Exception e) { log.error(“Failed to notify KvStateRegistry about registration {}.”, registrationName); return FutureUtils.completedExceptionally(e); } } else { if (log.isDebugEnabled()) { log.debug(“Notification about key-value state registration for unknown job {} received.”, jobId); } return FutureUtils.completedExceptionally(new FlinkJobNotFoundException(jobId)); } } @Override public CompletableFuture<Acknowledge> notifyKvStateUnregistered( JobID jobId, JobVertexID jobVertexId, KeyGroupRange keyGroupRange, String registrationName) { if (jobGraph.getJobID().equals(jobId)) { if (log.isDebugEnabled()) { log.debug(“Key value state unregistered for job {} under name {}.”, jobGraph.getJobID(), registrationName); } try { executionGraph.getKvStateLocationRegistry().notifyKvStateUnregistered( jobVertexId, keyGroupRange, registrationName); return CompletableFuture.completedFuture(Acknowledge.get()); } catch (Exception e) { log.error(“Failed to notify KvStateRegistry about registration {}.”, registrationName, e); return FutureUtils.completedExceptionally(e); } } else { if (log.isDebugEnabled()) { log.debug(“Notification about key-value state deregistration for unknown job {} received.”, jobId); } return FutureUtils.completedExceptionally(new FlinkJobNotFoundException(jobId)); } } //……}JobMaster的notifyKvStateRegistered方法主要是触发executionGraph.getKvStateLocationRegistry().notifyKvStateRegistered;notifyKvStateUnregistered方法主要是触发executionGraph.getKvStateLocationRegistry().notifyKvStateUnregisteredKvStateLocationRegistryflink-1.7.2/flink-runtime/src/main/java/org/apache/flink/runtime/query/KvStateLocationRegistry.javapublic class KvStateLocationRegistry { /* JobID this coordinator belongs to. / private final JobID jobId; /* Job vertices for determining parallelism per key. / private final Map<JobVertexID, ExecutionJobVertex> jobVertices; /* * Location info keyed by registration name. The name needs to be unique * per JobID, i.e. two operators cannot register KvState with the same * name. / private final Map<String, KvStateLocation> lookupTable = new HashMap<>(); /* * Creates the registry for the job. * * @param jobId JobID this coordinator belongs to. * @param jobVertices Job vertices map of all vertices of this job. / public KvStateLocationRegistry(JobID jobId, Map<JobVertexID, ExecutionJobVertex> jobVertices) { this.jobId = Preconditions.checkNotNull(jobId, “JobID”); this.jobVertices = Preconditions.checkNotNull(jobVertices, “Job vertices”); } /* * Returns the {@link KvStateLocation} for the registered KvState instance * or <code>null</code> if no location information is available. * * @param registrationName Name under which the KvState instance is registered. * @return Location information or <code>null</code>. / public KvStateLocation getKvStateLocation(String registrationName) { return lookupTable.get(registrationName); } /* * Notifies the registry about a registered KvState instance. * * @param jobVertexId JobVertexID the KvState instance belongs to * @param keyGroupRange Key group range the KvState instance belongs to * @param registrationName Name under which the KvState has been registered * @param kvStateId ID of the registered KvState instance * @param kvStateServerAddress Server address where to find the KvState instance * * @throws IllegalArgumentException If JobVertexID does not belong to job * @throws IllegalArgumentException If state has been registered with same * name by another operator. * @throws IndexOutOfBoundsException If key group index is out of bounds. / public void notifyKvStateRegistered( JobVertexID jobVertexId, KeyGroupRange keyGroupRange, String registrationName, KvStateID kvStateId, InetSocketAddress kvStateServerAddress) { KvStateLocation location = lookupTable.get(registrationName); if (location == null) { // First registration for this operator, create the location info ExecutionJobVertex vertex = jobVertices.get(jobVertexId); if (vertex != null) { int parallelism = vertex.getMaxParallelism(); location = new KvStateLocation(jobId, jobVertexId, parallelism, registrationName); lookupTable.put(registrationName, location); } else { throw new IllegalArgumentException(“Unknown JobVertexID " + jobVertexId); } } // Duplicated name if vertex IDs don’t match if (!location.getJobVertexId().equals(jobVertexId)) { IllegalStateException duplicate = new IllegalStateException( “Registration name clash. KvState with name ‘” + registrationName + “’ has already been registered by another operator (” + location.getJobVertexId() + “).”); ExecutionJobVertex vertex = jobVertices.get(jobVertexId); if (vertex != null) { vertex.fail(new SuppressRestartsException(duplicate)); } throw duplicate; } location.registerKvState(keyGroupRange, kvStateId, kvStateServerAddress); } /* * Notifies the registry about an unregistered KvState instance. * * @param jobVertexId JobVertexID the KvState instance belongs to * @param keyGroupRange Key group index the KvState instance belongs to * @param registrationName Name under which the KvState has been registered * @throws IllegalArgumentException If another operator registered the state instance * @throws IllegalArgumentException If the registration name is not known */ public void notifyKvStateUnregistered( JobVertexID jobVertexId, KeyGroupRange keyGroupRange, String registrationName) { KvStateLocation location = lookupTable.get(registrationName); if (location != null) { // Duplicate name if vertex IDs don’t match if (!location.getJobVertexId().equals(jobVertexId)) { throw new IllegalArgumentException(“Another operator (” + location.getJobVertexId() + “) registered the KvState " + “under ‘” + registrationName + “’.”); } location.unregisterKvState(keyGroupRange); if (location.getNumRegisteredKeyGroups() == 0) { lookupTable.remove(registrationName); } } else { throw new IllegalArgumentException(“Unknown registration name ‘” + registrationName + “’. " + “Probably registration/unregistration race.”); } }}KvStateLocationRegistry的构造器要求传入jobId及jobVertices;它有一个属性为lookupTable,存储了registrationName与KvStateLocation的映射关系notifyKvStateRegistered方法在lookupTable查找不到对应的KvStateLocation的时候会创建一个KvStateLocation并存放入lookupTable,最后调用location.registerKvState方法notifyKvStateUnregistere方法在lookupTable查找对应KvStateLocation的时候会触发location.unregisterKvState,然后将该KvStateLocation从lookupTable中移除小结KvStateRegistryGateway接口定义了notifyKvStateRegistered、notifyKvStateUnregistered两个方法;JobMaster实现了这两个方法JobMaster的notifyKvStateRegistered方法主要是触发executionGraph.getKvStateLocationRegistry().notifyKvStateRegistered;notifyKvStateUnregistered方法主要是触发executionGraph.getKvStateLocationRegistry().notifyKvStateUnregisteredKvStateLocationRegistry的构造器要求传入jobId及jobVertices;它有一个属性为lookupTable,存储了registrationName与KvStateLocation的映射关系;notifyKvStateRegistered方法在lookupTable查找不到对应的KvStateLocation的时候会创建一个KvStateLocation并存放入lookupTable,最后调用location.registerKvState方法;notifyKvStateUnregistere方法在lookupTable查找对应KvStateLocation的时候会触发location.unregisterKvState,然后将该KvStateLocation从lookupTable中移除docKvStateRegistryGateway ...

March 19, 2019 · 5 min · jiezi

从0到1学习Flink》—— 你上传的 jar 包藏到哪里去了?

前言写这篇文章其实也是知识星球里面的一个小伙伴问了这样一个问题:通过 flink UI 仪表盘提交的 jar 是存储在哪个目录下?这个问题其实我自己也有问过,但是自己因为自己的问题没有啥压力也就没深入去思考,现在可是知识星球的付费小伙伴问的,所以自然要逼着自己去深入然后才能给出正确的答案。跟着我一起来看看我的探寻步骤吧!小小的 jar 竟然还敢和我捉迷藏?查看配置文件首先想到的是这个肯定可以在配置文件中有设置的地方的:谷歌大法好虽然有个是 upload 的,但是并不是我们想要的目录!于是,只好动用我的“谷歌大法好”。找到了一条,点进去看 Issue 如下:发现这 tm 不就是想要的吗?都支持配置文件来填写上传的 jar 后存储的目录了!赶紧点进去看一波源码:源码确认这个 jobmanager.web.upload.dir 是不是?我去看下 1.8 的源码确认一下:发现这个 jobmanager.web.upload.dir 还过期了,用 WebOptions 类中的 UPLOAD_DIR 替代了!继续跟进去看看这个 UPLOAD_DIR 是啥玩意?看这注释的意思是说,如果这个配置 web.upload.dir 没有配置具体的路径的话就会使用 JOB_MANAGER_WEB_TMPDIR_KEY 目录,那么我们来看看是否配置了这个目录呢?确实没有配置这个 jar 文件上传的目录,那么我们来看看这个临时目录 JOB_MANAGER_WEB_TMPDIR_KEY 是在哪里的?又是一个过期的目录,mmp,继续跟下去看下这个目录 TMP_DIR。我们查看下配置文件是否有配置这个 web.tmpdir 的值,又是没有:so,它肯定使用的是 System.getProperty(“java.io.tmpdir”) 这个目录了,我查看了下我本地电脑起的 job 它的配置中有这个配置如下:java.io.tmpdir /var/folders/mb/3vpbvkkx13l2jmpt2kmmt0fr0000gn/T/再观察了下 job,发现 jobManager 这里有个 web.tmpdir 的配置:web.tmpdir /var/folders/mb/3vpbvkkx13l2jmpt2kmmt0fr0000gn/T/flink-web-ea909e9e-4bac-452d-8450-b4ff082298c7发现这个 web.tmpdir 的就是由 java.io.tmpdir + “flink-web-” + UUID 组成的!水落石出进入这个目录发现我们上传的 jar 终于被找到了:配置上传 jar 目录确认上面我们虽然已经知道我们上传的 jar 是存储在这个临时目录里,那么我们现在要验证一下,我们在配置文件中配置一下上传 jar 的固定位置,我们先在目录下创建一个 jars 目录,然后在配置文件中加入这个配置:web.tmpdir: /usr/local/blink-1.5.1/jars更改之后再看 web.tmpdir 是这样的:从 Flink UI 上上传了三个 jar,查看 /usr/local/blink-1.5.1/jars/flink-web-7a98165b-1d56-44be-be8c-d0cd9166b179 目录下就出现了我们的 jar 了。我们重启 Flink,发现这三个 jar 又没有了,这也能解释之前我自己也遇到过的问题了,Flink 重启后之前所有上传的 jar 都被删除了!作为生产环境,这样玩,肯定不行的,所以我们还是得固定一个目录来存储所有的上传 jar 包,并且不能够被删除,要配置固定的目录(Flink 重启也不删除的话)需要配置如下:web.upload.dir: /usr/local/blink-1.5.1/jars这样的话,就可以保证你的 jar 不再会被删除了!再来看看源码是咋写的哈://从配置文件中找 UPLOAD_DIRfinal Path uploadDir = Paths.get( config.getString(WebOptions.UPLOAD_DIR, config.getString(WebOptions.TMP_DIR)), “flink-web-upload”);return new RestServerEndpointConfiguration( restAddress,restBindAddress,port,sslEngineFactory, uploadDir,maxContentLength,responseHeaders);他就是从配置文件中找 UPLOAD_DIR,如果为 null 就找 TMP_DIR 目录来当作 jar 上传的路径!总结本文从知识星球一个朋友的问题,从现象到本质再到解决方案的讲解了下如何找到 Flink UI 上上传的 jar 包藏身之处,并提出了如何解决 Flink 上传的 jar 包被删除的问题。本篇文章连接是:http://www.54tianzhisheng.cn/2019/03/13/flink-job-jars/关注我微信公众号:zhisheng另外我自己整理了些 Flink 的学习资料,目前已经全部放到微信公众号了。你可以加我的微信:zhisheng_tian,然后回复关键字:Flink 即可无条件获取到。更多私密资料请加入知识星球!Github 代码仓库https://github.com/zhisheng17/flink-learning/以后这个项目的所有代码都将放在这个仓库里,包含了自己学习 flink 的一些 demo 和博客。相关文章1、《从0到1学习Flink》—— Apache Flink 介绍2、《从0到1学习Flink》—— Mac 上搭建 Flink 1.6.0 环境并构建运行简单程序入门3、《从0到1学习Flink》—— Flink 配置文件详解4、《从0到1学习Flink》—— Data Source 介绍5、《从0到1学习Flink》—— 如何自定义 Data Source ?6、《从0到1学习Flink》—— Data Sink 介绍7、《从0到1学习Flink》—— 如何自定义 Data Sink ?8、《从0到1学习Flink》—— Flink Data transformation(转换)9、《从0到1学习Flink》—— 介绍Flink中的Stream Windows10、《从0到1学习Flink》—— Flink 中的几种 Time 详解11、《从0到1学习Flink》—— Flink 写入数据到 ElasticSearch12、《从0到1学习Flink》—— Flink 项目如何运行?13、《从0到1学习Flink》—— Flink 写入数据到 Kafka14、《从0到1学习Flink》—— Flink JobManager 高可用性配置15、《从0到1学习Flink》—— Flink parallelism 和 Slot 介绍16、《从0到1学习Flink》—— Flink 读取 Kafka 数据批量写入到 MySQL17、《从0到1学习Flink》—— Flink 读取 Kafka 数据写入到 RabbitMQ18、《从0到1学习Flink》—— 你上传的 jar 包藏到哪里去了? ...

March 19, 2019 · 1 min · jiezi