flume+kafka+storm

• 
  

flume

原理

Flume 是一个可靠的，分布式的，用于采集，聚合，传输海量日志数据的系统。
Flume 的核心是把数据从数据源收集过来，再送到目的地。为了保证输送一定成功，在送到目的地之前，会先缓存数据，待数据真正到达目的地后，删除自己缓存的数据。
下面是一些概念.

Event
数据传输的基本单位.通常是一行记录.

Agent
Flume的运行核心,有三个组件:source,channel,sink.

Source
用于接收外部源发来的数据

Channel
用于缓存Source发来的event,有fileChannel和memoryChannel两种,分别将event缓存于文件和内存中,当事件被sink掉,才会从channel中删除.

Sink
消费event,将数据发送给外部存储系统(如hdfs等),或者发送给下一个agent的source.

搭建

--解压即用
tar -zxvf apache-flume- 1.6 . 0 -bin.tar.gz

配置文件

#测试配置
a1.sources = r1
a1.sinks = k1
a1.channels = c1

# Describe/configure the source
a1.sources.r1.type = netcat
a1.sources.r1.bind = localhost
a1.sources.r1.port =  44444

# Describe the sink
a1.sinks.k1.type = logger

# Use a channel which buffers events in memory
a1.channels.c1.type = memory
a1.channels.c1.capacity =  1000
a1.channels.c1.transactionCapacity =  100

# Bind the source and sink to the channel
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

#启用代理
cd /opt/apache-flume- 1.6 . 0 -bin/
bin/flume-ng agent --conf conf --conf-file /opt/apache-flume- 1.6 . 0 -bin/conf/test.conf --name a1 -Dflume.root.logger=INFO,console

#向端口灌数据测试
nc localhost  4444

###########################################################################################


#dapp1到test1
#######test1配置
a1.channels = ch1
a1.sources = avro-source1
a1.sinks = s1

a1.sinks.s1.type = logger

a1.channels.ch1.type = memory
a1.channels.ch1.capacity =  10000
a1.channels.ch1.transactionCapacity =  100

a1.sources.avro-source1.channels = ch1
a1.sources.avro-source1.type = avro
a1.sources.avro-source1.bind =  0.0 . 0.0
a1.sources.avro-source1.port =  41415

a1.sources.avro-source1.channel = ch1
a1.sinks.s1.channel = ch1

#启动代理
bin/flume-ng agent --conf conf --conf-file /opt/apache-flume- 1.6 . 0 -bin/conf/from_dapp1_test.conf --name a1 -Dflume.root.logger=INFO,console

dapp1配置
a1.sources = r1
a1.sinks = k1
a1.channels = c2

a1.sources.r1.type = exec
a1.sources.r1.command = tail  -F /home/q/www/dapp/logs/access. 2015 - 12 - 07 .log
a1.sources.r1.shell = /bin/bash -c
a1.sources.r1.channels = c2
a1.sources.r1.restart =  true
a1.sources.r1.logStdErr =  true

a1.sources.r1.interceptors = i1 i2
a1.sources.r1.interceptors.i1.type = host
a1.sources.r1.interceptors.i1.hostHeader = hostname
a1.sources.r1.interceptors.i1.useIP =  false

a1.sources.r1.interceptors.i2.type = timestamp

# Describe the sink
a1.sinks.k1.channel = c2
a1.sinks.k1.type = avro
a1.sinks.k1.hostname = l-pgtest1.s.dev.cn6.yincang.com
a1.sinks.k1.port =  41415

a1.channels.c2.type = memory
a1.channels.c2.capacity =  10000
a1.channels.c2.transactionCapacity =  100

###启动代理
/export/flume/bin/flume-ng agent --conf conf --conf-file /export/flume/flume-access-to-test1.conf --name a1

##################################################
flume to kafka配置
a1.channels = ch1
a1.sources = avro-source1
a1.sinks = s1

