Storm学习教程

Posted 2022-10-29 sunsfan

在这个教程中, 你将学到如何创建一个Storm topologies以及怎样把它部署到storm集群上。本教程中，Java将作为主要使用的语言，但在一小部分示例中将会使用Python来阐述storm处理多语言的能力。

预备工作

本教程使用的例子来自于 storm-starter 项目. 我们建议你拷贝该项目并跟随这个例子来进行学习。 请阅读 Setting up a development environment 和 Creating a new Storm project 创建好相应的基础环境。

Storm集群的组件

Storm集群在表面上与Hadoop集群相似。在Hadoop上运行"MapReduce jobs"，而在Storm上运行的是"topologies"。 "Jobs" and "topologies" 它们本身非常的不同 -- 一个关键的不同的是MapReduce job最终会完成并结束，而topology的消息处理将无限期进行下去（除非你kill它）。

在storm集群中，有两类节点。Master节点运行守护进程称为"Nimbus"，它有点像 Hadoop 的 "JobTracker"。Nimbus负责集群的代码分发，任务分配，故障监控。

每个工作节点运行的守护进程称为"Supervisor"。Supervisor 负责监听分配到它自己机器的作业，根据需要启动和停止相应的工作进程，当然这些工作进程也是Nimbus分派给它的。每个工作进程执行topology的一个子集；一个运行的topology是由分布在多个机器的多个工作进程组成的。

Nimbus 与 Supervisors 所有的协调工作是由 Zookeeper 集群完成的. 此外，Nimbus 守护进程 和 Supervisor 守护进程 是无状态的，快速失败的机制。 所有的状态保存在Zookeeper上或者本地磁盘中。这就是说，你用kill -9杀掉Nimbus 或者Supervisors，它们重新启动后就像什么都没有发生一样，这样的设计让storm集群拥有令人难以置信的稳定性。

Topologies

在Storm上进行实时计算，你需要创建名为 "topologies" 的这么个东西。一个topology是一个计算的图，每个在topology中的节点（以下部分也称作“组件”）包含了处理逻辑，以及多个节点间数据传送的联系和方式。运行一个topology很直接简单的。第一，你把你的java code和它所有的依赖打成一个单独的jar包。然后，你用如下的命令去运行就可以了。

storm jar all-my-code.jar org.apache.storm.MyTopology arg1 arg2

这个例子中运行的类是 org.apache.storm.MyTopology 且带着两个参数 arg1 和 arg2. 这个类的主要功能是定义topology，并被提交到Nimbus中。命令 storm jar 就是用来加载这个topology jar的。

因为topology的定义方式就是Thrift的结构，Nimbus也是一个Thrift服务，所以你可以用任何语言去创建topologies并提交。以上的例子是最简单的方式去使用基于JVM的语言（比如java）创建的topology。请阅读 Running topologies on a production cluster 来获得更多的信息关于topology的启动和停止。

流

Storm里的核心抽象就是 "流"。流 是一个无界的 元组序列。Storm提供原始地、分布式地、可靠地方式 把一个流转变成一个新的流。举例来说，

你可以把一个 tweet 流 转换成一个 趋势主题 的流。 

Storm中提供 流转换 的最主要的原生方式是 "spouts" and "bolts"。Spouts 和 bolts 有相应的接口，你需要用你的应用的特定逻辑实现接口即可。

Spout是 流 的源头。举例来说，一个spout也许会从 Kestrel 队列中读取数据并以流的方式发射出来，亦或者一个spout也许会连接Twitter的API,

并发出一个关于tweets的流。

一个bolt可以消费任意数量的输入流，并做一些处理，也可以由此发出一个新的流。复杂流的转换，像从一个tweet流中计算出一个关于趋势话题的流，它要求多个步骤，因此也需要多个bolt。Bolts 能做任何事情，运行方法，过滤元组，做流的聚合，流的连接，写入数据库等。 

Spouts 和 bolts 组成的网络 打包到 "topology" 中，它是顶级的抽象，是你需要提交到storm集群执行的东西。一个topology是一个由spout和bolt组成的 做流转换 的图，其中图中的每个节点都可以是一个spout或者一个bolt。图中的边表明了bolt订阅了哪些流，亦或是当一个spout或者bolt发射元组到流中，它发出的元组数据到订阅这个流的所有bolt中去。

topology中节点之间的联系表明了元组数据是怎样去传送的。举例来说，Spout A 和 Bolt B 相连（A 到 B），Spout A 和 Bolt C 相连(A 到 C)，Bolt B 和 Bolt C相连(B 到 C)。每当Spout A发出元组数据时，它会同时发给Bolt B 和 Bolt C。再者，所有Bolt B的输出元组，也会发给Bolt C。

