Storm架构和编程模型总结

1、编程模型 DataSource：外部数据源 Spout：接受外部数据源的组件，将外部数据源转化成Storm内部的数据，以Tuple为基本的传输单元下发给Bolt Bolt:接受Spout发送的数据，或上游的bolt的发送的数据。根据业务逻辑进行处理。发送给下一个Bolt或者是存储到某种介质上。介质可以是Redis可以是mysql，或者其他。 Tuple：Storm内部中数据传输的基本单元，里面封装了一个List对象，用来保存数据。 StreamGrouping:数据分组策略 7种：shuffleGrouping(Random函数),Non Grouping(Random函数),FieldGrouping(Hash取模)、Local or ShuffleGrouping 本地或随机，优先本地。

2、并发度用户指定的一个任务，可以被多个线程执行，并发度的数量等于线程的数量。一个任务的多个线程，会被运行在多个Worker（JVM）上，有一种类似于平均算法的负载均衡策略。尽可能减少网络IO，和Hadoop中的MapReduce中的本地计算的道理一样。

3、架构 Nimbus：任务分配 Supervisor：接受任务，并启动worker。worker的数量根据端口号来的。 Worker:执行任务的具体组件（其实就是一个JVM）,可以执行两种类型的任务，Spout任务或者bolt任务。 Task：Task=线程=executor。一个Task属于一个Spout或者Bolt并发任务。 Zookeeper：保存任务分配的信息、心跳信息、元数据信息。

4、Worker与topology 一个worker只属于一个topology,每个worker中运行的task只能属于这个topology。反之，一个topology包含多个worker，其实就是这个topology运行在多个worker上。一个topology要求的worker数量如果不被满足，集群在任务分配时，根据现有的worker先运行topology。如果当前集群中worker数量为0，那么最新提交的topology将只会被标识active，不会运行，只有当集群有了空闲资源之后，才会被运行。

5、如何指定驱动类中每个组件的并发度数量？如何设置worker的数量？
1，根据上游的数据量来设置Spout的并发度。
2，根据业务复杂度和execute方法执行时间来设置Bolt并发度。
3，根据集群的可用资源来配置，一般情况下70%的资源使用率。
4，Worker的数量理论上根据程序并发度总的Task数量来均分，在实际的业务场景中，需要反复调整。

6、Ack-fail机制

1，需要ack-fail时，请为每个tuple生成一个messageID,这个messagetId是用来标识你关心的tuple。当这个tuple被完全处理时，storm框架会调用Spout的ack方法，否则调用fail。至于你的消息是否重发，完全由自己处理。

MySpout{
        private Map buffer = new HashMap();
        spout.open()
        spout.nextTuple(){

            collector.emit()
            buffer.put(msgId,messValue)

        }
        spout.outputFields()

        spout.ack(msgId){

        //消息移除
        buffer.remove(msgId);

        }
        spout.fail(msgId){
        //消息重发
         String messValue = buffer.get(msgId)
         collector.emit();
        }
    }

    MyBolt{

        bolt.execute(){
        //先判断消息是否被处理过
        // 在redis或mysql中保存一个处理过的消息列表    
        //需要手动的调用ack方法
        collector.ack(tuple)
        }
    }

2，在Spout有并发度的情况下，storm会根据tuple最开始的所属的spout taskId，通知相应的spoutTask。

3、在流式计算中topology的bolt组件是可以配置多个的，在每个环节中，都需要bolt组件显式告诉storm框架，自己对当前接受的这个tuple处理完成。

<spoutTaskId,<RootID,ackaValue=0>>
        spout1----->tuple1(msgId,rootId)-----bolt1-----collector.ack(tuple)
                               bolt1-----tuple1-1----->bolt2------ack(tuple1-1)
                               bolt1-----tuple1-2----->bolt2------ack(tuple1-2)
                               bolt1-----tuple1-3----->bolt2------ack(tuple1-3)
                               bolt1-----tuple1-4----->bolt2------ack(tuple1-4)
                                                       bolt2-----tuple2-1----->bolt3------ack(tuple2-1)
                                                       bolt2-----tuple2-2----->bolt3------ack(tuple2-2)
                                                       bolt2-----tuple2-3----->bolt3------ack(tuple2-3)
                                                       bolt2-----tuple2-4----->bolt3------ack(tuple2-4)

4、ack机制里面，发送两种类型的tuple。一种是原始消息(DataTuple)，另外一种是 ackTuple

spout.emit(DataTuple(MessageId(ackTuple)))------->bolt1.execute(dataTuple)---->collector.ack(dataTuple)
                        ackTuple--------------------->Acker.execute(tuple)
                                                                                  dataTuple--->MessageId--->ackTuple
                                                                                        Acker.execute(tuple)

Storm架构和编程模型总结

猜你喜欢