#a1.sinks.s1.type = logger
a1.sinks.s1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.s1.topic = flume_to_kafka_test
a1.sinks.s1.brokerList =  192.168 . 236.62 : 9092 , 192.168 . 236.63 : 9092 , 192.168 . 236.77 : 9092
a1.sinks.s1.requiredAcks =  1
a1.sinks.s1.batchSize =  20
a1.sinks.s1.channel = c1

a1.channels.ch1.type = memory
a1.channels.ch1.capacity =  10000
a1.channels.ch1.transactionCapacity =  100

a1.sources.avro-source1.channels = ch1
a1.sources.avro-source1.type = avro
a1.sources.avro-source1.bind =  0.0 . 0.0
a1.sources.avro-source1.port =  41415

a1.sources.avro-source1.channel = ch1
a1.sinks.s1.channel = ch1

##启动
bin/flume-ng agent --conf conf --conf-file /opt/apache-flume- 1.6 . 0 -bin/conf/from_dapp1_to_kafka.conf --name a1



bin/flume-ng agent --conf conf --conf-file /export/flume1. 6 /conf_a1/skynet_from_kafka.conf --name a4&

###启动带http监控参数，通过host:port/metrics url访问得到监控数据
bin/flume-ng agent --conf conf --conf-file /export/flume1. 6 /conf_a1/skynet_from_kafka.conf --name a4 -Dflume.monitoring.type=http -Dflume.monitoring.port= 34545 &

kafka

原理

Apache Kafka 是一个分布式消息发布订阅系统,易于扩展,提供高吞吐量的发布和订阅,支持多订阅者.
如下是一些概念.

1 .Broker
一个broker就是一个kafka服务

2 .Topic
使用kafka时,我们会将消息分类,一个类别称为一个topic.
一个topic可以有多个分区,每一个分区位于一个broker上.
每个topic的多个partitions 都有一个称为leader的server,用于处理分区的读写请求,
同时有 0 到多个followers ,用于分区备份,如果leader失败,其中任一followers变为leader.

3 .Producer
消息生产者,向topics发送数据,可以进行负载均衡,也可以定义分区函数进行分发(通过消息中的关键字,不同关键字的消息分发至不同的分区)

4 .Consumer
消费者,订阅消息并处理发布的消息,

整体架构

不同的producer 向kafka集群发送消息

不同的consumer 从kafka订阅消费消息

topic

一个topic可以有多个分区,每一个分区位于一个broker上.每一个分区都是一个顺序的、不可变的消息队列， 并且可以持续的添加.

同一个partition中的数据是有序的,如果要保证整topic中的消息有序,可以一个topic设置一个partition.kafka会保留所有的消息,直到消息过期.

消费者持有的元数据只是一个偏移量,一般情况下,当消费者处理消息的时候,偏移量会线性增加,实际上偏移量由消费者自己控制,可以回到一个先前的位置重新开始处理.

一个消费者的处理不会影响其他消费者对此Topic的处理.

并行发送,并行处理.

zookeeper搭建

用的是kafka自带的zk
1 .config/zookeeper.properties 配置
tickTime= 2000
dataDir=/home/q/data/zookeeper
clientPort= 2182
initLimit= 5
syncLimit= 2
server. 1 = 192.168 . 236.62 : 2889 : 3889
server. 2 = 192.168 . 236.63 : 2889 : 3889
server. 3 = 192.168 . 236.77 : 2889 : 3886

2 .在dataDir目录下写一个myid,这个id是zookeeper的主机标示，每个主机id不同echo  1  >myid
3 .逐次启动 3 台机器的zookeeper构成一个集群
 bin/zookeeper-server-start.sh config/zookeeper.properties &

kafka搭建

0 .搭建zookeeper

1 .解压
tar -zxvf kafka_2. 11 - 0.8 . 2.2 .tgz