在topology中的每个节点都是并行运行的。因此在你的topology中，你可以为每个节点指定并行运行的数量，然后storm集群将会产生相应数量的线程来执行。

一个topology无限运行，直到你杀掉它才会停止。Storm将自动地重新分配失败过的任务。此外，Storm保证不会有数据丢失，即便是机器挂掉，消息被丢弃。

数据模型

Storm用元组作为它的数据模型。一个元组是一个命名的，有值的，一般由过个字段组成的序列，序列中的每个字段可以是任何类型的对象。在沙箱之外，Storm提供所有的原始类型，字符串，byte数组作为元组的字段值。如果想用一个其他类型的对象，你需要实现a serializer 接口。

每个topology节点必须声明输出元组的字段。举例来说，这个bolt声明它将输出带有"double" and "triple"两个字段的元组：

public class DoubleAndTripleBolt extends BaseRichBolt 
    private OutputCollectorBase _collector;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollectorBase collector) 
        _collector = collector;
    

    @Override
    public void execute(Tuple input) 
        int val = input.getInteger(0);        
        _collector.emit(input, new Values(val*2, val*3));
        _collector.ack(input);
    

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) 
        declarer.declare(new Fields("double", "triple"));
        

 declareOutputFields 方法声明了该bolt的输出的字段 ["double", "triple"] .这个bolt的剩余部分将在接下来进行说明。

一个简单topology

让我们去看一个简单的 topology，去探索更多的概念，去看一下它的代码到底长什么样。让我们看一下 ExclamationTopology 的定义，来自storm-starter的项目:

TopologyBuilder builder = new TopologyBuilder();        
builder.setSpout("words", new TestWordSpout(), 10);        
builder.setBolt("exclaim1", new ExclamationBolt(), 3)
        .shuffleGrouping("words");
builder.setBolt("exclaim2", new ExclamationBolt(), 2)
        .shuffleGrouping("exclaim1");

这个topology包含了一个spout和两个bolt，这个spout发出words，然后每个bolt都在自己的读入字符串上加上"!!!"。

这些节点被安排成一条线：spout发给第一个bolt，第一个bolt发给第二个bolt。如果spout发出的元组数据是["bob"] 和 ["john"]，通过第二个

bolt后，将发出["bob!!!!!!"] 和 ["john!!!!!!"]。

代码中用 setSpout 和 setBolt 方法定义了节点。这些方法的输入是 一个用户指定的id，包含处理逻辑的对象，你希望该节点并行计算的数量。在这个例子中，这个 spout 的id是 "words" ，两个bolt的id分别为 "exclaim1" 和 "exclaim2"。

包含处理逻辑的spout对象实现了 IRichSpout 接口，bolt对象实现了 IRichBolt 接口。

最后一个参数，是你希望该节点并行计算的数量是多少，这是可选的。它表明了会有多少线程会通过storm集群来执行这个组件（spout或bolt）。

如果你忽略它，Storm集群会分配单线程给该节点。

setBolt 返回一个 InputDeclarer 对象,它用来定义bolt的输入。在这里，bolt "exclaim1" 声明了它希望通过shuffle分组的方式读取 spout "words"中的所有元组。同理，Bolt "exclaim2" 声明了它希望通过shuffle分组的方式读取 bolt "exclaim1" 所发出的元组数据。

"shuffle 分组" 指元组数据 将会 随机分布地 从输入任务 到bolt任务中。在多个组件（spout或bolt）之间，这里有很多数据分组的方式。

这在接下来的章节中会说明。

如果你希望bolt "exclaim2" 从 spout "words" 和 bolt "exclaim1" 读取所有的元组数据，你需要像下面这样定义：

builder.setBolt("exclaim2", new ExclamationBolt(), 5)
            .shuffleGrouping("words")
            .shuffleGrouping("exclaim1");

如你所见，输入的定义可以是链式的，bolt可以指定多个源。

让我们深入了解一下spout和bolt在topology中的实现。Spout负责发送新的数据到topology中。 TestWordSpout 在topology中每隔 100ms 发送了一个随机的单词，单词来自列表["nathan", "mike", "jackson", "golda", "bertels"]。在 TestWordSpout 中的 nextTuple() 的实现细节如下:

public void nextTuple() 
    Utils.sleep(100);
    final String[] words = new String[] "nathan", "mike", "jackson", "golda", "bertels";
    final Random rand = new Random();
    final String word = words[rand.nextInt(words.length)];
    _collector.emit(new Values(word));

