zookeeper+storm+kafka集群完全配置

zookeeper配置
		参数名	说明
clientPort	客户端连接server的端口，即对外服务端口，一般设置为2181
dataDir	存储快照文件snapshot的目录。默认情况下，事务日志也会存储在这里。建议同时配置参数dataLogDir, 事务日志的写性能直接影响zk性能。
tickTime	ZK中的一个时间单元。ZK中所有时间都是以这个时间单元为基础，进行整数倍配置的。例如，session的最小超时时间是2*tickTime。
dataLogDir	事务日志输出目录。尽量给事务日志的输出配置单独的磁盘或是挂载点，这将极大的提升ZK性能。
globalOutstandingLimit	最大请求堆积数。默认是1000。ZK运行的时候， 尽管server已经没有空闲来处理更多的客户端请求了，但是还是允许客户端将请求提交到服务器上来，以提高吞吐性能。当然，为了防止Server内存溢出，这个请求堆积数还是需要限制下的。
preAllocSize	预先开辟磁盘空间，用于后续写入事务日志。默认是64M，每个事务日志大小就是64M。如果ZK的快照频率较大的话，建议适当减小这个参数。
snapCount	每进行snapCount次事务日志输出后，触发一次快照(snapshot), 此时，ZK会生成一个snapshot.*文件，同时创建一个新的事务日志文件log.*。默认是100000.（真正的代码实现中，会进行一定的随机数处理，以避免所有服务器在同一时间进行快照而影响性能。
traceFile	用于记录所有请求的log，一般调试过程中可以使用，但是生产环境不建议使用，会严重影响性能。
maxClientCnxns	单个客户端与单台服务器之间的连接数的限制，是ip级别的，默认是60，如果设置为0，那么表明不作任何限制。请注意这个限制的使用范围，仅仅是单台客户端机器与单台ZK服务器之间的连接数限制，不是针对指定客户端IP，也不是ZK集群的连接数限制，也不是单台ZK对所有客户端的连接数限制。指定客户端IP的限制策略。
clientPortAddress	对于多网卡的机器，可以为每个IP指定不同的监听端口。默认情况是所有IP都监听 clientPort 指定的端口。
minSessionTimeoutmaxSessionTimeout	Session超时时间限制，如果客户端设置的超时时间不在这个范围，那么会被强制设置为最大或最小时间。默认的Session超时时间是在2 *  tickTime ~ 20 * tickTime
fsync.warningthresholdms	事务日志输出时，如果调用fsync方法超过指定的超时时间，那么会在日志中输出警告信息。默认是1000ms。
autopurge.purgeInterval	在上文中已经提到，3.4.0及之后版本，ZK提供了自动清理事务日志和快照文件的功能，这个参数指定了清理频率，单位是小时，需要配置一个1或更大的整数，默认是0，表示不开启自动清理功能。
autopurge.snapRetainCount	这个参数和上面的参数搭配使用，这个参数指定了需要保留的文件数目。默认是保留3个。
electionAlg	在之前的版本中， 这个参数配置是允许我们选择leader选举算法，但是由于在以后的版本中，只会留下一种“TCP-based version of fast leader election”算法
initLimit	Follower在启动过程中，会从Leader同步所有最新数据，然后确定自己能够对外服务的起始状态。Leader允许F在 initLimit 时间内完成这个工作。通常情况下，我们不用太在意这个参数的设置。如果ZK集群的数据量确实很大了，F在启动的时候，从Leader上同步数据的时间也会相应变长，因此在这种情况下，有必要适当调大这个参数了
syncLimit	在运行过程中，Leader负责与ZK集群中所有机器进行通信，例如通过一些心跳检测机制，来检测机器的存活状态。如果L发出心跳包在syncLimit之后，还没有从F那里收到响应，那么就认为这个F已经不在线了。注意：不要把这个参数设置得过大，否则可能会掩盖一些问题
leaderServes	默认情况下，Leader是会接受客户端连接，并提供正常的读写服务。但是，如果你想让Leader专注于集群中机器的协调，那么可以将这个参数设置为no，这样一来，会大大提高写操作的性能。
server.x=[hostname]:nnnnn[:nnnnn]	这里的x是一个数字，与myid文件中的id是一致的。右边可以配置两个端口，第一个端口用于F和L之间的数据同步和其它通信，第二个端口用于Leader选举过程中投票通信。
group.x=nnnnn[:nnnnn]weight.x=nnnnn	对机器分组和权重设置
cnxTimeout	Leader选举过程中，打开一次连接的超时时间，默认是5s。
zookeeper.DigestAuthenticationProvider.superDigest	ZK权限设置相关
skipACL	对所有客户端请求都不作ACL检查。如果之前节点上设置有权限限制，一旦服务器上打开这个开头，那么也将失效。
forceSync	这个参数确定了是否需要在事务日志提交的时候调用 FileChannel.force来保证数据完全同步到磁盘
jute.maxbuffer	每个节点最大数据量，是默认是1M。这个限制必须在server和client端都进行设置才会生效