2 .配置config/server.properties
-----------------------------------------------------------------------------
# 每个broker的唯一标识,非负整数
broker.id= 1
# broker 服务端口
port= 9092
# broker绑定的服务器地址
host.name= 192.168 . 236.62
# zk 连接配置,防止某个zk宕机,可配置多个,以逗号分隔
zookeeper.connect= 192.168 . 236.62 : 2182 , 192.168 . 236.63 : 2182 , 192.168 . 236.77 : 2182
# kafka存放数据的位置
log.dirs=/home/q/data/kafka-logs
#日志清理策略
log.cleanup.policy=delete
#日志存储的最大时间,超过时间会按日志清理策略清理,消费消息的最长时间
log.retention.minutes=3days
#每个topic 每个分区保存数据的上限,超过则会被清理
log.retention.bytes=- 1
#压缩日志保留时间
log.cleaner.delete.retention.ms=1day
...
--------------------------------------------------------------------------------
其他broker配置类似

3 .启动每个kafka服务
bin/kafka-server-start.sh config/server.properties &
4 .关闭kafka
bin/kafka-server-stop.sh config/server.properties &
5 .重启
先执行 3 ，再执行 4

命令

bin/kafka-topics.sh --create --zookeeper  192.168 . 236.62 : 2182  --replication-factor  1  --partitions  3  --topic flume_to_kafka_test

bin/kafka-topics.sh --list --zookeeper localhost: 2182

bin/kafka-console-producer.sh --broker-list l-pgtest1.vc.dev.cn0.yincang.com: 9092  --topic test

bin/kafka-console-consumer.sh --zookeeper localhost: 2182  --topic flume_to_kafka_test --from-beginning

bin/kafka-topics.sh --describe --zookeeper localhost: 2182  --topic flume_to_kafka_test
Topic:flume_to_kafka_test    PartitionCount: 3     ReplicationFactor: 1     Configs:
    Topic: flume_to_kafka_test    Partition:  0     Leader:  2     Replicas:  2     Isr:  2
    Topic: flume_to_kafka_test    Partition:  1     Leader:  0     Replicas:  0     Isr:  0
    Topic: flume_to_kafka_test    Partition:  2     Leader:  1     Replicas:  1     Isr:  1
PartitionCount 分区数
ReplicationFactor 副本服务数
Partition 分区编号
Leader 分区读写请求服务编号
replicas 给定partition备份的列表,无论活着与否,是否为leader
Isr 同步的副本,副本列表的子集,当前活着并可以被leader联系到

#删除Topic
bin/kafka-topics.sh --delete --zookeeper  192.168 . 236.62 : 2182  --topic flume_to_kafka_test
bin/kafka-topics.sh --delete --zookeeper  192.168 . 236.62 : 2182  --topic flume_to_kafka_test

#########调整分区数
bin/kafka-topics.sh --alter --topic qvpas_pv_logs --zookeeper localhost: 2181  --partitions  4
调分区的警告：WARNING: If partitions are increased  for  a topic that has a key, the partition logic or ordering of the messages will be affected
--看效果
--调整前
[xiao.yang @l -pgtest1.vc.dev.cn0 /opt/kafka_2. 11 - 0.8 . 2.2 ]$ bin/kafka-topics.sh --describe --zookeeper localhost: 2182  --topic qvpas_pv_log
Topic:qvpas_pv_log    PartitionCount: 3     ReplicationFactor: 3     Configs:
    Topic: qvpas_pv_log    Partition:  0     Leader:  2     Replicas:  1 , 2 , 3     Isr:  2 , 3 , 1
    Topic: qvpas_pv_log    Partition:  1     Leader:  2     Replicas:  2 , 3 , 1     Isr:  2 , 3 , 1
    Topic: qvpas_pv_log    Partition:  2     Leader:  3     Replicas:  3 , 1 , 2     Isr:  3 , 2 , 1
--调整后
[xiao.yang @l -pgtest1.vc.dev.cn0 /opt/kafka_2. 11 - 0.8 . 2.2 ]$ bin/kafka-topics.sh --describe --topic qvpas_pvogs --zookeeper localhost: 2182
Topic:qvpas_pv_logs    PartitionCount: 4     ReplicationFactor: 1     Configs:
    Topic: qvpas_pv_logs    Partition:  0     Leader:  1     Replicas:  1     Isr:  1
    Topic: qvpas_pv_logs    Partition:  1     Leader:  3     Replicas:  3     Isr:  3
    Topic: qvpas_pv_logs    Partition:  2     Leader:  1     Replicas:  1     Isr:  1
    Topic: qvpas_pv_logs    Partition:  3     Leader:  2     Replicas:  2     Isr:  2

