Storm入门和基础性能测试

spout: 管理数据输入流

bolt: 把数据保存到存储器，或者传给另一个bolt

一个Storm集群就是在一连串的bolt之间转换spout传过来的数据。

storm入门：
http://www.cnblogs.com/quchunhui/p/5370191.html


tuple 介绍：
http://blog.csdn.net/wmzzu/article/details/40213001


storm程序解释：
https://book.douban.com/reading/33008852/

一、Storm中运行的组件

     我们知道，Storm的强大之处就是可以很容易地在集群中横向拓展它的计算能力，它会把整个运算过程分割成多个独立的tasks在集群中进行并行计算。在Storm中，一个task就是运行在集群中的一个Spout或Bolt实例。

     为了方便理解Storm如何并行处理我们分给它的任务,这里我先介绍一下在集群中涉及到Topology的四种组件：

• Nodes(machines):集群中的节点，就是这些节点一起工作来执行Topology。
• Workers(JVMs):一个worker就是一个独立的JVM进程。每个节点都可以通过配置运行一个或多个workers，一个Topology可以指定由多少个workers来执行。     
• Executors(threads):一个worker JVM中运行的线程。一个worker进程可以执行一个或多个executor线程。一个Executor可以运行多个tasks，Storm默认一个每个executor分配一个task。
• Tasks(bolt/spout实例)：Tasks就是spouts和bolts的实例，它具体是被executor线程处理的。

二、Storm中的并行（以WordCountTopology为例）

     我们可以通过配置来调整我们work的并行数量，如果我们不进行设置，Storm默认大部分过程的并行数量为1。假设我们对WordCountTopology不单独进行配置，那么我们的Topology执行情况如下图所示：

     我们的一个节点会为我们的Topology分配一个worker，这个worker会为每个Task启动一个Executor线程。

2.1 为Topology增加workers

     一种最简单的提高Topology运算能力的途径就是为我们的Topology增加workers。Storm为我们提供了两种途径来增加workers:通过配置文件或通过程序设置。

• 描述：在集群中为topology创建多少个工作进程
• 配置选项： TOPOLOGY_WORKERS 
• 在代码中配置：
• • Config#setNumWorkers

     通过Config对象来配置workers:

          Config config = new Config();

     config.setNumWorkers(2);

注意：在LocalMode下不管设置几个workers，最终都只有一个worker JVM进程。

2.2 配置executors和tasks

     前面我们已经说过，Storm会为每个Topology组件创建一个task，而默认一个executor只处理一个task。task是spouts和bolts的实例，一个executor线程可由处理多个tasks，tasks是真正处理具体数据的一个过程，我们在代码中写的spout和bolt可以看做是由集群中分布的tasks来执行的。Task的数量在整个topology运行期间一般是不变的，但是组件的Executors是有可能发生变化的。这也就意味着：threads<=tasks。

2.2.1 设置executor（thread）数量

     通过设置parallelism hint来指定一个组件的executors。

• 描述：每个组件产生多少个Executor
• 配置选项：？
• 在代码中配置：
  • TopologyBuilder#setSpout()
  • TopologyBuilder#setBolt()
  • Note that as of Storm 0.8 the parallelism_hint parameter now specifies the initial number of executors (not tasks!) for that bolt.     

     下面我们指定SentenseSpout的并行数量为2，则这个Spout组件会有两个executors，每个executor分配一个task，其Topology的运行情况如下图所示：

     builder.setSpout(SENTENCE_SPOUT_ID, spout, 2);

2.2.2 设置task的数量

     通过setNumTasks()方法来指定一个组件的tasks数量。

• 描述：每个组件创建多少个task
• 配置选项： TOPOLOGY_TASKS
• 在代码中配置：
• • ComponentConfigurationDeclarer#setNumTasks()   

     下面我们为SplitSentenceBolt 设置4个tasks和2个executors，这样的话每个executor线程将被分配执行4/2=2个tasks，然后再为WordCountBolt分配4个task，每个task由一个executor负责执行。其Topology如下图所示：

     builder.setBolt(SPLIT_BOLT_ID, splitBolt, 2).setNumTasks(4).shuffleGrouping(SENTENCE_SPOUT_ID);

     builder.setBolt(COUNT_BOLT_ID, countBolt, 4).fieldsGrouping(SPLIT_BOLT_ID, newFields("word"));

   如果一开始分配2个workers,则Topology的运行情况如下图所示：

 