storm集群配置
		配置项	配置说明
storm.zookeeper.servers	ZooKeeper服务器列表
storm.zookeeper.port	ZooKeeper连接端口
storm.zookeeper.root	ZooKeeper中Storm的根目录位置
storm.zookeeper.session.timeout	客户端连接ZooKeeper超时时间
storm.local.dir	storm使用的本地文件系统目录(必须存在并且storm进程可读写)
storm.cluster.mode	Storm集群运行模式([distributed,local])
storm.local.mode.zmq	Local模式下是否使用ZeroMQ作消息系统，如果设置为false则使用java消息系统。默认为false
storm.id	运行中拓扑的id,由storm name和一个唯一随机数组成。
nimbus.host	nimbus服务器地址
nimbus.thrift.port	nimbus的thrift监听端口
nimbus.childopts	通过storm-deploy项目部署时指定给nimbus进程的jvm选项
nimbus.task.timeout.secs	心跳超时时间，超时后nimbus会认为task死掉并重分配给另一个地址。
nimbus.monitor.freq.secs	nimbus检查心跳和重分配任务的时间间隔.注意如果是机器宕掉nimbus会立即接管并处理。
nimbus.supervisor.timeout.secs	supervisor的心跳超时时间,一旦超过nimbus会认为该supervisor已死并停止为它分发新任务.
nimbus.task.launch.secs	task启动时的一个特殊超时设置.在启动后第一次心跳前会使用该值来临时替代nimbus.task.timeout.secs.
nimbus.reassign	当发现task失败时nimbus是否重新分配执行。默认为真，不建议修改。
nimbus.file.copy.expiration.secs	nimbus判断上传/下载链接的超时时间，当空闲时间超过该设定时nimbus会认为链接死掉并主动断开
ui.port	Storm UI的服务端口
drpc.servers	DRPC服务器列表，以便DRPCSpout知道和谁通讯
drpc.port	Storm DRPC的服务端口
supervisor.slots.ports	supervisor上能够运行workers的端口列表.每个worker占用一个端口,且每个端口只运行一个worker.通过这项配置可以调整每台机器上运行的worker数.(调整slot数/每机)
supervisor.childopts	在storm-deploy项目中使用,用来配置supervisor守护进程的jvm选项
supervisor.worker.timeout.secs	supervisor中的worker心跳超时时间,一旦超时supervisor会尝试重启worker进程.
supervisor.worker.start.timeout.secs	supervisor初始启动时，worker的心跳超时时间，当超过该时间supervisor会尝试重启worker。因为JVM初始启动和配置会带来的额外消耗，从而使得第一次心跳会超过supervisor.worker.timeout.secs的设定
supervisor.enable	supervisor是否应当运行分配给他的workers.默认为true,该选项用来进行Storm的单元测试,一般不应修改.
supervisor.heartbeat.frequency.secs	supervisor心跳发送频率(多久发送一次)
supervisor.monitor.frequency.secs	supervisor检查worker心跳的频率
worker.childopts	supervisor启动worker时使用的jvm选项.所有的”%ID%”字串会被替换为对应worker的标识符
worker.heartbeat.frequency.secs	worker的心跳发送时间间隔
task.heartbeat.frequency.secs	task汇报状态心跳时间间隔
task.refresh.poll.secs	task与其他tasks之间链接同步的频率.(如果task被重分配,其他tasks向它发送消息需要刷新连接).一般来讲，重分配发生时其他tasks会理解得到通知。该配置仅仅为了防止未通知的情况。
topology.debug	如果设置成true，Storm将记录发射的每条信息。
topology.optimize	master是否在合适时机通过在单个线程内运行多个task以达到优化topologies的目的.
topology.workers	执行该topology集群中应当启动的进程数量.每个进程内部将以线程方式执行一定数目的tasks.topology的组件结合该参数和并行度提示来优化性能
topology.ackers	topology中启动的acker任务数.Acker保存由spout发送的tuples的记录，并探测tuple何时被完全处理.当Acker探测到tuple被处理完毕时会向spout发送确认信息.通常应当根据topology的吞吐量来确定acker的数目，但一般不需要太多.当设置为0时,相当于禁用了消息可靠性,storm会在spout发送tuples后立即进行确认.
topology.message.timeout.secs	topology中spout发送消息的最大处理超时时间.如果一条消息在该时间窗口内未被成功ack,Storm会告知spout这条消息失败。而部分spout实现了失败消息重播功能。
topology.kryo.register	注册到Kryo(Storm底层的序列化框架)的序列化方案列表.序列化方案可以是一个类名,或者是com.esotericsoftware.kryo.Serializer的实现.
topology.skip.missing.kryo.registrations	Storm是否应该跳过它不能识别的kryo序列化方案.如果设置为否task可能会装载失败或者在运行时抛出错误.
topology.max.task.parallelism	在一个topology中能够允许的最大组件并行度.该项配置主要用在本地模式中测试线程数限制.
topology.max.spout.pending	一个spout task中处于pending状态的最大的tuples数量.该配置应用于单个task,而不是整个spouts或topology.
topology.state.synchronization.timeout.secs	组件同步状态源的最大超时时间(保留选项,暂未使用)
topology.stats.sample.rate	用来产生task统计信息的tuples抽样百分比
topology.fall.back.on.java.serialization	topology中是否使用java的序列化方案
zmq.threads	每个worker进程内zeromq通讯用到的线程数
zmq.linger.millis	当连接关闭时,链接尝试重新发送消息到目标主机的持续时长.这是一个不常用的高级选项,基本上可以忽略.
java.library.path	JVM启动(如Nimbus,Supervisor和workers)时的java.library.path设置.该选项告诉JVM在哪些路径下定位本地库.