如你所见，这个实现非常简单明了。

ExclamationBolt 给输入的字符串追加上 "!!!" 。 让我们看一下 ExclamationBolt 的完整实现吧：

public static class ExclamationBolt implements IRichBolt 
    OutputCollector _collector;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) 
        _collector = collector;
    

    @Override
    public void execute(Tuple tuple) 
        _collector.emit(tuple, new Values(tuple.getString(0) + "!!!"));
        _collector.ack(tuple);
    

    @Override
    public void cleanup() 
    

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) 
        declarer.declare(new Fields("word"));
    

    @Override
    public Map<String, Object> getComponentConfiguration() 
        return null;
    

prepare 方法提供了一个 OutputCollector 对象，它用来发出元组数据给下游节点。元组数据可以在任意时间从bolt发出 -- 可以在 prepare,execute, 或者 cleanup 方法,或者 在另一个线程，异步地发送。 这里的 prepare 实现很简单，初始化并保存了 OutputCollector 的引用，该引用将在接下来的execute 方法中使用。

execute 方法从该bolt的输入中接收一个元组数据， ExclamationBolt 对象提取元组中的第一个字段，并追加字符串 "!!!" 。如果你实现的bolt订阅了多个输入源，你可以用 Tuple 中的 Tuple#getSourceComponent 方法来获取你当前读取的这个元组数据来自于哪个源。

在 execute 方法中，还有一点东西需要说明。 即输入的元组作为第一个参数 发出 ，然后在最后一行中发出确认消息。这是Storm保证可靠性的API的一部分，它保证数据不会丢失，这在之后的教程会说明。

当一个Bolt将要停止、关闭时，它需要关闭当前打开的资源，此时 cleanup 方法可以被调用。 需要注意的是，这并不保证这个方法在storm集群中一定会被调用：举例来说，如果机器上的任务爆发，这就不会调用这个方法。 cleanup 方法打算用于，当你在 local mode 上运行你的topology(模拟storm集群的仿真模式), 你能够启动和停止很多topology且不会遭受任何资源泄露的问题。

declareOutputFields 方法声明 ExclamationBolt 发出一个名称为 "word" 的带一个字段的元组。

getComponentConfiguration 方法允许你从很多方面配置这个组件怎样去运行。更多高级的话题，深入的解释，请参见 Configuration.

通常像 cleanup 和 getComponentConfiguration 方法，在bolt中并不是必须去实现的。你可以用一个更为简洁的方式，通过使用一个提供默认实现的基本类去定义bolt，这也许更为合适一些。 ExclamationBolt 可以通过继承 BaseRichBolt,这会更简单一点，就像这样:

public static class ExclamationBolt extends BaseRichBolt 
    OutputCollector _collector;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) 
        _collector = collector;
    

    @Override
    public void execute(Tuple tuple) 
        _collector.emit(tuple, new Values(tuple.getString(0) + "!!!"));
        _collector.ack(tuple);
    

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) 
        declarer.declare(new Fields("word"));
        

在local mode上运行ExclamationTopology

让我们来看一下如何在本地模式上运行 ExclamationTopology ，看到它工作起来。

Storm有两种操作模式：本地模式和分布式模式。在本地模式中，Storm通过线程模拟工作节点并在一个进程中完成执行。本地模式在用于开发和测试topology时是很有用处的。当你在本地模式中运行 storm-starter 项目中的 topology 时，你就能看到每个组件发送了什么信息。你可以获取更多关于在本地模式上运行topology的信息，请参见 Local mode。

在分布式模式中，Storm操作的是机器集群。当你提交一个topology给master，你也需要提交运行这个topology所必须的代码。Master将会关注于分发你的代码并分配worker去运行你的topology。如果worker挂掉，master将会重新分配这些代码、topology到其他地方。你可以获取更多关于在分布式模式上运行topology的信息，请参见 Running topologies on a production cluster。

这是在本地模式上运行 ExclamationTopology 的代码:

Config conf = new Config();
conf.setDebug(true);
conf.setNumWorkers(2);

LocalCluster cluster = new LocalCluster();
cluster.submitTopology("test", conf, builder.createTopology());
Utils.sleep(10000);
cluster.killTopology("test");
cluster.shutdown();

首先，代码中定义了单进程的伪集群，通过创建 LocalCluster 对象实现。提交topology到虚拟集群，和提交topology到真正的分布式集群是相同的。提交topology使用[转]hadoop,spark,storm,pig,hive,mahout等到底有什么区别和联系？

storm学习笔记

Storm学习：Storm简介

Storm学习教程

Storm学习教程

Storm 入门教程