三、一个topology的例子

     下面这幅图展示了一个实际topology的全景，topology由三个组件组成，一个Spout：BlueSpout，两个Bolt：GreenBolt、YellowBolt。

     如上图，我们配置了两个worker进程，两个Spout线程，两个GreenBolt线程和六个YellowBolt线程，那么分布到集群中的话，每个工作进程都会有5个executor线程。下面看一下具体代码：

     java Config conf = new Config();

     conf.setNumWorkers(2); // use two worker processes

     topologyBuilder.setSpout(“blue-spout”, new BlueSpout(), 2); // set parallelism hint to 2

     topologyBuilder.setBolt(“green-bolt”, new GreenBolt(), 2) .setNumTasks(4) .shuffleGrouping(“blue-spout”);

     topologyBuilder.setBolt(“yellow-bolt”, new YellowBolt(), 6) .shuffleGrouping(“green-bolt”);

     StormSubmitter.submitTopology( “mytopology”, conf, topologyBuilder.createTopology() );

     当然，Storm中也有一个参数来控制topology的并行数量：

• TOPOLOGY_MAX_TASK_PARALLELISM: 这个参数可以控制一个组件上Executor的最大数量。它通常用来在本地模式测试topology的最大线程数量。当然我们也可以在代码中设置： Config#setMaxTaskParallelism().      

四、如何改变一个运行topology中的Parallelism

     Storm中一个很好的特性就是可以在topology运行期间动态调制worker进程或Executor线程的数量而不需要重启topology。这种机制被称作rebalancing。

     我们有两种方式来均衡一个topology：

1. 通过Storm web UI来均衡
2. 通过CLI tool storm 来均衡  

     下面就是一个CLI tool应用的例子：

 # Reconfigure the topology “mytopology” to use 5 worker processes, # the spout “blue-spout” to use 3 executors and # the bolt      “yellow-bolt” to use 10 executors.

     $ storm rebalance mytopology -n 5 -e blue-spout=3 -e yellow-bolt=10 

在命令行动态修改并行度
除了使用代码进行调整，还可以在shell命令行下对并行度进行调整。
storm rebalance wt -w 10 -n 2 -e spout=2 -e bolt=2
表示 10秒之后对mytopology进行并行度调整。把spout调整为2个executor，把bolt调整为2个executor
注意：并行度主要就是调整executor的数量，但是调整之后的executor的数量必须小于等于task的数量，如果分配的executor的线程数比task数量多的话也只能分配和task数量相等的executor。.
-w  几秒后   -n  几个worker  -e 几个executer 

eclipse配好linux java版本后，然后 将storm下的lib下的所有包（除了slf4j-log4j12-1.7.6.jar，他会和log4j包产生冲突），全部下载下来，然后作为eclipse的导入依赖包，最后还会有一些额外的包需要下载，这时可以直接看日志，搜索报错就成，额外的包，可以用maven新建一个工程，下载kafka，storm，zk，然后.m2文件夹里面找，直接用eclipse创建maven工程，老是出现slf4j-log4j12-1.7.6.jar和log4j包冲突错误，且eclipse打jar包我删除不了slf4j-log4j12-1.7.6.jar，所以只能这样解决，最后不要忘了，把集群上storm下的lib下的slf4j-log4j12-1.7.6.jar也给 放到其他目录下，好比新建bak目录，要不会引发jar包冲突，然后这样昨晚，storm自身测试代码，和storm+kafka测试代码，都能跑起来。

storm测试代码：

import backtype.storm.Config;
import backtype.storm.StormSubmitter;
import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.BasicOutputCollector;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.topology.base.BaseBasicBolt;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
import java.util.Map;
import java.util.Random;


public class ThroughputTest {
int timeCount;

double start = System.currentTimeMillis() * 1.0 / 1000;
   
 public static class GenSpout extends BaseRichSpout {
        private static final Character[] CHARS = new Character[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};


        SpoutOutputCollector _collector;
        int _size;
        Random _rand;
        String _id;
        String _val;

 
public GenSpout() {
          
        }