defaults.yaml	 
 
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

 
########### These all have default values as shown

########### Additional configuration goes into storm.yaml


java.library.path: "/usr/local/lib:/opt/local/lib:/usr/lib"

 
### storm.* configs are general configurations

# the local dir is where jars are kept

storm.local.dir: "storm-local"

storm.zookeeper.servers:

    - "localhost"

storm.zookeeper.port: 2181

storm.zookeeper.root: "/storm"

storm.zookeeper.session.timeout: 20000

storm.zookeeper.connection.timeout: 15000

storm.zookeeper.retry.times: 5

storm.zookeeper.retry.interval: 1000

storm.zookeeper.retry.intervalceiling.millis: 30000

storm.zookeeper.auth.user: null

storm.zookeeper.auth.password: null

storm.cluster.mode: "distributed"

# can be distributed or local

storm.local.mode.zmq: false

storm.thrift.transport: "backtype.storm.security.auth.SimpleTransportPlugin"

storm.principal.tolocal: "backtype.storm.security.auth.DefaultPrincipalToLocal"

storm.group.mapping.service: "backtype.storm.security.auth.ShellBasedGroupsMapping"

storm.messaging.transport: "backtype.storm.messaging.netty.Context"

storm.nimbus.retry.times: 5

storm.nimbus.retry.interval.millis: 2000

storm.nimbus.retry.intervalceiling.millis: 60000

storm.auth.simple-white-list.users: []

storm.auth.simple-acl.users: []

storm.auth.simple-acl.users.commands: []

storm.auth.simple-acl.admins: []

storm.meta.serialization.delegate: "backtype.storm.serialization.DefaultSerializationDelegate"

 
### nimbus.* configs are for the master

nimbus.host: "localhost"

nimbus.thrift.port: 6627

nimbus.thrift.threads: 64

nimbus.thrift.max_buffer_size: 1048576

nimbus.childopts: "-Xmx1024m"

nimbus.task.timeout.secs: 30

nimbus.supervisor.timeout.secs: 60

nimbus.monitor.freq.secs: 10

nimbus.cleanup.inbox.freq.secs: 600

