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 |