  public GenSpout(int size) {
            _size = size;
        }

        @Override
        public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
            _collector = collector;
            _rand = new Random();
            _id = randString(5);
            _val = randString(_size);
        }


        @Override
        public void nextTuple() {
            _collector.emit(new Values(_id, _val));

        }


        private String randString(int size) {
            StringBuffer buf = new StringBuffer();
            for(int i=0; i<size; i++) {
                buf.append(CHARS[_rand.nextInt(CHARS.length)]);
            }
            return buf.toString();
        }


        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            declarer.declare(new Fields("id", "item"));
        }

public long timestart(){
long start = System.currentTimeMillis();
}
    }


    public static class IdentityBolt extends BaseBasicBolt {
        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            declarer.declare(new Fields("id", "item"));
        }


        @Override
        public void execute(Tuple tuple, BasicOutputCollector collector) {
            collector.emit(tuple.getValues());
        }
    }


    public static class CountBolt extends BaseBasicBolt {
        int _count;


        @Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
            declarer.declare(new Fields("count"));
        }


        @Override
        public void execute(Tuple tuple, BasicOutputCollector collector) {
            _count+=1;
            collector.emit(new Values(_count));
        }
    }


    public static class AckBolt extends BaseBasicBolt {

@Override
        public void declareOutputFields(OutputFieldsDeclarer declarer) {
        }


        @Override
        public void execute(Tuple tuple, BasicOutputCollector collector) {

}
    }

public static class TimeCount{

public static TimeCount  (double gs,ThroughputTest  t){
double start = gs;
while(true){
double end = System.currentTimeMillis() * 1.0 / 1000;

if((end - timestart) % 1 == 0){
System.out.println("每秒的数据处理条数为：" + timeCount)
break;
}
}
}
}
    //storm jar storm-benchmark-0.0.1-SNAPSHOT-standalone.jar storm.benchmark.ThroughputTest demo 100 8 8 8 10000
    public static void main(String[] args) throws Exception {
        int size = Integer.parseInt(args[1]);
        int workers = Integer.parseInt(args[2]);
        int spout = Integer.parseInt(args[3]);
        int bolt = Integer.parseInt(args[4]);
        int maxPending = Integer.parseInt(args[5]);


        TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("spout", new GenSpout(size), spout);
//        builder.setBolt("count", new CountBolt(), bolt)
//                .fieldsGrouping("bolt", new Fields("id"));
//        builder.setBolt("bolt", new IdentityBolt(), bolt)
//                .shuffleGrouping("spout");
        builder.setBolt("bolt2", new AckBolt(), bolt)
               .shuffleGrouping("spout");
//        builder.setBolt("count2", new CountBolt(), bolt)
//                .fieldsGrouping("bolt2", new Fields("id"));


        Config conf = new Config();
        conf.setNumWorkers(workers);
        //conf.setMaxSpoutPending(maxPending);
        conf.setNumAckers(0);
        conf.setStatsSampleRate(0.0001);
        //topology.executor.receive.buffer.size: 8192 #batched
        //topology.executor.send.buffer.size: 8192 #individual messages
        //topology.transfer.buffer.size: 1024 # batched


        //conf.put("topology.executor.send.buffer.size", 1024);
        //conf.put("topology.transfer.buffer.size", 8);
        //conf.put("topology.receiver.buffer.size", 8);
        //conf.put(Config.TOPOLOGY_WORKER_CHILDOPTS, "-Xdebug -Xrunjdwp:transport=dt_socket,address=1%ID%,server=y,suspend=n");


double s = new ThroughputTest().start;
ThroughputTest t = new ThroughputTest();
TimeCount tc = new TimeCount(s,t);
        StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
    }
}


注意： 这个测试代码没有 bolt处理，bolt就是接收一下数据，不处理也不转发，所以测试的时候网络io和cpu会出现 机器间不均衡的现象，可以自己手动价格bolt处理试试。
633 20cpu
666 40cpu
699 60cpu
61212 70cpu
61818  78cpu
62424 84cpu

pkts_out=2.85 
bytes_in Number of bytes in per second 
每秒出去字节数 

bytes_in=769.35 
bytes_out Number of bytes out per second 
每秒进来节数 

tps：每秒钟物理设备的 I/O 传输总量