Storm日志分析调研及其实时架构

1.Storm第一个Demo

2.Windows下基于eclipse的Storm应用开发与调试

3.Storm实例+mysql数据库保存

4.Storm原理介绍

5. flume+kafka+storm+mysql 实时架构

1.Storm第一个Demo

　　Storm运行模式：

1. 本地模式(Local Mode)： 即Topology（相当于一个任务，后续会详细讲解）  运行在本地机器的单一JVM上，这个模式主要用来开发、调试。
2. 远程模式(Remote Mode):在这个模式，我们把我们的Topology提交到集群，在这个模式中，Storm的所有组件都是线程安全的，因为它们都会运行在不同的Jvm或物理机器上，这个模式就是正式的生产模式。

　　写一个HelloWord Storm

     我们现在创建这么一个应用，统计文本文件中的单词个数，详细学习过Hadoop的朋友都应该写过。那么我们需要具体创建这样一个Topology，用一个spout负责读取文本文件，用第一个bolt来解析成单词，用第二个bolt来对解析出的单词计数，整体结构如图所示：

可以从这里下载源码：https://github.com/storm-book/examples-ch02-getting_started/zipball/master

  写一个可运行的Demo很简单，我们只需要三步：

1. 创建一个Spout读取数据
2. 创建bolt处理数据
3. 创建一个Topology提交到集群

下面我们就写一下，以下代码拷贝到eclipse（依赖的jar包到官网下载即可）即可运行。

1.创建一个Spout作为数据源

     Spout作为数据源，它实现了IRichSpout接口，功能是读取一个文本文件并把它的每一行内容发送给bolt。

package storm.demo.spout;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Map;
import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.IRichSpout;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;
public class WordReader implements IRichSpout {
	private static final long serialVersionUID = 1L;
	private SpoutOutputCollector collector;
	private FileReader fileReader;
	private boolean completed = false;

	public boolean isDistributed() {
		return false;
	}
	/**
	 * 这是第一个方法，里面接收了三个参数，第一个是创建Topology时的配置，
	 * 第二个是所有的Topology数据，第三个是用来把Spout的数据发射给bolt
	 * **/
	@Override
	public void open(Map conf, TopologyContext context,
			SpoutOutputCollector collector) {
		try {
			//获取创建Topology时指定的要读取的文件路径
			this.fileReader = new FileReader(conf.get("wordsFile").toString());
		} catch (FileNotFoundException e) {
			throw new RuntimeException("Error reading file ["
					+ conf.get("wordFile") + "]");
		}
		//初始化发射器
		this.collector = collector;

	}
	/**
	 * 这是Spout最主要的方法，在这里我们读取文本文件，并把它的每一行发射出去（给bolt）
	 * 这个方法会不断被调用，为了降低它对CPU的消耗，当任务完成时让它sleep一下
	 * **/
	@Override
	public void nextTuple() {
		if (completed) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// Do nothing
			}
			return;
		}
		String str;
		// Open the reader
		BufferedReader reader = new BufferedReader(fileReader);
		try {
			// Read all lines
			while ((str = reader.readLine()) != null) {
				/**
				 * 发射每一行，Values是一个ArrayList的实现
				 */
				this.collector.emit(new Values(str), str);
			}
		} catch (Exception e) {
			throw new RuntimeException("Error reading tuple", e);
		} finally {
			completed = true;
		}

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

	}
	@Override
	public void close() {
		// TODO Auto-generated method stub
	}
	
	@Override
	public void activate() {
		// TODO Auto-generated method stub

	}
	@Override
	public void deactivate() {
		// TODO Auto-generated method stub

	}
	@Override
	public void ack(Object msgId) {
		System.out.println("OK:" + msgId);
	}
	@Override
	public void fail(Object msgId) {
		System.out.println("FAIL:" + msgId);

	}
	@Override
	public Map<String, Object> getComponentConfiguration() {
		// TODO Auto-generated method stub
		return null;
	}
}

　　