#########调整备份因子
--需要配置一段json，如下 alter_qvpas_pv_logs_replicas.json 文件内容：
{ "version" : 1 ,
 "partitions" :[{ "topic" : "qvpas_pv_logs" , "partition" : 0 , "replicas" :[ 1 , 2 ]},
               { "topic" : "qvpas_pv_logs" , "partition" : 1 , "replicas" :[ 1 , 2 ]},
               { "topic" : "qvpas_pv_logs" , "partition" : 2 , "replicas" :[ 1 , 2 ]},
               { "topic" : "qvpas_pv_logs" , "partition" : 3 , "replicas" :[ 1 , 2 ]}]
}
--执行
bin/kafka-reassign-partitions.sh --zookeeper localhost: 2182  --reassignment-json-file alter_qvpas_pv_logs_replicas.json --execute
--看效果
--调整前
[root @l -pgtest1.vc.dev.cn0 /opt/kafka_2. 11 - 0.8 . 2.2 ]# bin/kafka-topics.sh --describe --topic qvpas_pv_logs --zookeeper localhost:2182Topic:qvpas_pv_logs
 PartitionCount: 4     ReplicationFactor: 1     Configs:
    Topic: qvpas_pv_logs    Partition:  0     Leader:  1     Replicas:  1     Isr:  1
    Topic: qvpas_pv_logs    Partition:  1     Leader:  3     Replicas:  3     Isr:  3
    Topic: qvpas_pv_logs    Partition:  2     Leader:  1     Replicas:  1     Isr:  1
    Topic: qvpas_pv_logs    Partition:  3     Leader:  2     Replicas:  2     Isr:  2
--调整后
[root @l -pgtest1.vc.dev.cn0 /opt/kafka_2. 11 - 0.8 . 2.2 ]# bin/kafka-topics.sh --describe --topic qvpas_pv_logs --zookeeper localhost:2182Topic:qvpas_pv_logs
 PartitionCount: 4     ReplicationFactor: 2     Configs:
    Topic: qvpas_pv_logs    Partition:  0     Leader:  1     Replicas:  1 , 2     Isr:  1 , 2
    Topic: qvpas_pv_logs    Partition:  1     Leader:  1     Replicas:  1 , 2     Isr:  1 , 2
    Topic: qvpas_pv_logs    Partition:  2     Leader:  1     Replicas:  1 , 2     Isr:  1 , 2
    Topic: qvpas_pv_logs    Partition:  3     Leader:  2     Replicas:  1 , 2     Isr:  2 , 1

--调整kafka topic的队列保留时间为 1 天，（一种清理kafka队列的方式，可以将时间设置为1s,则1s之前的消息会全部被清除，然后再把时间调为正常值，如 3 天）
bin/kafka-topics.sh --zookeeper localhost: 2181  --alter --topic data. import .dujia.accesslog --config retention.ms= 86400000


-- 0.10 之后的
 bin/kafka-configs.sh --zookeeper localhost: 2181  --alter --entity-type topics --entity-name skynet_topic_td_1 --add-config retention.ms= 86400000

storm

原理

Storm是一个分布式的、高容错的实时计算系统。

就像Hadoop提供一组通用原语来进行批量处理(batch processing)一样，Storm也提供了一组通用原语来进行实时计算(realtime computation)。

storm的集群表面上看和hadoop的集群非常像。但是在Hadoop上面你运行的是MapReduce的Job, 而在Storm上面你运行的是Topology。
一个关键的区别是： 一个MapReduce Job最终会结束， 而一个Topology运永远运行（除非被显式杀掉）。

