实时流处理Storm、Spark Streaming、Samza、Flink孰优孰劣

系统管理员 2022-05-23 23:04 253阅读 0赞

From http://www.dataguru.cn/article-9532-1.html

分布式流处理需求日益增加，包括支付交易、社交网络、物联网（IOT）、系统监控等。业界对流处理已经有几种适用的框架来解决，下面我们来比较各流处理框架的相同点以及区别。

分布式流处理是对无边界数据集进行连续不断的处理、聚合和分析。它跟MapReduce一样是一种通用计算，但我们期望延迟在毫秒或者秒级别。这类系统一般采用有向无环图（DAG）。

DAG是任务链的图形化表示，我们用它来描述流处理作业的拓扑。如下图，数据从sources流经处理任务链到sinks。单机可以运行DAG，但本篇文章主要聚焦在多台机器上运行DAG的情况。

[![212654bvvmazvwzpgkqndp.jpg][]][212654bvvmazvwzpgkqndp.jpg]

关注点

当选择不同的流处理系统时，有以下几点需要注意的：

**运行时和编程模型** ：平台框架提供的编程模型决定了许多特色功能，编程模型要足够处理各种应用场景。这是一个相当重要的点，后续会继续。

**函数式原语** ：流处理平台应该能提供丰富的功能函数，比如，map或者filter这类易扩展、处理单条信息的函数；处理多条信息的函数aggregation；跨数据流、不易扩展的操作join。

**状态管理** ：大部分应用都需要保持状态处理的逻辑。流处理平台应该提供存储、访问和更新状态信息。

**消息传输保障** ：消息传输保障一般有三种：at most once，at least once和exactly once。At most once的消息传输机制是每条消息传输零次或者一次，即消息可能会丢失；A t least once意味着每条消息会进行多次传输尝试，至少一次成功，即消息传输可能重复但不会丢失；Exactly once的消息传输机制是每条消息有且只有一次，即消息传输既不会丢失也不会重复。

**容错** ：流处理框架中的失败会发生在各个层次，比如，网络部分，磁盘崩溃或者节点宕机等。流处理框架应该具备从所有这种失败中恢复，并从上一个成功的状态（无脏数据）重新消费。

**性能** ：延迟时间（Latency），吞吐量（Throughput）和扩展性（Scalability）是流处理应用中极其重要的指标。

平台的成熟度和接受度：成熟的流处理框架可以提供潜在的支持，可用的库，甚至开发问答帮助。选择正确的平台会在这方面提供很大的帮助。

运行时和编程模型

运行时和编程模型是一个系统最重要的特质，因为它们定义了表达方式、可能的操作和将来的局限性。因此，运行时和编程模型决定了系统的能力和适用场景。

实现流处理系统有两种完全不同的方式：

第一种是称作 **原生流处理**

意味着所有输入的记录一旦到达即会一个接着一个进行处理。

[![212654vddn6d7ddck6add7.jpg][]][212654vddn6d7ddck6add7.jpg]

第二种称为 **微批处理** 。

把输入的数据按照某种预先定义的时间间隔（典型的是几秒钟）分成短小的批量数据，流经流处理系统。

[![212654xsga3wtgxfj3fp8j.jpg][]][212654xsga3wtgxfj3fp8j.jpg]

两种方法都有其先天的优势和不足。

**首先以原生流处理开始，原生流处理的优势在于它的表达方式。数据一旦到达立即处理，这些系统的延迟性远比其它微批处理要好。除了延迟性外，原生流处理的状态操作也容易实现**，后续将详细讲解。

**一般原生流处理系统为了达到低延迟和容错性会花费比较大的成本，因为它需要考虑每条记录。**

**原生流处理的负载均衡也是个问题。**比如，我们处理的数据按key分区，如果分区的某个key是资源密集型，那这个分区很容易成为作业的瓶颈。

接下来看下微批处理。

**将流式计算分解成一系列短小的批处理作业，也不可避免的减弱系统的表达力。**像状态管理或者join等操作的实现会变的困难，因为微批处理系统必须操作整个批量数据。并且，batch interval会连接两个不易连接的事情：基础属性和业务逻辑。