2.创建两个bolt来处理Spout发射出的数据

     Spout已经成功读取文件并把每一行作为一个tuple(在Storm数据以tuple的形式传递)发射过来，我们这里需要创建两个bolt分别来负责解析每一行和对单词计数。

     Bolt中最重要的是execute方法，每当一个tuple传过来时它便会被调用。

     第一个bolt：WordNormalizer

package storm.demo.bolt;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.IRichBolt;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
public class WordNormalizer implements IRichBolt {
	private OutputCollector collector;
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		this.collector = collector;
	}
	/**这是bolt中最重要的方法，每当接收到一个tuple时，此方法便被调用
	 * 这个方法的作用就是把文本文件中的每一行切分成一个个单词，并把这些单词发射出去（给下一个bolt处理）
	 * **/
	@Override
	public void execute(Tuple input) {
		String sentence = input.getString(0);
		String[] words = sentence.split(" ");
		for (String word : words) {
			word = word.trim();
			if (!word.isEmpty()) {
				word = word.toLowerCase();
				// Emit the word
				List a = new ArrayList();
				a.add(input);
				collector.emit(a, new Values(word));
			}
		}
		//确认成功处理一个tuple
		collector.ack(input);
	}
	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declare(new Fields("word"));

	}
	@Override
	public void cleanup() {
		// TODO Auto-generated method stub

	}
	@Override
	public Map<String, Object> getComponentConfiguration() {
		// TODO Auto-generated method stub
		return null;
	}
}

第二个bolt:WordCounter

package storm.demo.bolt;
import java.util.HashMap;
import java.util.Map;
import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.IRichBolt;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.tuple.Tuple;

public class WordCounter implements IRichBolt {
	Integer id;
	String name;
	Map<String, Integer> counters;
	private OutputCollector collector;

	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		this.counters = new HashMap<String, Integer>();
		this.collector = collector;
		this.name = context.getThisComponentId();
		this.id = context.getThisTaskId();

	}
	@Override
	public void execute(Tuple input) {
		String str = input.getString(0);
		if (!counters.containsKey(str)) {
			counters.put(str, 1);
		} else {
			Integer c = counters.get(str) + 1;
			counters.put(str, c);
		}
		// 确认成功处理一个tuple
		collector.ack(input);
	}
	/**
	 * Topology执行完毕的清理工作，比如关闭连接、释放资源等操作都会写在这里
	 * 因为这只是个Demo，我们用它来打印我们的计数器
	 * */
	@Override
	public void cleanup() {
		System.out.println("-- Word Counter [" + name + "-" + id + "] --");
		for (Map.Entry<String, Integer> entry : counters.entrySet()) {
			System.out.println(entry.getKey() + ": " + entry.getValue());
		}
		counters.clear();
	}
	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		// TODO Auto-generated method stub

	}
	@Override
	public Map<String, Object> getComponentConfiguration() {
		// TODO Auto-generated method stub
		return null;
	}
}

 

3.在main函数中创建一个Topology

     在这里我们要创建一个Topology和一个LocalCluster对象，还有一个Config对象做一些配置。 

package storm.demo;

import storm.demo.bolt.WordCounter;
import storm.demo.bolt.WordNormalizer;
import storm.demo.spout.WordReader;
import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.tuple.Fields;
public class WordCountTopologyMain {
	public static void main(String[] args) throws InterruptedException {
		//定义一个Topology
		TopologyBuilder builder = new TopologyBuilder();
		builder.setSpout("word-reader",new WordReader());
		builder.setBolt("word-normalizer", new WordNormalizer())
		.shuffleGrouping("word-reader");
		builder.setBolt("word-counter", new WordCounter(),2)
		.fieldsGrouping("word-normalizer", new Fields("word"));
		//配置
		Config conf = new Config();
		conf.put("wordsFile", "d:/text.txt");
		conf.setDebug(false);
		//提交Topology
		conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);
		//创建一个本地模式cluster
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("Getting-Started-Toplogie", conf,
		builder.createTopology());
		Thread.sleep(1000);
		cluster.shutdown();
	}
}

　   运行这个函数我们即可看到后台打印出来的单词个数。

 

3.Storm实例+mysql数据库保存

package com.qing.storm.Spout;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Map;

import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;