控制节点(master node)
控制节点上面运行一个后台程序： Nimbus， 它的作用类似Hadoop里面的JobTracker。Nimbus负责在集群里面分布代码，分配工作给机器， 并且监控状态。
工作节点(worker node)
每一个工作节点上面运行一个叫做Supervisor的后台程序（类似 TaskTracker）。Supervisor会监听分配给它那台机器的工作，根据需要 启动/关闭工作进程。

Nimbus和Supervisor之间的所有协调工作都是通过一个Zookeeper集群来完成。

Woker
Worker是Spout/Bolt中运行具体处理逻辑的进程。
Executor
Executor称为物理线程，每个Worker可以包含多个Executor。
Task
Task是具体的处理逻辑对象，默认情况下，执行器和任务对应，即一个执行器对应一个任务。

搭建

1 .解压
tar -zxvf apache-storm- 0.10 . 0 .tar.gz
2 .配置 conf/storm.yaml
#zk集群地址配置
 storm.zookeeper.servers:
     -  "192.168.236.62"
     -  "192.168.236.63"
     -  "192.168.236.77"
#zk端口号,如果是默认的 2181 ,无须配置
 storm.zookeeper.port:  2182
#storm使用的本地文件系统目录,用于Nimbus和Supervisor进程存储少量状态,如jars,conf等
 storm.local.dir:  "/home/q/data/storm"
#Storm集群Nimbus机器地址，各个Supervisor工作节点需要知道哪个机器是Nimbus，以便下载Topologies的jars、confs等文件
 nimbus.host:  "192.168.236.62"

#对于每个Supervisor工作节点，需要配置该工作节点可以运行的worker数量。每个worker占用一个单独的端口用于接收消息
 supervisor.slots.ports:
    -  6700
    -  6701
    -  6702
    -  6703

3 .启动Nimbus后台程序,在Storm主控节点nimbus上运行如下命令
bin/storm nimbus&
4 .启动supervisor,在各个工作节点上运行如下命令
bin/storm supervisor&
5 .启动storm ui,在nimbus节点上运行
  启动后可以通过http: //{nimbus host}:8080观察集群的worker资源使用情况、Topologies的运行状态等信息
 bin/storm ui&
注意:Storm UI必须和Storm Nimbus部署在同一台机器上，否则UI无法正常工作.

Topology

Topology是storm的核心,我们通过编写和部署Topology来处理数据.
下面是一些概念.
Stream
Storm中的核心抽象概念就是流。流是无边界的元组(tuples)的序列。
通过对stream中tuple序列中每个字段命名来定义stream。
storm提供一些原语来分布式地、可靠地把一个stream传输进一个新的stream。(spout和bolt)
Spout
spout的流的源头。
比如一个spout可能从kafka的topic读取消息并且把这些消息发射成一个流。
通常Spout会从外部数据源（队列、数据库等）读取数据，然后封装成Tuple形式，之后发送到Stream中。
Spout是一个主动的角色，在接口内部有个nextTuple函数，Storm框架会不停的调用该函数。
Bolt
bolt可以接收任意多个输入stream，作一些处理，有些bolt可能还会发射一些新的stream。
一些复杂的流转换，需要多个步骤，从而也就需要多个bolt。
Bolt可以做任何事情: 运行函数，过滤tuple,做一些聚合，做一些合并以及访问数据库等。
Bolt是一个被动的角色，其接口中有一个execute(Tuple input)方法，在接收到消息之后会调用此函数，我们可以在此方法中执行自己的处理逻辑。
StreamGroups
一个Stream应如何分配数据给Bolt上面的Task. http: //wiki.corp.yincang.com/display/~xiao.yang/stream+groups
Topology
spout和bolt所组成一个网络会被打包成topology， topology是storm里面最高一级的抽象（类似 Job）， 我们可以把topology提交给storm的集群来运行.

使用

##集群部署topology
bin/storm jar /home/xiao.yang/storm_test.jar kafka.MyTest l-pgtest1.s.dev.cn6.yincang.com
##查看topology
bin/storm list
##删除topology
bin/storm kill MyTest
##激活topology
bin/storm active MyTest
##不激活
bin/storm deactive MyTest