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
|