相反地， **微批处理系统的容错性和负载均衡实现起来非常简单**，因为微批处理系统仅发送每批数据到一个worker节点上，如果一些数据出错那就使用其它副本。微批处理系统很容易建立在原生流处理系统之上。

编程模型一般分为 **组合式** 和 **声明式** 。

组合式编程提供基本的构建模块，它们必须紧密结合来创建拓扑。新的组件经常以接口的方式完成。相对应地，声明式API操作是定义的高阶函数。它允许我们用抽象类型和方法来写函数代码，并且系统创建拓扑和优化拓扑。声明式API经常也提供更多高级的操作（比如，窗口函数或者状态管理）。后面很快会给出样例代码。

主流流处理系统

有一系列各种实现的流处理框架，不能一一列举，这里仅选出主流的流处理解决方案，并且支持Scala API。因此，我们将详细介绍Apache Storm，Trident，Spark Streaming，Samza和Apache Flink。前面选择讲述的虽然都是流处理系统，但它们实现的方法包含了各种不同的挑战。这里暂时不讲商业的系统，比如Google MillWheel或者Amazon Kinesis，也不会涉及很少使用的Intel GearPump或者Apache Apex。

[![212654bowqgf22erfv32rk.jpg][]][212654bowqgf22erfv32rk.jpg]

**Apache Storm**

最开始是由Nathan Marz和他的团队于2010年在数据分析公司BackType开发的，后来BackType公司被Twitter收购，接着Twitter开源Storm并在2014年成为Apache顶级项目。毋庸置疑，Storm成为大规模流数据处理的先锋，并逐渐成为工业标准。Storm是原生的流处理系统，提供low-level的API。Storm使用Thrift来定义topology和支持多语言协议，使得我们可以使用大部分编程语言开发，Scala自然包括在内。

**Trident**

它是对Storm的一个更高层次的抽象，Trident最大的特点以batch的形式进行流处理。Trident简化topology构建过程，增加了窗口操作、聚合操作或者状态管理等高级操作，这些在Storm中并不支持。相对应于Storm的At most once流传输机制，Trident提供了Exactly once传输机制。Trident支持Java，Clojure和Scala。

**Spark**

当前Spark是非常受欢迎的批处理框架，包含Spark SQL，MLlib和Spark Streaming。Spark的运行时是建立在批处理之上，因此后续加入的Spark Streaming也依赖于批处理，实现了微批处理。接收器把输入数据流分成短小批处理，并以类似Spark作业的方式处理微批处理。Spark Streaming提供高级声明式API（支持Scala，Java和Python）。

**Samza**

最开始是专为LinkedIn公司开发的流处理解决方案，并和LinkedIn的Kafka一起贡献给社区，现已成为基础设施的关键部分。Samza的构建严重依赖于基于log的Kafka，两者紧密耦合。Samza提供组合式API，当然也支持Scala。

**Apache Flink**

Flink是个相当早的项目，开始于2008年，但只在最近才得到注意。Flink是原生的流处理系统，提供high level的API。Flink也提供API来像Spark一样进行批处理，但两者处理的基础是完全不同的。Flink把批处理当作流处理中的一种特殊情况。在Flink中，所有的数据都看作流，是一种很好的抽象，因为这更接近于现实世界。

快速的介绍流处理系统之后，让我们以下面的表格来更好清晰的展示它们之间的不同：

[![212655p5qbpu85u8b3wppt.jpg][]][212655p5qbpu85u8b3wppt.jpg]

Word Count

Wordcount之于流处理框架学习，就好比hello world之于编程语言学习。它能很好的展示各流处理框架的不同之处，让我们从Storm开始看看如何实现Wordcount：

\[java\]  [view plain][]   [copy][view plain]