nimbus.inbox.jar.expiration.secs: 3600

nimbus.task.launch.secs: 120

nimbus.reassign: true

nimbus.file.copy.expiration.secs: 600

nimbus.topology.validator: "backtype.storm.nimbus.DefaultTopologyValidator"

nimbus.credential.renewers.freq.secs: 600

 
### ui.* configs are for the master

ui.port: 8080

ui.childopts: "-Xmx768m"

ui.actions.enabled: true

ui.filter: null

ui.filter.params: null

ui.users: null

ui.header.buffer.bytes: 4096

ui.http.creds.plugin: backtype.storm.security.auth.DefaultHttpCredentialsPlugin

 
logviewer.port: 8000

logviewer.childopts: "-Xmx128m"

logviewer.cleanup.age.mins: 10080

logviewer.appender.name: "A1"


logs.users: null

 
drpc.port: 3772

drpc.worker.threads: 64

drpc.max_buffer_size: 1048576

drpc.queue.size: 128

drpc.invocations.port: 3773

drpc.invocations.threads: 64

drpc.request.timeout.secs: 600

drpc.childopts: "-Xmx768m"

drpc.http.port: 3774

drpc.https.port: -1

drpc.https.keystore.password: ""

drpc.https.keystore.type: "JKS"

drpc.http.creds.plugin: backtype.storm.security.auth.DefaultHttpCredentialsPlugin

drpc.authorizer.acl.filename: "drpc-auth-acl.yaml"

drpc.authorizer.acl.strict: false

 
transactional.zookeeper.root: "/transactional"

transactional.zookeeper.servers: null

transactional.zookeeper.port: null

 
### supervisor.* configs are for node supervisors

# Define the amount of workers that can be run on this machine. Each worker is assigned a port to use for communication

supervisor.slots.ports:

    - 6700

    - 6701

    - 6702

    - 6703

supervisor.childopts: "-Xmx256m"

supervisor.run.worker.as.user: false

#how long supervisor will wait to ensure that a worker process is started

supervisor.worker.start.timeout.secs: 120

#how long between heartbeats until supervisor considers that worker dead and tries to restart it

supervisor.worker.timeout.secs: 30

#how frequently the supervisor checks on the status of the processes it's monitoring and restarts if necessary

supervisor.monitor.frequency.secs: 3

#how frequently the supervisor heartbeats to the cluster state (for nimbus)

supervisor.heartbeat.frequency.secs: 5

supervisor.enable: true

supervisor.supervisors: []

supervisor.supervisors.commands: []

 
### worker.* configs are for task workers

worker.childopts: "-Xmx768m"

worker.gc.childopts: ""

worker.heartbeat.frequency.secs: 1

 

# control how many worker receiver threads we need per worker

topology.worker.receiver.thread.count: 1

 
task.heartbeat.frequency.secs: 3

task.refresh.poll.secs: 10

task.credentials.poll.secs: 30

 
zmq.threads: 1

zmq.linger.millis: 5000

zmq.hwm: 0


storm.messaging.netty.server_worker_threads: 1

storm.messaging.netty.client_worker_threads: 1

storm.messaging.netty.buffer_size: 5242880 #5MB buffer

# Since nimbus.task.launch.secs and supervisor.worker.start.timeout.secs are 120, other workers should also wait at least that long before giving up on connecting to the other worker.

storm.messaging.netty.max_retries: 300

storm.messaging.netty.max_wait_ms: 1000

storm.messaging.netty.min_wait_ms: 100


# If the Netty messaging layer is busy(netty internal buffer not writable), the Netty client will try to batch message as more as possible up to the size of storm.messaging.netty.transfer.batch.size bytes, otherwise it will try to flush message as soon as possible to reduce latency.

storm.messaging.netty.transfer.batch.size: 262144

 
# We check with this interval that whether the Netty channel is writable and try to write pending messages if it is.

storm.messaging.netty.flush.check.interval.ms: 10

 

# By default, the Netty SASL authentication is set to false.  Users can override and set it true for a specific topology.

storm.messaging.netty.authentication: false

 
# default number of seconds group mapping service will cache user group

storm.group.mapping.service.cache.duration.secs: 120

 
### topology.* configs are for specific executing storms

topology.enable.message.timeouts: true

topology.debug: false

topology.workers: 1

