FLUME-KAFKA-SPARK STREAMING -实时计算框架搭建

首先，我们需要一个模拟实时数据，用来生成日志文件

File ctoFile = new File(args[0]);
	File dest=new File(args[1]);

	InputStreamReader rdCto = new InputStreamReader(new FileInputStream(ctoFile));
	OutputStreamWriter writer=new OutputStreamWriter(new FileOutputStream(dest));
	BufferedReader bfReader = new BufferedReader(rdCto);
	BufferedWriter bwriter=new BufferedWriter(writer);
	PrintWriter pw=new PrintWriter(bwriter);
	String txtline = null;
		while ((txtline = bfReader.readLine()) != null) {
			Thread.sleep(2000);
			pw.println(txtline);
			pw.flush();
		}
		bfReader.close();
		pw.close();

编译成字节码文件（.class）上传到linux系统，运行需要两个参数
第一个参数 数据源
第二个参数 目标文件

接下来，就是编辑flume配置文件tokafka.conf了

	指定变量名
		a1.sources = r1
		a1.sinks = k1
		a1.channels = c1
	
	编写source
		#指定类型为exec
		agent.sources.r1.type = exec
		#命令  ---监控文件
		agent.sources.r1.command = tail -F /home/michael/test/data.log
	
	指定管道
		agent.sources.r1.channels = c1
		agent.sinks.k1.channels = c1

	编写sink
		#设置成控制台输出用于测试有没有监听到"日志文件"的信息
		agent.sinks.k1.type = logger
		
	修改sink
		#配置sink指向kafka
		agent.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
		agent.sinks.k1.topic = test
		agent.sinks.k1.brokerList = localhost:9092
		agent.sinks.k1.batchSize = 20
		agent.sinks.k1.requiredAcks = 1

flume
Flume是一种分布式，可靠且可用的服务，用于有效地收集，聚合和移动大量日志数据，它具有可靠性机制和许多故障转移和恢复机制，具有强大的容错能力
下载地址:http://archive.apache.org/dist/flume/1.6.0/
系统要求
Java运行时环境 - Java 1.8或更高版本
内存 - 源，通道或接收器使用的配置的足够内存
磁盘空间 - 通道或接收器使用的配置的足够磁盘空间
目录权限 - 代理使用的目录的读/写权限

agent:
是flume代理，包含以下组件:
source数据源
channel通道（缓存的数据）
sink接收器

启动命令：
flume-ng agent --conf /home/michael/soft/flume/conf/ --conf-file tokafka.conf --name agent -Dflume.root.logger=INFO,console
------------------其后面的属性：
–conf：我的conf文件的父目录
–conf-file：我的conf文件的路径
–name：agent的名称

kafka阶段

启动kafka测试数据是否传到kafka并用消费者消费

1. 启动zookeeper
   zookeeper-server-start.sh ~/soft/kafka/config/zookeeper.properties

2. 启动kafka服务
   kafka-server-start.sh ~/soft/kafka/config/server.properties

3. 创建主题
   kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

4. 启动SocketTest（之前编写的java文件）
   java SocketTest access.20120104.log test/data.log

5. 启动flume
   flume-ng agent --conf ~/soft/flume/conf --conf-file ~/soft/flume/conf/tokafka.conf --name agent -Dflume.root.logger=INFO,console

6. 启动kafka消费者测试
   kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者规模的网站中的所有动作流数据。 这种动作（网页浏览，搜索和其他用户的行动）是在现代网络上的许多社会功能的一个关键因素。 这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。 对于像Hadoop一样的日志数据和离线分析系统，但又要求实时处理的限制，这是一个可行的解决方案。Kafka的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理，也是为了通过集群来提供实时的消息。

名词介绍：
----Broker:Kafka集群包含一个或多个服务器，这种服务器被称为broker [5]
----Topic:每条发布到Kafka集群的消息都有一个类别，这个类别被称为Topic。（物理上不同Topic的消息分开存储，逻辑上一个Topic的消息虽然保存于一个或多个broker上但用户只需指定消息的Topic即可生产或消费数据而不必关心数据存于何处）
----Partition:Partition是物理上的概念，每个Topic包含一个或多个Partition.
----Producer:负责发布消息到Kafka broker
----Consumer:消息消费者，向Kafka broker读取消息的客户端。
----Consumer Group:每个Consumer属于一个特定的Consumer Group（可为每个Consumer指定group name，若不指定group name则属于默认的group）。

最后，我们使用spark streaming程序

在此之前，引入spark-streaming-kafka-0-10_2.11包
maven

		<!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming-kafka-0-10 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
            <version>2.1.2</version>
        </dependency>

    val conf = new SparkConf().setAppName("fromkafka").setMaster("local[2]")
    val ssc = new StreamingContext(conf,Seconds(5))//每5秒一次
    ssc.sparkContext.setLogLevel("ERROR")//只打印error及以上级别的消息
    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "master:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "test",
      "auto.offset.reset" -> "latest",
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
    val topics = Array("test")
    // 从Kafka中读取数据
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,
      Subscribe[String, String](topics, kafkaParams)
    )
    stream.map(x => x.key()).print()//打印读到的数据
    ssc.start()
    ssc.awaitTermination()// 等待实时流

这样，我们就获取到了"实时数据"，如果要对其进行"计算"，就需要对spark streaming深入学习了