1.  TopologyBuilder builder = **new** TopologyBuilder();  
2.   builder.setSpout("spout", **new** RandomSentenceSpout(), 5);  
3.   builder.setBolt("split", **new** Split(), 8).shuffleGrouping("spout");  
4.   builder.setBolt("count", **new** WordCount(), 12).fieldsGrouping("split", **new** Fields("word"));  
5.   ...  
6.   Map counts = **new** HashMap();  
7.   **public** **void** execute(Tuple tuple, BasicOutputCollector collector) \{  
8.     String word = tuple.getString(0);  
9.     Integer count = counts.containsKey(word) ? counts.get(word) + 1 : 1;  
10.    counts.put(word, count);  
11.    collector.emit(**new** Values(word, count));  
12.  \}

首先，定义topology。第二行代码定义一个spout，作为数据源。然后是一个处理组件bolt，分割文本为单词。接着，定义另一个bolt来计算单词数（第四行代码）。也可以看到魔数5，8和12，这些是并行度，定义集群每个组件执行的独立线程数。第八行到十五行是实际的WordCount bolt实现。因为Storm不支持内建的状态管理，所有这里定义了一个局部状态。

按之前描述，Trident是对Storm的一个更高层次的抽象，Trident最大的特点以batch的形式进行流处理。除了其它优势，Trident提供了状态管理，这对wordcount实现非常有用。

\[java\]  [view plain][]   [copy][view plain]

1.  **public** **static** StormTopology buildTopology(LocalDRPC drpc) \{  
2.   FixedBatchSpout spout = ...  
3.   TridentTopology topology = **new** TridentTopology();  
4.   TridentState wordCounts = topology.newStream("spout1", spout)  
5.   .each(**new** Fields("sentence"),**new** Split(), **new** Fields("word"))  
6.   .groupBy(**new** Fields("word"))  
7.   .persistentAggregate(**new** MemoryMapState.Factory(),   
8.   **new** Count(), **new** Fields("count"));  
9.   ...  
10.  \}

如你所见，上面代码使用higher level操作，比如each（第七行代码）和groupby（第八行代码）。并且使用Trident管理状态来存储单词数（第九行代码）。

下面是时候祭出提供声明式API的Apache Spark。记住，相对于前面的例子，这些代码相当简单，几乎没有冗余代码。下面是简单的流式计算单词数：

\[java\]  [view plain][]   [copy][view plain]

1.  val conf = **new** SparkConf().setAppName("wordcount")  
2.  val ssc = **new** StreamingContext(conf, Seconds(1))  
3.  val text = ...  
4.  val counts = text.flatMap(line => line.split(" "))  
5.   .map(word => (word, 1))  
6.   .reduceByKey(\_ + \_)  
7.  counts.print()  
8.  ssc.start()  
9.  ssc.awaitTermination()

每个Spark Streaming的作业都要有StreamingContext，它是流式函数的入口。StreamingContext加载第一行代码定义的配置conf，但更重要地，第二行代码定义batch interval（这里设置为1秒）。第六行到八行代码是整个单词数计算。这些是标准的函数式代码，Spark定义topology并且分布式执行。第十二行代码是每个Spark Streaming作业最后的部分：启动计算。记住，Spark Streaming作业一旦启动即不可修改。

接下来看下Apache Samza，另外一个组合式API例子：

\[plain\]  [view plain][]   [copy][view plain]