topology.acker.executors: null

topology.tasks: null

# maximum amount of time a message has to complete before it's considered failed

topology.message.timeout.secs: 30

topology.multilang.serializer: "backtype.storm.multilang.JsonSerializer"

topology.skip.missing.kryo.registrations: false

topology.max.task.parallelism: null

topology.max.spout.pending: null

topology.state.synchronization.timeout.secs: 60

topology.stats.sample.rate: 0.05

topology.builtin.metrics.bucket.size.secs: 60

topology.fall.back.on.java.serialization: true

topology.worker.childopts: null

topology.executor.receive.buffer.size: 1024 #batched

topology.executor.send.buffer.size: 1024 #individual messages

topology.receiver.buffer.size: 8 # setting it too high causes a lot of problems (heartbeat thread gets starved, throughput plummets)

topology.transfer.buffer.size: 1024 # batched

topology.tick.tuple.freq.secs: null

topology.worker.shared.thread.pool.size: 4

topology.disruptor.wait.strategy: "com.lmax.disruptor.BlockingWaitStrategy"

topology.spout.wait.strategy: "backtype.storm.spout.SleepSpoutWaitStrategy"

topology.sleep.spout.wait.strategy.time.ms: 1

topology.error.throttle.interval.secs: 10

topology.max.error.report.per.interval: 5

topology.kryo.factory: "backtype.storm.serialization.DefaultKryoFactory"

topology.tuple.serializer: "backtype.storm.serialization.types.ListDelegateSerializer"

topology.trident.batch.emit.interval.millis: 500

topology.testing.always.try.serialize: false

topology.classpath: null

topology.environment: null

topology.bolts.outgoing.overflow.buffer.enable: false

dev.zookeeper.path: "/tmp/dev-storm-zookeeper"

Kafka配置
		producer.properties