@SuppressWarnings("serial")
public class ReadLogSpout extends BaseRichSpout {
	
	private SpoutOutputCollector collector;
	FileInputStream fis;
	InputStreamReader isr;
	BufferedReader br;

	@Override
	public void nextTuple() {
		// TODO Auto-generated method stub
		String str = "";
		try {
			while ((str = this.br.readLine()) != null) {
				this.collector.emit(new Values(str));
				Thread.sleep(100);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@SuppressWarnings("rawtypes")
	@Override
	public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
		// TODO Auto-generated method stub
		this.collector = collector;		
		String file = "/opt/apache-storm-0.9.3/bin/domain.log";
		try{
			this.fis = new FileInputStream(file);
		this.isr = new InputStreamReader(fis);
		this.br = new BufferedReader(isr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		// TODO Auto-generated method stub
		declarer.declare(new Fields("str"));
	}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

package com.qing.storm.Bolt;

import backtype.storm.topology.BasicOutputCollector;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseBasicBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

@SuppressWarnings("serial")
public class SplitBolt extends BaseBasicBolt{

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		// TODO Auto-generated method stub
		declarer.declare(new Fields("word"));
	}

	@Override
	public void execute(Tuple tuple, BasicOutputCollector collector) {
		// TODO Auto-generated method stub
		String sentence = tuple.getString(0);
		for(String word: sentence.split(" ")){
		collector.emit(new Values(word));
	}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
package com.qing.storm.Bolt;

import java.util.HashMap;
import java.util.Map;

import backtype.storm.topology.BasicOutputCollector;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseBasicBolt;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

@SuppressWarnings("serial")
public class WordCountBolt extends BaseBasicBolt{
	Map<String, Integer> counts = new HashMap<String, Integer>();
	
	public void execute(Tuple tuple, BasicOutputCollector collector) {
		// TODO Auto-generated method stub
		String word = tuple.getString(0);
		Integer count = counts.get(word);
		if(count == null){
			count = 0;
		}
		count++;
		counts.put(word, count);
		collector.emit(new Values(word,count));
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		// TODO Auto-generated method stub
		declarer.declare(new Fields("word", "count"));
	}



}




///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
package com.qing.storm.Bolt;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Map;

import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.tuple.Tuple;

@SuppressWarnings("serial")
public class MysqlBolt extends BaseRichBolt{
	private OutputCollector collector;
	Connection conn = null;
	String from = "word_count"; //表名
	private String word;
	private int num;
	@Override
	public void declareOutputFields(OutputFieldsDeclarer arg0) {
		// TODO Auto-generated method stub
		
	}



	@Override
	public void prepare(@SuppressWarnings("rawtypes") Map conf, TopologyContext context, OutputCollector collector) {
		// TODO Auto-generated method stub
		this.collector = collector;
		try {
			LinkDB();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void LinkDB() throws InstantiationException, IllegalAccessException, SQLException {
		// TODO Auto-generated method stub
		String host_port = "127.0.0.1:3306";
		String database = "storm_test";
		String username = "root";
		String password = "root";
		String url = "jdbc:mysql://" + host_port + "/" + database;
			try {
				Class.forName("com.mysql.jdbc.Driver");
				conn  = DriverManager.getConnection(url, username, password);
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	@Override
	public void execute(Tuple tuple) {
		// TODO Auto-generated method stub
		String word= tuple.getString(0);
		int num = tuple.getInteger(1);
		InsertDB(word, num);
	}

	private void InsertDB(String word, int num) {
		// TODO Auto-generated method stub
		this.word = word;
		this.num = num;
		String sql = "replace into " + this.from+ "(word, num) values ('" +word+"',"+num+ ")";
		try {
		    Statement	statement = conn.createStatement();
			statement.executeUpdate(sql);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
package com.qing.storm.Topology;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.StormSubmitter;
import backtype.storm.generated.AlreadyAliveException;
import backtype.storm.generated.InvalidTopologyException;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.tuple.Fields;

import com.qing.storm.Bolt.MysqlBolt;
import com.qing.storm.Bolt.SplitBolt;
import com.qing.storm.Bolt.WordCountBolt;
import com.qing.storm.Spout.ReadLogSpout;

public class DB_Topology {
	public static void main(String[] args){
		  try {
		TopologyBuilder builder = new TopologyBuilder();
		
		builder.setSpout("spout", new ReadLogSpout(), 5);
		
		builder.setBolt("split", new SplitBolt(), 8).shuffleGrouping("spout");
		
		builder.setBolt("count", new WordCountBolt(), 10).fieldsGrouping("split", new Fields("word"));
		
		builder.setBolt("Mysql", new MysqlBolt(),10).fieldsGrouping("count", new Fields("word","count"));
		
		
		Config conf = new Config();
		conf.setDebug(true);
		 //if (args != null && args.length > 0) {
             /*设置该topology在storm集群中要抢占的资源slot数，一个slot对应这supervisor节点上的以个worker进程
              如果你分配的spot数超过了你的物理节点所拥有的worker数目的话，有可能提交不成功，加入你的集群上面已经有了
              一些topology而现在还剩下2个worker资源，如果你在代码里分配4个给你的topology的话，那么这个topology可以提交
              但是提交以后你会发现并没有运行。 而当你kill掉一些topology后释放了一些slot后你的这个topology就会恢复正常运行。
             */
             //conf.setNumWorkers(1);
     
            	 if (args != null && args.length > 0) {
            		 conf.setNumWorkers(1);
            		 StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
            	 }
			} catch (AlreadyAliveException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvalidTopologyException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
         }
//		conf.setMaxTaskParallelism(1);
//		LocalCluster cluster = new LocalCluster();
//		cluster.submitTopology("word-count", conf, builder.createTopology());
//		try {
//			Thread.sleep(1000000);
//		} catch (InterruptedException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		//cluster.shutdown();
	}

　　

4.Storm原理介绍

　　Storm是使用Clojure语言开发，但是可以在Storm中使用任何语言编写应用程序，所需的只是一个连接到Storm 的架构的适配器。已存在针对 Scala、JRuby、Perl 和 PHP 的适配器，但是还有支持流式传输到 Storm 拓扑结构中的结构化查询语言适配器。

　　Storm 的关键属性
　　Storm 实现的一些特征决定了它的性能和可靠性的。Storm 使用 ZeroMQ 传送消息，这就消除了中间的排队过程，使得消息能够直接在任务自身之间流动。在消息的背后，是一种用于序列化和反序列化 Storm 的原语类型的自动化且高效的机制。
　　Storm 的一个最有趣的地方是它注重容错和管理。Storm 实现了有保障的消息处理，所以每个元组都会通过该拓扑结构进行全面处理；如果发现一个元组还未处理会自动从喷嘴处重放。Storm 还实现了任务级的故障检测，在一个任务发生故障时，消息会自动重新分配以快速重新开始处理。Storm 包含比 Hadoop 更智能的处理管理，流程会由监管员来进行管理，以确保资源得到充分使用。

　　Storm 实现了一种数据流模型，其中数据持续地流经一个转换实体网络（参见 图 1）。一个数据流的抽象称为一个流，这是一个无限的元组序列。元组就像一种使用一些附加的序列化代码来表示标准数据类型（比如整数、浮点和字节数组）或用户定义类型的结构。每个流由一个惟一 ID 定义，这个 ID 可用于构建数据源和接收器 (sink) 的拓扑结构。流起源于喷嘴，喷嘴将数据从外部来源流入 Storm 拓扑结构中。

　　

　　接收器（或提供转换的实体）称为螺栓。螺栓实现了一个流上的单一转换和一个 Storm 拓扑结构中的所有处理。螺栓既可实现 MapReduce 之类的传统功能，也可实现更复杂的操作（单步功能），比如过滤、聚合或与数据库等外部实体通信。典型的 Storm 拓扑结构会实现多个转换，因此需要多个具有独立元组流的螺栓。喷嘴和螺栓都实现为 Linux® 系统中的一个或多个任务。

　　使用 Storm 为词频轻松地实现 MapReduce 功能。如 图 2 中所示，喷嘴生成文本数据流，螺栓实现 Map 功能（令牌化一个流的各个单词）。来自 “map” 螺栓的流然后流入一个实现 Reduce 功能的螺栓中（以将单词聚合到总数中）。

　　　　

　　请注意，螺栓可将数据传输到多个螺栓，也可接受来自多个来源的数据。Storm 拥有流分组 的概念，流分组实现了混排 (shuffling)（随机但均等地将元组分发到螺栓）或字段分组（根据流的字段进行流分区）。还存在其他流分组，包括生成者使用自己的内部逻辑路由元组的能力。

　　但是，Storm 架构中一个最有趣的特性是有保障的消息处理。Storm 可保证一个喷嘴发射出的每个元组都会处理；如果它在超时时间内没有处理，Storm 会从该喷嘴重放该元组。此功能需要一些聪明的技巧来在拓扑结构中跟踪元素，也是 Storm 的重要的附加价值之一。

　　除了支持可靠的消息传送外，Storm 还使用 ZeroMQ 最大化消息传送性能（删除中间排队，实现消息在任务间的直接传送）。ZeroMQ 合并了拥塞检测并调整了它的通信，以优化可用的带宽。

5. flume+kafka+storm+mysql 实时架构

flume的架构图：

　　

kafka的架构图：

storm的架构图：

  flume + kafka + storm +mysql的数据流架构图：

下面介绍一下kafka到storm的配置：

其实这些都是通过java代码实现的，这里用到了 KafkaSpout类，RDBMSDumperBolt类（以后这些可以作为工具类打包上传到集群中）

storm作业中，我们写了一个KafkaStormRdbms类，作业具体配置如下：

首先设置连接mysql的参数

　　

        ArrayList<String> columnNames = new ArrayList<String>();
        ArrayList<String> columnTypes = new ArrayList<String>();
        String tableName = "stormTestTable_01";
        // Note: if the rdbms table need not to have a primary key, set the variable 'primaryKey' to 'N/A'
        // else set its value to the name of the tuple field which is to be treated as primary key
        String primaryKey = "N/A";
        String rdbmsUrl = "jdbc:mysql://$hostname:3306/fuqingwuDB" ;
        String rdbmsUserName = "fuqingwu";
        String rdbmsPassword = "password";

        //add the column names and the respective types in the two arraylists
        columnNames.add("word");

        //add the types
        columnTypes.add("varchar (100)");

　配置 KafkaSpout 及 Topology：

TopologyBuilder builder = new TopologyBuilder();
		
		List<String> hosts = new ArrayList<String>();
        hosts.add("hadoop01");
        SpoutConfig spoutConf = SpoutConfig.fromHostStrings(hosts, 1, "flume_kafka", "/root", "id");
        spoutConf.scheme = new StringScheme();
        spoutConf.forceStartOffsetTime(-2);
		
        spoutConf.zkServers = new ArrayList<String>() {{
        	          add("hadoop01"); 
        	        }};
        spoutConf.zkPort = 2181;
        
		//set the spout for the topology
		builder.setSpout("spout",  new KafkaSpout(spoutConf), 1);

		//dump the stream data into rdbms table		
		RDBMSDumperBolt dumperBolt = new RDBMSDumperBolt(primaryKey, tableName, columnNames, columnTypes, rdbmsUrl, rdbmsUserName, rdbmsPassword);
		builder.setBolt("dumperBolt",dumperBolt, 1).shuffleGrouping("spout");

　原文连接：http://blog.csdn.net/baiyangfu_love/article/details/8096088

　GitHub：https://github.com/baniuyao/flume-kafka

这个框架用的组件基本都是最新稳定版本，flume-ng1.4+kafka0.8+storm0.9+mysql架构设计：

1）.数据采集

负责从各节点上实时采集数据，选用cloudera的flume来实现

2）.数据接入

由于采集数据的速度和数据处理的速度不一定同步，因此添加一个消息中间件来作为缓冲，选用apache的kafka

3）.流式计算

对采集到的数据进行实时分析，选用apache的storm

4）.数据输出

对分析后的结果持久化，暂定用mysql

参考：http://blog.csdn.net/mylittlered/article/details/20810265

http://www.blogchong.com/post/storm_data_Platform.html