1.  class WordCountTask extends StreamTask \{  
2.    override def process(envelope: IncomingMessageEnvelope, collector: MessageCollector,   
3.      coordinator: TaskCoordinator) \{  
4.      val text = envelope.getMessage.asInstanceOf\[String\]  
5.      val counts = text.split(" ").foldLeft(Map.empty\[String, Int\]) \{  
6.        (count, word) => count + (word -> (count.getOrElse(word, 0) + 1))  
7.      \}  
8.      collector.send(new OutgoingMessageEnvelope(new SystemStream("kafka", "wordcount"), counts))  
9.   \}

Samza的属性配置文件定义topology，为了简明这里并没把配置文件放上来。定义任务的输入和输出，并通过Kafka topic通信。在单词数计算整个topology是WordCountTask。在Samza中，实现特殊接口定义组件StreamTask，在第三行代码重写方法process。它的参数列表包含所有连接其它系统的需要。第八行到十行简单的Scala代码是计算本身。

Flink的API跟Spark Streaming是惊人的相似，但注意到代码里并未设置batch interval。

\[plain\]  [view plain][]   [copy][view plain]

1.  val env = ExecutionEnvironment.getExecutionEnvironment  
2.   val text = env.fromElements(...)  
3.   val counts = text.flatMap ( \_.split(" ") )  
4.     .map ( (\_, 1) )  
5.     .groupBy(0)  
6.     .sum(1)  
7.   counts.print()  
8.   env.execute("wordcount")

上面的代码是相当的直白，仅仅只是几个函数式调用，Flink支持分布式计算。

**容错性**

流处理系统的容错性与生俱来的比批处理系统难实现。当批处理系统中出现错误时，我们只需要把失败的部分简单重启即可；但对于流处理系统，出现错误就很难恢复。因为线上许多作业都是7 x 24小时运行，不断有输入的数据。流处理系统面临的另外一个挑战是状态一致性，因为重启后会出现重复数据，并且不是所有的状态操作是幂等的。容错性这么难实现，那下面我们看看各大主流流处理框架是如何处理这一问题。

Apache Storm：Storm使用上游数据备份和消息确认的机制来保障消息在失败之后会重新处理。消息确认原理：每个操作都会把前一次的操作处理消息的确认信息返回。Topology的数据源备份它生成的所有数据记录。当所有数据记录的处理确认信息收到，备份即会被安全拆除。失败后，如果不是所有的消息处理确认信息收到，那数据记录会被数据源数据替换。这保障了没有数据丢失，但数据结果会有重复，这就是at-least once传输机制。

Storm

采用取巧的办法完成了容错性，对每个源数据记录仅仅要求几个字节存储空间来跟踪确认消息。纯数据记录消息确认架构，尽管性能不错，但不能保证exactly once消息传输机制，所有应用开发者需要处理重复数据。Storm存在低吞吐量和流控问题，因为消息确认机制在反压下经常误认为失败。

[![212655k313551rrhqxzt7h.jpg][]][212655k313551rrhqxzt7h.jpg]

Spark Streaming：

Spark Streaming实现微批处理，容错机制的实现跟Storm不一样的方法。微批处理的想法相当简单。Spark在集群各worker节点上处理micro-batches。每个micro-batches一旦失败，重新计算就行。因为micro-batches本身的不可变性，并且每个micro-batches也会持久化，所以exactly once传输机制很容易实现。

[![212655mkfqmkimvrrpvo83.jpg][]][212655mkfqmkimvrrpvo83.jpg]

Samza：

Samza的实现方法跟前面两种流处理框架完全不一样。 **Samza利用消息系统Kafka的持久化和偏移量。**Samza监控任务的偏移量，当任务处理完消息，相应的偏移量被移除。消息的偏移量会被checkpoint到持久化存储中，并在失败时恢复。但是问题在于：从上次checkpoint中修复偏移量时并不知道上游消息已经被处理过，这就会造成重复。这就是at least once传输机制。

[![212655f39kimimhh39bhiz.jpg][]][212655f39kimimhh39bhiz.jpg]

Apache Flink：

Flink的容错机制是基于分布式快照实现的，这些快照会保存流处理作业的状态（本文对Flink的检查点和快照不进行区分，因为两者实际是同一个事物的两种不同叫法。Flink构建这些快照的机制可以被描述成分布式数据流的轻量级异步快照，它采用Chandy-Lamport算法实现。）。

如果发生失败的情况，系统可以从这些检查点进行恢复。Flink发送checkpoint的栅栏（barrier）到数据流中（栅栏是Flink的分布式快照机制中一个核心的元素），当checkpoint的栅栏到达其中一个operator，operator会接所有收输入流中对应的栅栏（比如，图中checkpoint n对应栅栏n到n-1的所有输入流，其仅仅是整个输入流的一部分）。

所以相对于Storm，Flink的容错机制更高效，因为Flink的操作是对小批量数据而不是每条数据记录。但也不要让自己糊涂了，Flink仍然是原生流处理框架，它与Spark Streaming在概念上就完全不同。Flink也提供exactly once消息传输机制。

[![212655u5bvppe41ztnplnz.jpg][]][212655u5bvppe41ztnplnz.jpg]

**状态管理**

大部分大型流处理应用都涉及到状态。相对于无状态的操作（其只有一个输入数据，处理过程和输出结果），有状态的应用会有一个输入数据和一个状态信息，然后处理过程，接着输出结果和修改状态信息。

因此，我们不得不管理状态信息，并持久化。我们期望一旦因某种原因失败，状态能够修复。状态修复有可能会出现小问题，它并不总是保证exactly once，有时也会出现消费多次，但这并不是我们想要的。

据我们所知，Storm提供at-least once的消息传输保障。那我们又该如何使用Trident做到exactly once的语义。概念上貌似挺简单，你只需要提交每条数据记录，但这显然不是那么高效。所以你会想到小批量的数据记录一起提交会优化。Trident定义了几个抽象来达到exactly once的语义，见下图，其中也会有些局限。

[![212655bshddudiejrdljjj.jpg][]][212655bshddudiejrdljjj.jpg]

Spark Streaming是微批处理系统，它把状态信息也看做是一种微批量数据流。在处理每个微批量数据时，Spark加载当前的状态信息，接着通过函数操作获得处理后的微批量数据结果并修改加载过的状态信息。

[![212656ywpwf3aotqe3i3ou.jpg][]][212656ywpwf3aotqe3i3ou.jpg]

Samza实现状态管理是通过Kafka来处理的。Samza有真实的状态操作，所以其任务会持有一个状态信息，并把状态改变的日志推送到Kafka。如果需要状态重建，可以很容易的从Kafka的topic重建。为了达到更快的状态管理，Samza也支持把状态信息放入本地key-value存储中，所以状态信息不必一直在Kafka中管理，见下图。不幸的是，Samza只提供at-least once语义，exactly once的支持也在计划中。

[![212656fxyuu3ed4hcgiz8d.jpg][]][212656fxyuu3ed4hcgiz8d.jpg]

Flink提供状态操作，和Samza类似。

Flink提供两种类型的状态：一种是用户自定义状态；另外一种是窗口状态。

如图，第一个状态是自定义状态，它和其它的的状态不相互作用。这些状态可以分区或者使用嵌入式Key-Value存储状态［文档一和二］。当然Flink提供exactly-once语义。下图展示Flink长期运行的三个状态。

[![212656m144hc02oyhmip3c.jpg][]][212656m144hc02oyhmip3c.jpg]

单词计数例子中的状态管理

单词计数的详细代码见上篇文章，这里仅关注状态管理部分。

让我们先看Trident：

public static StormTopology buildTopology(LocalDRPC drpc) \{

FixedBatchSpout spout = ...

TridentTopology topology = new TridentTopology();

TridentState wordCounts = topology.newStream("spout1", spout)

.each(new Fields("sentence"),new Split(), new Fields("word"))

.groupBy(new Fields("word"))

.persistentAggregate(new MemoryMapState.Factory(), new Count(), new Fields("count"));

...

在第九行代码中，我们通过调用persistentAggregate创建一个状态。其中参数Count存储单词数，如果你想从状态中处理数据，你必须创建一个数据流。从代码中也可以看出实现起来不方便。

Spark Streaming声明式的方法稍微好点：

// Initial RDD input to updateStateByKey

val initialRDD = ssc.sparkContext.parallelize(List.empty\[(String, Int)\])

val lines = ...

val words = lines.flatMap(\_.split(" "))

val wordDstream = words.map(x => (x, 1))

val trackStateFunc = (batchTime: Time, word: String, one: Option\[Int\],

state: State\[Int\]) => \{

val sum = one.getOrElse(0) + state.getOption.getOrElse(0)

val output = (word, sum)

state.update(sum)

Some(output)

val stateDstream = wordDstream.trackStateByKey(

StateSpec.function(trackStateFunc).initialState(initialRDD))

首先我们需要创建一个RDD来初始化状态（第二行代码），然后进行transformations（第五行和六行代码）。接着在第八行到十四行代码，我们定义函数来处理单词数状态。函数计算并更新状态，最后返回结果。第十六行和十七行代码，我们得到一个状态信息流，其中包含单词数。

接着我们看下Samza：

class WordCountTask extends StreamTask with InitableTask \{

private var store: CountStore = \_

def init(config: Config, context: TaskContext) \{

this.store = context.getStore("wordcount-store")

.asInstanceOf\[KeyValueStore\[String, Integer\]\]

override def process(envelope: IncomingMessageEnvelope,

collector: MessageCollector, coordinator: TaskCoordinator) \{

val words = envelope.getMessage.asInstanceOf\[String\].split(" ")

words.foreach \{ key =>

val count: Integer = Option(store.get(key)).getOrElse(0)

store.put(key, count + 1)

collector.send(new OutgoingMessageEnvelope(new SystemStream("kafka", "wordcount"),

(key, count)))

首先在第三行代码定义状态，进行Key-Value存储，在第五行到八行代码初始化状态。接着在计算中使用，上面的代码已经很直白。

最后，讲下Flink使用简洁的API实现状态管理：

val env = ExecutionEnvironment.getExecutionEnvironment

val text = env.fromElements(...)

val words = text.flatMap ( \_.split(" ") )

words.keyBy(x => x).mapWithState \{

(word, count: Option\[Int\]) =>

val newCount = count.getOrElse(0) + 1

val output = (word, newCount)

(output, Some(newCount))

我们仅仅需要在第六行代码中调用mapwithstate函数，它有一个函数参数（函数有两个变量，第一个是单词，第二个是状态。然后返回处理的结果和新的状态）。

**流处理框架性能**

这里所讲的性能主要涉及到的是延迟性和吞吐量。

对于延迟性来说，微批处理一般在秒级别，大部分原生流处理在百毫秒以下，调优的情况下Storm可以很轻松的达到十毫秒。

同时也要记住，消息传输机制保障，容错性和状态恢复都会占用机器资源。例如，打开容错恢复可能会降低10％到15％的性能，Storm可能降低70%的吞吐量。总之，天下没有免费的午餐。对于有状态管理，Flink会降低25%的性能，Spark Streaming降低50%的性能。

也要记住，各大流处理框架的所有操作都是分布式的，通过网络发送数据是相当耗时的，所以进了利用数据本地性，也尽量优化你的应用的序列化。

项目成熟度

当你为应用选型时一定会考虑项目的成熟度。下面来快速浏览一下：

Storm是第一个主流的流处理框架，后期已经成为长期的工业级的标准，并在像Twitter，Yahoo，Spotify等大公司使用。

Spark Streaming是最近最流行的Scala代码实现的流处理框架。现在Spark Streaming被公司（Netflix, Cisco, DataStax, Intel, IBM等）日渐接受。

Samza主要在LinkedIn公司使用。Flink是一个新兴的项目，很有前景。

你可能对项目的贡献者数量也感兴趣。Storm和Trident大概有180个代码贡献者；整个Spark有720多个；根据github显示，Samza有40个；Flink有超过130个代码贡献者。

流处理框架推荐

应用选型是大家都会遇到的问题，一般是根据应用具体的场景来选择特定的流处理框架。下面给出几个作者认为优先考虑的点：

High level API：具有high level API的流处理框架会更简洁和高效；

状态管理：大部分流处理应用都涉及到状态管理，因此你得把状态管理作为评价指标之一；

exactly once语义：exactly once会使得应用开发变得简单，但也要看具体需求，可能at least once 或者at most once语义就满足你得要求；

自动恢复：确保流处理系统能够快速恢复，你可以使用Chaos Monkey或者类似的工具进行测试。快速的恢复是流处理重要的部分。

**Storm：Storm非常适合任务量小但速度要求高的应用。** 如果你主要在意流处理框架的延迟性，Storm将可能是你的首先。但同时也要记住，Storm的容错恢复或者Trident的状态管理都会降低整体的性能水平。也有一个潜在的Storm更新项目-Twitter的Heron，Heron设计的初衷是为了替代Storm，并在每个单任务上做了优化但同时保留了API。

Spark Streaming：如果你得基础架构中已经设计到Spark，那Spark Streaming无疑是值得你尝试的。因为你可以很好的利用Spark各种library。如果你需要使用Lambda架构，Spark Streaming也是一个不错的选择。但你要时刻记住微批处理的局限性，以及它的延迟性问题。

Samza：如果你想使用Samza，那Kafka应该是你基础架构中的基石，好在现在Kafka已经成为家喻户晓的组件。像前面提到的，Samza一般会搭配强大的本地存储一起，这对管理大数据量的状态非常有益。它可以轻松处理上万千兆字节的状态信息，但要记住Samza只支持at least once语义。

Flink：Flink流处理系统的概念非常不错，并且满足绝大多数流处理场景，也经常提供前沿的功能函数，比如，高级窗口函数或者时间处理功能，这些在其它流处理框架中是没有的。同时Flink也有API提供给通用的批处理场景。但你需要足够的勇气去上线一个新兴的项目，并且你也不能忘了看下Flink的roadmap。

Dataflow和开源

最后，我们来聊下Dataflow和它的开源。Dataflow是Google云平台的一部分，Google云平台包含很多组件：大数据存储，BigQuery，Cloud PubSub，数据分析工具和前面提到的Dataflow。

Dataflow是Google管理批处理和流处理的统一API。它是建立在MapReduce（批处理），FlumeJava（编程模型）和MillWheel（流处理）之上。Google最近决定开源Dataflow SDK，并完成Spark和Flink的runner。现在可以通过Dataflow的API来定义Google云平台作业、Flink作业或者Spark作业，后续会增加对其它引擎的支持。

**Google为Dataflow提供Java、Python的API** ，社区已经完成Scalable的DSL支持。除此之外，Google及其合作者提交Apache Beam到Apache。

[![212656e6xrpms5dy6mkwwo.jpg][]][212656e6xrpms5dy6mkwwo.jpg]

结论

本系列文章粗略的讲述各大流行的流处理框架，并讨论了它们的相似性、区别、折衷权衡和使用的场景。希望这些将会给你设计流处理方案有帮助。

[212654bvvmazvwzpgkqndp.jpg]: /images/20220524/efec6de698764869b0c019ca8dda055f.png
[212654vddn6d7ddck6add7.jpg]: /images/20220524/9d6937b12d3c4131a3928883d57697f3.png
[212654xsga3wtgxfj3fp8j.jpg]: /images/20220524/b211a37d79c04242b87d1774c667962c.png
[212654bowqgf22erfv32rk.jpg]: /images/20220524/ed4dbf33bb3d48229eed98bacd6c7c0c.png
[212655p5qbpu85u8b3wppt.jpg]: /images/20220524/7a0119b9638c4034b39531e236332566.png
[view plain]: https://blog.csdn.net/justlpf/article/details/80292581#
[212655k313551rrhqxzt7h.jpg]: /images/20220524/6455b67060984bbfb6c4b3b0c1ebf6ea.png
[212655mkfqmkimvrrpvo83.jpg]: /images/20220524/d9bb3465124145ce83cb759c7ae5a72f.png
[212655f39kimimhh39bhiz.jpg]: /images/20220524/02261fffdfae4fb5a786c46393edbd69.png
[212655u5bvppe41ztnplnz.jpg]: /images/20220524/6f6a76c9c33448b78ea13c6700ee05cd.png
[212655bshddudiejrdljjj.jpg]: /images/20220524/97b39017aa7a40dea1feeaefc4f6a019.png
[212656ywpwf3aotqe3i3ou.jpg]: /images/20220524/f93153efb0144862b7e4b62bd727ad5e.png
[212656fxyuu3ed4hcgiz8d.jpg]: /images/20220524/7fff37050a4844ed84e44aadd2db8504.png
[212656m144hc02oyhmip3c.jpg]: /images/20220524/4149f877591a4434aa96fae652e45520.png
[212656e6xrpms5dy6mkwwo.jpg]: /images/20220524/941e56e6fac042cc9e103bb3368d4179.png