#指定kafka节点列表，用于获取metadata，不必全部指定
#需要kafka的服务器地址，来获取每一个topic的分片数等元数据信息。
metadata.broker.list=kafka01:9092,kafka02:9092,kafka03:9092
#生产者生产的消息被发送到哪个block，需要一个分组策略。
#指定分区处理类。默认kafka.producer.DefaultPartitioner，表通过key哈希到对应分区
#partitioner.class=kafka.producer.DefaultPartitioner
#生产者生产的消息可以通过一定的压缩策略（或者说压缩算法）来压缩。消息被压缩后发送到broker集群，
#而broker集群是不会进行解压缩的，broker集群只会把消息发送到消费者集群，然后由消费者来解压缩。
#是否压缩，默认0表示不压缩，1表示用gzip压缩，2表示用snappy压缩。
#压缩后消息中会有头来指明消息压缩类型，故在消费者端消息解压是透明的无需指定。
#文本数据会以1比10或者更高的压缩比进行压缩。
compression.codec=none
#指定序列化处理类，消息在网络上传输就需要序列化，它有String、数组等许多种实现。
serializer.class=kafka.serializer.DefaultEncoder
#如果要压缩消息，这里指定哪些topic要压缩消息，默认empty，表示不压缩。
#如果上面启用了压缩，那么这里就需要设置
#compressed.topics=
#这是消息的确认机制，默认值是0。在面试中常被问到。
#producer有个ack参数，有三个值，分别代表：
#（1）不在乎是否写入成功；0
#（2）写入leader成功；1
#（3）写入leader和所有副本都成功；-1
#要求非常可靠的话可以牺牲性能设置成最后一种。
#为了保证消息不丢失，至少要设置为1，也就是说至少保证leader将消息保存成功。
#设置发送数据是否需要服务端的反馈,有三个值0,1,-1，分别代表3种状态：
#0: producer不会等待broker发送ack。生产者只要把消息发送给broker之后，就认为发送成功了，这是第1种情况；
#1: 当leader接收到消息之后发送ack。生产者把消息发送到broker之后，并且消息被写入到本地文件，才认为发送成功，这是第2种情况；
#-1: 当所有的follower都同步消息成功后发送ack。不仅是主的分区将消息保存成功了，而且其所有的分区的副本数也都同步好了，才会被认为发动成功，这是第3种情况。
request.required.acks=0
#broker必须在该时间范围之内给出反馈，否则失败。
#在向producer发送ack之前,broker允许等待的最大时间 ，如果超时,
#broker将会向producer发送一个error ACK.意味着上一次消息因为某种原因
#未能成功(比如follower未能同步成功)
request.timeout.ms=10000
#生产者将消息发送到broker，有两种方式，一种是同步，表示生产者发送一条，broker就接收一条；
#还有一种是异步，表示生产者积累到一批的消息，装到一个池子里面缓存起来，再发送给broker，
#这个池子不会无限缓存消息，在下面，它分别有一个时间限制（时间阈值）和一个数量限制（数量阈值）的参数供我们来设置。
#一般我们会选择异步。
#同步还是异步发送消息，默认“sync”表同步，"async"表异步。异步可以提高发送吞吐量,
#也意味着消息将会在本地buffer中,并适时批量发送，但是也可能导致丢失未发送过去的消息
producer.type=sync
#在async模式下,当message被缓存的时间超过此值后,将会批量发送给broker,
#默认为5000ms
#此值和batch.num.messages协同工作.
queue.buffering.max.ms = 5000
#异步情况下，缓存中允许存放消息数量的大小。
#在async模式下,producer端允许buffer的最大消息量
#无论如何,producer都无法尽快的将消息发送给broker,从而导致消息在producer端大量沉积
#此时,如果消息的条数达到阀值,将会导致producer端阻塞或者消息被抛弃，默认为10000条消息。
queue.buffering.max.messages=20000
#如果是异步，指定每次批量发送数据量，默认为200
batch.num.messages=500
#在生产端的缓冲池中，消息发送出去之后，在没有收到确认之前，该缓冲池中的消息是不能被删除的，
#但是生产者一直在生产消息，这个时候缓冲池可能会被撑爆，所以这就需要有一个处理的策略。
#有两种处理方式，一种是让生产者先别生产那么快，阻塞一下，等会再生产；另一种是将缓冲池中的消息清空。
#当消息在producer端沉积的条数达到"queue.buffering.max.meesages"后阻塞一定时间后,
#队列仍然没有enqueue(producer仍然没有发送出任何消息)
#此时producer可以继续阻塞或者将消息抛弃,此timeout值用于控制"阻塞"的时间
#-1: 不限制阻塞超时时间，让produce一直阻塞,这个时候消息就不会被抛弃
#0: 立即清空队列,消息被抛弃
queue.enqueue.timeout.ms=-1
#当producer接收到error ACK,或者没有接收到ACK时,允许消息重发的次数
#因为broker并没有完整的机制来避免消息重复,所以当网络异常时(比如ACK丢失)
#有可能导致broker接收到重复的消息,默认值为3.
message.send.max.retries=3
#producer刷新topic metada的时间间隔,producer需要知道partition leader
#的位置,以及当前topic的情况
#因此producer需要一个机制来获取最新的metadata,当producer遇到特定错误时,
#将会立即刷新
#(比如topic失效,partition丢失,leader失效等),此外也可以通过此参数来配置
#额外的刷新机制，默认值600000
topic.metadata.refresh.interval.ms=60000

consumer.properties

#消费者集群通过连接Zookeeper来找到broker。

#zookeeper连接服务器地址

zookeeper.connect=zk01:2181,zk02:2181,zk03:2181

#zookeeper的session过期时间，默认5000ms，用于检测消费者是否挂掉

zookeeper.session.timeout.ms=5000

#当消费者挂掉，其他消费者要等该指定时间才能检查到并且触发重新负载均衡

zookeeper.connection.timeout.ms=10000

#这是一个时间阈值。

#指定多久消费者更新offset到zookeeper中。

#注意offset更新时基于time而不是每次获得的消息。

#一旦在更新zookeeper发生异常并重启，将可能拿到已拿到过的消息

zookeeper.sync.time.ms=2000

#指定消费

group.id=xxxxx

#这是一个数量阈值，经测试是500条。

#当consumer消费一定量的消息之后,将会自动向zookeeper提交offset信息#注意offset信息并不是每消费一次消息就向zk提交

#一次,而是现在本地保存(内存),并定期提交,默认为true

auto.commit.enable=true

# 自动更新时间。默认60 * 1000

auto.commit.interval.ms=1000

# 当前consumer的标识,可以设定,也可以有系统生成,

#主要用来跟踪消息消费情况,便于观察

conusmer.id=xxx

# 消费者客户端编号，用于区分不同客户端，默认客户端程序自动产生

client.id=xxxx

# 最大取多少块缓存到消费者(默认10)

queued.max.message.chunks=50

# 当有新的consumer加入到group时,将会reblance,此后将会

#有partitions的消费端迁移到新  的consumer上,如果一个

#consumer获得了某个partition的消费权限,那么它将会向zk

#注册 "Partition Owner registry"节点信息,但是有可能

#此时旧的consumer尚没有释放此节点, 此值用于控制,

#注册节点的重试次数.

rebalance.max.retries=5

#每拉取一批消息的最大字节数

#获取消息的最大尺寸,broker不会像consumer输出大于

#此值的消息chunk 每次feth将得到多条消息,此值为总大小,

#提升此值,将会消耗更多的consumer端内存

fetch.min.bytes=6553600

#当消息的尺寸不足时,server阻塞的时间,如果超时,

#消息将立即发送给consumer

#数据一批一批到达，如果每一批是10条消息，如果某一批还

#不到10条，但是超时了，也会立即发送给consumer。

fetch.wait.max.ms=5000

socket.receive.buffer.bytes=655360

# 如果zookeeper没有offset值或offset值超出范围。

#那么就给个初始的offset。有smallest、largest、

#anything可选，分别表示给当前最小的offset、

#当前最大的offset、抛异常。默认largest

auto.offset.reset=smallest

# 指定序列化处理类

derializer.class=kafka.serializer.DefaultDecoder

server.properties

#broker的全局唯一编号，不能重复

broker.id=0

#用来监听链接的端口，producer或consumer将在此端口建立连接

port=9092

#处理网络请求的线程数量，也就是接收消息的线程数。

#接收线程会将接收到的消息放到内存中，然后再从内存中写入磁盘。

num.network.threads=3

#消息从内存中写入磁盘是时候使用的线程数量。

#用来处理磁盘IO的线程数量

num.io.threads=8

#发送套接字的缓冲区大小

socket.send.buffer.bytes=102400

#接受套接字的缓冲区大小

socket.receive.buffer.bytes=102400

#请求套接字的缓冲区大小

socket.request.max.bytes=104857600

#kafka运行日志存放的路径

log.dirs=/export/servers/logs/kafka

#topic在当前broker上的分片个数

num.partitions=2

#我们知道segment文件默认会被保留7天的时间，超时的话就

#会被清理，那么清理这件事情就需要有一些线程来做。这里就是

#用来设置恢复和清理data下数据的线程数量

num.recovery.threads.per.data.dir=1

#segment文件保留的最长时间，默认保留7天（168小时），

#超时将被删除，也就是说7天之前的数据将被清理掉。

log.retention.hours=168

#滚动生成新的segment文件的最大时间

log.roll.hours=168

#日志文件中每个segment的大小，默认为1G

log.segment.bytes=1073741824

#上面的参数设置了每一个segment文件的大小是1G，那么

#就需要有一个东西去定期检查segment文件有没有达到1G，

#多长时间去检查一次，就需要设置一个周期性检查文件大小

#的时间（单位是毫秒）。

log.retention.check.interval.ms=300000

#日志清理是否打开

log.cleaner.enable=true

#broker需要使用zookeeper保存meta数据

zookeeper.connect=zk01:2181,zk02:2181,zk03:2181

#zookeeper链接超时时间

zookeeper.connection.timeout.ms=6000

#上面我们说过接收线程会将接收到的消息放到内存中，然后再从内存

#写到磁盘上，那么什么时候将消息从内存中写入磁盘，就有一个

#时间限制（时间阈值）和一个数量限制（数量阈值），这里设置的是

#数量阈值，下一个参数设置的则是时间阈值。

#partion buffer中，消息的条数达到阈值，将触发flush到磁盘。

log.flush.interval.messages=10000

#消息buffer的时间，达到阈值，将触发将消息从内存flush到磁盘，

#单位是毫秒。

log.flush.interval.ms=3000

#删除topic需要server.properties中设置delete.topic.enable=true否则只是标记删除

delete.topic.enable=true

#此处的host.name为本机IP(重要),如果不改,则客户端会抛出:

#Producer connection to localhost:9092 unsuccessful 错误!

host.name=kafka01

advertised.host.name=192.168.239.128