目录
一、Broker配置
关于broker配置的详情，可以查看scala类中的 kafka.server.KafkaConfig。
| 名称 | 描述 | 类型 | 默认值 | 有效值 | 重要性 |
|---|---|---|---|---|---|
| zookeeper.connect | Zookeeper主机地址 | string | 高 | ||
| advertised.host.name | 不建议:仅在未设置`advertised.listeners` 或 `listeners`时使用。用`advertised.listeners`替换。 主机名发布到zookeeper供客户端使用。在IaaS环境,这可能需要与broker绑定不通的端口。如果未设置,将使用`host.name`的值（如果已经配置）。否则，他将使用java.net.InetAddress.getCanonicalHostName()返回的值。 | string | null | 高 | |
| advertised.listeners | 监听器发布到ZooKeeper供客户端使用，如果与`listeners`配置不同。在IaaS环境,这可能需要与broker绑定不通的接口。如果没有设置，将使用`listeners`的配置。与`listeners`不同的是，配置0.0.0.0元地址是无效的。 | string | null | 高 | |
| advertised.port | 不建议:仅在未设置“advertised.listeners”或“listeners”时使用。使用`advertised.listeners`代替。 这个端口发布到ZooKeeper供客户端使用。在IaaS环境，这可能需要与broker绑定不通的端口。如果没有设置，它将绑定和broker相同的端口。 | int | null | 高 | |
| auto.create.topics.enable | 是否允许在服务器上自动创建topic | boolean | true | 高 | |
| auto.leader.rebalance.enable | 是否允许leader平衡。后台线程会定期检查并触发leader平衡。 | boolean | true | 高 | |
| background.threads | 用于处理各种后台任务的线程数量 | int | 10 | [1,...] | 高 |
| broker.id | 用于服务的broker id。如果没设置，将生存一个唯一broker id。为了避免ZooKeeper生成的id和用户配置的broker id相冲突，生成的id将在reserved.broker.max.id的值基础上加1。 | int | -1 | 高 | |
| compression.type | 为特点的topic指定一个最终压缩类型。此配置接受的标准压缩编码方式有（'gzip', 'snappy', 'lz4'）。此外还有'uncompressed'相当于不压缩；'producer'意味着压缩类型由'producer'决定。 | string | producer | 高 | |
| delete.topic.enable | 是否允许删除topic。如果关闭此配置，通过管理工具删除topic将不再生效。 | boolean | true | 高 | |
| host.name | 不建议: 仅在未设置`listeners`时使用。使用`listeners`来代替。 如果设置了broker主机名，则他只会当定到这个地址。如果没设置，将绑定到所有接口。 | string | "" | 高 | |
| leader.imbalance.check.interval.seconds | 由控制器触发分区重新平衡检查的频率设置 | long | 300 | 高 | |
| leader.imbalance.per.broker.percentage | 每个broker允许的不平衡的leader的百分比，如果高于这个比值将触发leader进行平衡。这个值用百分比来指定。 | int | 10 | 高 | |
| listeners | 监听器列表 - 使用逗号分隔URI列表和监听器名称。如果侦听器名称不是安全协议，则还必须设置listener.security.protocol.map。指定主机名为0.0.0.0来绑定到所有接口。留空则绑定到默认接口上。合法监听器列表的示例：PLAINTEXT：// myhost：9092，SSL：//：9091 CLIENT：//0.0.0.0：9092，REPLICATION：// localhost：9093 | string | null | 高 | |
| log.dir | 保存日志数据的目录（对log.dirs属性的补充） | string | /tmp/kafka-logs | 高 | |
| log.dirs | 保存日志数据的目录，如果未设置将使用log.dir的配置。 | string | null | 高 | |
| log.flush.interval.messages | 在将消息刷新到磁盘之前，在日志分区上累积的消息数量。 | long | 9223372036854775807 | [1,...] | 高 |
| log.flush.interval.ms | 在刷新到磁盘之前，任何topic中的消息保留在内存中的最长时间（以毫秒为单位）。如果未设置，则使用log.flush.scheduler.interval.ms中的值。 | long | null | 高 | |
| log.flush.offset.checkpoint.interval.ms | 日志恢复点的最后一次持久化刷新记录的频率 | int | 60000 | [0,...] | 高 |
| log.flush.scheduler.interval.ms | 日志刷新器检查是否需要将所有日志刷新到磁盘的频率（以毫秒为单位） | long | 9223372036854775807 | 高 | |
| log.flush.start.offset.checkpoint.interval.ms | 我们更新日志持久化记录开始offset的频率 | int | 60000 | [0,...] | 高 |
| log.retention.bytes | 日志删除的大小阈值 | long | -1 | 高 | |
| log.retention.hours | 日志删除的时间阈值（小时为单位） | int | 168 | 高 | |
| log.retention.minutes | 日志删除的时间阈值（分钟为单位），如果未设置，将使用log.retention.hours的值 | int | null | 高 | |
| log.retention.ms | 日志删除的时间阈值（毫秒为单位），如果未设置，将使用log.retention.minutes的值 | long | null | 高 | |
| log.roll.hours | 新日志段轮转时间间隔（小时为单位），次要配置为log.roll.ms | int | 168 | [1,...] | 高 |
| log.roll.jitter.hours | 从logrolltimemillis（以小时计）中减去的最大抖动，次要配置log.roll.jitter.ms | int | 0 | [0,...] | 高 |
| log.roll.jitter.ms | 从logrolltimemillis（以毫秒计）中减去的最大抖动，如果未设置，则使用log.roll.jitter.hours的配置 | long | null | 高 | |
| log.roll.ms | 新日志段轮转时间间隔（毫秒为单位），如果未设置，则使用log.roll.hours配置 | long | null | 高 | |
| log.segment.bytes | 单个日志段文件最大大小 | int | 1073741824 | [14,...] | 高 |
| log.segment.delete.delay.ms | 从文件系统中删除一个日志段文件前的保留时间 | long | 60000 | [0,...] | 高 |
| message.max.bytes | kafka允许的最大的一个批次的消息大小。 如果这个数字增加，且有0.10.2版本以下的consumer，那么consumer的提取大小也必须增加，以便他们可以取得这么大的记录批次。 在最新的消息格式版本中，记录总是被组合到一个批次以提高效率。 在以前的消息格式版本中，未压缩的记录不会分组到批次中，并且此限制仅适用于该情况下的单个记录。 可以使用topic设置`max.message.bytes`来设置每个topic。 | int | 1000012 | [0,...] | 高 |
| min.insync.replicas | 当producer将ack设置为“全部”（或“-1”）时，min.insync.replicas指定了被认为写入成功的最小副本数。如果这个最小值不能满足，那么producer将会引发一个异常（NotEnoughReplicas或NotEnoughReplicasAfterAppend）。当一起使用时，min.insync.replicas和acks允许您强制更大的耐久性保证。 一个经典的情况是创建一个复本数为3的topic，将min.insync.replicas设置为2，并且producer使用“all”选项。 这将确保如果大多数副本没有写入producer则抛出异常。 | int | 1 | [1,...] | 高 |
| num.io.threads | 服务器用于处理请求的线程数，可能包括磁盘I/O | int | 8 | [1,...] | 高 |
| num.network.threads | 服务器用于从接收网络请求并发送网络响应的线程数 | int | 3 | [1,...] | 高 |
| num.recovery.threads.per.data.dir | 每个数据目录，用于启动时日志恢复和关闭时刷新的线程数 | int | 1 | [1,...] | 高 |
| num.replica.fetchers | 从源broker复制消息的拉取器的线程数。增加这个值可以增加follow broker的I/O并行度。 | int | 1 | 高 | |
| offset.metadata.max.bytes | 与offset提交相关联的元数据条目的最大大小 | int | 4096 | 高 | |
| offsets.commit.required.acks | 在offset提交可以接受之前，需要设置acks的数目，一般不需要更改，默认值为-1。 | short | -1 | 高 | |
| offsets.commit.timeout.ms | offset提交将延迟到topic所有副本收到提交或超时。这与producer请求超时类似。 | int | 5000 | [1,...] | 高 |
| offsets.load.buffer.size | 每次从offset段文件往缓存加载时，批量读取的数据大小 | int | 5242880 | [1,...] | 高 |
| offsets.retention.check.interval.ms | 检查失效offset的频率 | long | 600000 | [1,...] | 高 |
| offsets.retention.minutes | 超过这个保留期限未提交的offset将被丢弃 | int | 1440 | [1,...] | 高 |
| offsets.topic.compression.codec | 用于offsets topic的压缩编解码器 - 压缩可用于实现“原子”提交 | int | 0 | 高 | |
| offsets.topic.num.partitions | Offsets topic的分区数量（部署后不应更改） | int | 50 | [1,...] | 高 |
| offsets.topic.replication.factor | offset topic的副本数（设置的越大，可用性越高）。内部topic创建将失败，直到集群大小满足此副本数要求。 | short | 3 | [1,...] | 高 |
| offsets.topic.segment.bytes | 为了便于更快的日志压缩和缓存加载，offset topic段字节应该保持相对较小 | int | 104857600 | [1,...] | 高 |
| port | 不建议: 仅在未设置“listener”时使用。使用`listeners`来代替。端口用来来监听和接受连接 | int | 9092 | 高 | |
| queued.max.requests | 网络线程阻塞前队列允许的最大请求数 | int | 500 | [1,...] | 高 |
| quota.consumer.default | 不建议:仅在动态默认配额未配置或在zookeeper中使用。任何由clientid区分开来的consumer，如果它每秒产生的字节数多于这个值，就会受到限制 | long | 9223372036854775807 | [1,...] | 高 |
| quota.producer.default | 不建议:仅在动态默认配额未配置或在zookeeper中使用。任何由clientid区分开来的producer，如果它每秒产生的字节数多于这个值，就会受到限制 | long | 9223372036854775807 | [1,...] | 高 |
| replica.fetch.min.bytes | 复制数据过程中，replica收到的每个fetch响应，期望的最小的字节数，如果没有收到足够的字节数，就会等待更多的数据，直到达到replicaMaxWaitTimeMs（复制数据超时时间） | int | 1 | 高 | |
| replica.fetch.wait.max.ms | 副本follow同leader之间通信的最大等待时间，失败了会重试。 此值始终应始终小于replica.lag.time.max.ms，以防止针对低吞吐量topic频繁收缩ISR | int | 500 | 高 | |
| replica.high.watermark.checkpoint.interval.ms | high watermark被保存到磁盘的频率，用来标记日后恢复点/td> | long | 5000 | 高 | |
| replica.lag.time.max.ms | 如果一个follower在这个时间内没有发送fetch请求或消费leader日志到结束的offset，leader将从ISR中移除这个follower，并认为这个follower已经挂了 | long | 10000 | 高 | |
| replica.socket.receive.buffer.bytes | socket接收网络请求的缓存大小 | int | 65536 | 高 | |
| replica.socket.timeout.ms | 副本复制数据过程中，发送网络请求的socket超时时间。这个值应该大于replica.fetch.wait.max.ms的值 | int | 30000 | 高 | |
| request.timeout.ms | 该配置控制客户端等待请求响应的最长时间。如果在超时之前未收到响应，则客户端将在必要时重新发送请求，如果重试仍然失败，则请求失败。 | int | 30000 | 高 | |
| socket.receive.buffer.bytes | 服务端用来处理socket连接的SO_RCVBUFF缓冲大小。如果值为-1，则使用系统默认值。 | int | 102400 | 高 | |
| socket.request.max.bytes | socket请求的最大大小，这是为了防止server跑光内存，不能大于Java堆的大小。 | int | 104857600 | [1,...] | 高 |
| socket.send.buffer.bytes | 服务端用来处理socket连接的SO_SNDBUF缓冲大小。如果值为-1，则使用系统默认值。 | int | 102400 | 高 | |
| transaction.max.timeout.ms | 事务允许的最大超时时间。如果客户请求的事务超时，那么broker将在InitProducerIdRequest中返回一错误。 这样可以防止客户超时时间过长，从而阻碍consumers读取事务中包含的topic。 | int | 900000 | [1,...] | 高 |
| transaction.state.log.load.buffer.size | 将producer ID和事务加载到高速缓存中时，从事务日志段（the transaction log segments）中批量读取的大小。 | int | 5242880 | [1,...] | 高 |
| transaction.state.log.min.isr | 覆盖事务topic的min.insync.replicas配置 | int | 2 | [1,...] | 高 |
| transaction.state.log.num.partitions | 事务topic的分区数（部署后不应该修改） | int | 50 | [1,...] | 高 |
| transaction.state.log.replication.factor | 事务topic的副本数（设置的越大，可用性越高）。内部topic在集群数满足副本数之前，将会一直创建失败。 | short | 3 | [1,...] | 高 |
| transaction.state.log.segment.bytes | 事务topic段应保持相对较小，以便于更快的日志压缩和缓存负载。 | int | 104857600 | [1,...] | 高 |
| transactional.id.expiration.ms | 事务协调器在未收到任何事务状态更新之前，主动设置producer的事务标识为过期之前将等待的最长时间（以毫秒为单位） | int | 604800000 | [1,...] | 高 |
| unclean.leader.election.enable | 指定副本是否能够不再ISR中被选举为leader，即使这样可能会丢数据 | boolean | false | 高 | |
| zookeeper.connection.timeout.ms | 与ZK server建立连接的超时时间,没有配置就使用zookeeper.session.timeout.ms | int | null | 高 | |
| zookeeper.session.timeout.ms | ZooKeeper的session的超时时间 | int | 6000 | 高 | |
| zookeeper.set.acl | ZooKeeper客户端连接是否设置ACL安全y安装 | boolean | false | 高 | |
| broker.id.generation.enable | 是否允许服务器自动生成broker.id。如果允许则产生的值会交由reserved.broker.max.id审核 | boolean | true | 中 | |
| broker.rack | broker的机架位置。 这将在机架感知副本分配中用于容错。例如：RACK1，us-east-1 | string | null | 中 | |
| connections.max.idle.ms | 连接空闲超时：服务器socket处理线程空闲超时关闭时间 | long | 600000 | 中 | |
| controlled.shutdown.enable | 是否允许服务器关闭broker服务 | boolean | true | 中 | |
| controlled.shutdown.max.retries | 当发生失败故障时，由于各种原因导致关闭服务的次数 | int | 3 | 中 | |
| controlled.shutdown.retry.backoff.ms | 在每次重试关闭之前，系统需要时间从上次故障状态（控制器故障切换，副本延迟等）中恢复。 这个配置决定了重试之前等待的时间。 | long | 5000 | 中 | |
| controller.socket.timeout.ms | 控制器到broker通道的socket超时时间 | int | 30000 | 中 | |
| default.replication.factor | 自动创建topic时的默认副本个数 | int | 1 | 中 | |
| delete.records.purgatory.purge.interval.requests | 删除purgatory中请求的清理间隔时间（purgatory：broker对于无法立即处理的请求，将会放在purgatory中，当请求完成后，并不会立即清除，还会继续在purgatory中占用资源，直到下一次delete.records.purgatory.purge.interval.requests） | int | 1 | 中 | |
| fetch.purgatory.purge.interval.requests | 提取purgatory中请求的间隔时间 | int | 1000 | 中 | |
| group.initial.rebalance.delay.ms | 在执行第一次重新平衡之前，group协调器将等待更多consumer加入group的时间。延迟时间越长意味着重新平衡的工作可能越小，但是等待处理开始的时间增加。 | int | 3000 | 中 | |
| group.max.session.timeout.ms | consumer注册允许的最大会话超时时间。超时时间越短，处理心跳越频繁从而使故障检测更快，但会导致broker被抢占更多的资源。 | int | 300000 | medium | |
| group.min.session.timeout.ms | consumer注册允许的最小会话超时时间。超时时间越短，处理心跳越频繁从而使故障检测更快，但会导致broker被抢占更多的资源。 | int | 6000 | 中 | |
| inter.broker.listener.name | broker间通讯的监听器名称。如果未设置，则侦听器名称由security.inter.broker.protocol定义。 同时设置此项和security.inter.broker.protocol属性是错误的，只设置一个。 | string | null | 中 | |
| inter.broker.protocol.version | 指定使用哪个版本的 inter-broker 协议。 在所有broker升级到新版本之后，这通常会有冲突。一些有效的例子是：0.8.0, 0.8.1, 0.8.1.1, 0.8.2, 0.8.2.0, 0.8.2.1, 0.9.0.0, 0.9.0.1，详情可以检查apiversion的完整列表 | string | 1.0-IV0 | 中 | |
| log.cleaner.backoff.ms | 检查log是否需要清除的时间间隔。 | long | 15000 | [0,...] | 中 |
| log.cleaner.dedupe.buffer.size | 日志去重清理线程所需要的内存 | long | 134217728 | 中 | |
| log.cleaner.delete.retention.ms | 日志记录保留时间 | long | 86400000 | 中 | |
| log.cleaner.enable | 在服务器上启用日志清理器进程。如果任何topic都使用cleanup.policy = compact，包括内部topic offset，则建议开启。如果被禁用的话，这些topic将不会被压缩，而且会不断增长。 | boolean | true | 中 | |
| log.cleaner.io.buffer.load.factor | 日志清理器去重的缓存负载数。完全重复数据的缓存比例可以改变。数值越高，清理的越多，但会导致更多的hash冲突 | double | 0.9 | 中 | |
| log.cleaner.io.buffer.size | 所有清理线程的日志清理I/O缓存区所需要的内存 | int | 524288 | [0,...] | 中 |
| log.cleaner.io.max.bytes.per.second | 日志清理器受到的大小限制数，因此它的I/O读写总和将小于平均值 | double | 1.7976931348623157E308 | 中 | |
| log.cleaner.min.cleanable.ratio | 日志中脏数据清理比例 | double | 0.5 | 中 | |
| log.cleaner.min.compaction.lag.ms | 消息在日志中保持未压缩的最短时间。 仅适用于正在压缩的日志。 | long | 0 | 中 | |
| log.cleaner.threads | 用于日志清理的后台线程的数量 | int | 1 | [0,...] | 中 |
| log.cleanup.policy | 超出保留窗口期的日志段的默认清理策略。用逗号隔开有效策略列表。有效策略：“delete”和“compact” | list | delete | [compact, delete] | 中 |
| log.index.interval.bytes | 添加offset索引字段大小间隔（设置越大，代表扫描速度越快，但是也更耗内存） | int | 4096 | [0,...] | 中 |
| log.index.size.max.bytes | offset索引的最大字节数 | int | 10485760 | [4,...] | 中 |
| log.message.format.version | 指定broker用于将消息附加到日志的消息格式版本。应该是一个有效的apiversion值。例如：0.8.2，0.9.0.0，0.10.0，详情去看apiversion。通过设置特定的消息格式版本，用户得保证磁盘上的所有现有消息的版本小于或等于指定的版本。不正确地设置这个值会导致旧版本的用户出错，因为他们将接收到他们无法处理的格式消息。 | string | 1.0-IV0 | 中 | |
| log.message.timestamp.difference.max.ms | broker收到消息时的时间戳和消息中指定的时间戳之间允许的最大差异。当log.message.timestamp.type=CreateTime,如果时间差超过这个阈值，消息将被拒绝。如果log.message.timestamp.type = logappendtime，则该配置将被忽略。允许的最大时间戳差值，不应大于log.retention.ms，以避免不必要的频繁日志滚动。 | long | 9223372036854775807 | 中 | |
| log.message.timestamp.type | 定义消息中的时间戳是消息创建时间还是日志追加时间。 该值应该是“createtime”或“logappendtime”。 | string | CreateTime | [CreateTime, LogAppendTime] | 中 |
| log.preallocate | 创建新的日志段前是否应该预先分配文件？如果你在windows上使用kafka，你可能需要打开个这个选项 | boolean | false | 中 | |
| log.retention.check.interval.ms | 日志清理器检查是否有日志符合删除的频率（以毫秒为单位） | long | 300000 | [1,...] | 中 |
| max.connections.per.ip | 每个IP允许的最大连接数 | int | 2147483647 | [1,...] | 中 |
| max.connections.per.ip.overrides | 每个IP或主机名将覆盖默认的最大连接数 | string | "" | 中 | |
| num.partitions | 每个topic的默认日志分区数 | int | 1 | [1,...] | 中 |
| principal.builder.class | 实现kafkaprincipalbuilder接口类的全名，该接口用于构建授权期间使用的kafkaprincipal对象。此配置还支持以前已弃用的用于ssl客户端身份验证的principalbuilder接口。如果未定义主体构建器，则默认采用所使用的安全协议。对于ssl身份验证，如果提供了一个主体名称，主体名称将是客户端证书的专有名称;否则，如果不需要客户端身份验证，则主体名称将是匿名的。对于sasl身份验证，如果使用gssapi，则将使用由sasl.kerberos.principal.to.local.rules定义的规则来生成主体，而使用其他机制的sasl身份验证ID。若果用明文，委托人将是匿名的。 | class | null | 中 | |
| producer.purgatory.purge.interval.requests | producer请求purgatory的清除间隔（请求数量） | int | 1000 | 中 | |
| queued.max.request.bytes | 在不再读取请求之前队列的字节数 | long | -1 | 中 | |
| replica.fetch.backoff.ms | 当拉取分区发生错误时，睡眠的时间。 | int | 1000 | [0,...] | 中 |
| replica.fetch.max.bytes | 尝试提取每个分区的消息的字节数。这并不是绝对最大值，如果第一个非空分区的第一个批量记录大于这个值，那么批处理仍将被执行并返回，以确保进度可以正常进行下去。broker接受的最大批量记录大小通过message.max.bytes（broker配置）或max.message.bytes（topic配置）进行配置。 | int | 1048576 | [0,...] | medium |
| replica.fetch.response.max.bytes | 预计整个获取响应的最大字节数。记录被批量取回时，如果取第一个非空分区的第一个批量记录大于此值，记录的批处理仍将被执行并返回以确保可以进行下去。因此，这不是绝对的最大值。 broker接受的最大批量记录大小通过message.max.bytes（broker配置）或max.message.bytes（topic配置）进行配置。 | int | 10485760 | [0,...] | 中 |
| reserved.broker.max.id | 可以用于broker.id的最大数量 | int | 1000 | [0,...] | 中 |
| sasl.enabled.mechanisms | kafka服务器中启用的sasl机制的列表。 该列表可能包含安全提供程序可用的任何机制。默认情况下只有gssapi是启用的。 | list | GSSAPI | 中 | |
| sasl.kerberos.kinit.cmd | Kerberos kinit 命令路径。 | string | /usr/bin/kinit | 中 | |
| sasl.kerberos.min.time.before.relogin | 登录线程在尝试刷新间隔内的休眠时间。 | long | 60000 | 中 | |
| sasl.kerberos.principal.to.local.rules | 主体名称到简称映射的规则列表（通常是操作系统用户名）。按顺序，使用与principal名称匹配的第一个规则将其映射到简称。列表中的任何后续规则都将被忽略。 默认情况下，{username} / {hostname} @ {realm}形式的主体名称映射到{username}。 有关格式的更多细节，请参阅安全授权和acls。 请注意，如果由principal.builder.class配置提供了kafkaprincipalbuilder的扩展，则忽略此配置。 | list | DEFAULT | 中 | |
| sasl.kerberos.service.name | kafka运行的kerberos的主体名称。 这可以在kafka的JAAS配置或在kafka的配置中定义。 | string | null | 中 | |
| sasl.kerberos.ticket.renew.jitter | 添加到更新时间的随机抖动的百分比 | double | 0.05 | 中 | |
| sasl.kerberos.ticket.renew.window.factor | 登录线程将休眠，直到从上次刷新到ticket的到期的时间到达（指定窗口因子），在此期间它将尝试更新ticket。 | double | 0.8 | 中 | |
| sasl.mechanism.inter.broker.protocol | SASL机制，用于broker之间的通讯，默认是GSSAPI。 | string | GSSAPI | 中 | |
| security.inter.broker.protocol | broker之间的安全通讯协议，有效值有：PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL。同时设置此配置和inter.broker.listener.name属性会出错 | string | PLAINTEXT | 中 | |
| ssl.cipher.suites | 密码套件列表。 这是一种用于使用tls或ssl网络协议来协商网络连接的安全设置的认证，加密，mac和密钥交换算法的命名组合。 默认情况下，所有可用的密码套件都受支持。 | list | null | 中 | |
| ssl.client.auth | 配置请求客户端的broker认证。常见的设置：ssl.client.auth=required如果设置需要客户端认证。 ssl.client.auth=requested客户端认证可选，不同于requested，客户端可选择不提供自身的身份验证信息。 ssl.client.auth=none 不需要客户端身份认证。 | string | none | [required, requested, none] | 中 |
| ssl.enabled.protocols | 已启用的SSL连接协议列表。 | list | TLSv1.2,TLSv1.1,TLSv1 | 中 | |
| ssl.key.password | 秘钥库文件中的私钥密码。对客户端是可选的。 | password | null | 中 | |
| ssl.keymanager.algorithm | 用于SSL连接的密钥管理工厂算法。默认值是为Java虚拟机配置的密钥管理器工厂算法。 | string | SunX509 | 中 | |
| ssl.keystore.location | 密钥仓库文件的位置。客户端可选，并可用于客户端的双向认证。 | string | null | 中 | |
| ssl.keystore.password | 密钥仓库文件的仓库密码。客户端可选，只有ssl.keystore.location配置了才需要。 | password | null | 中 | |
| ssl.keystore.type | 密钥仓库文件的格式。客户端可选。 | string | JKS | 中 | |
| ssl.protocol | 用于生成SSLContext，默认是TLS，适用于大多数情况。允许使用最新的JVM，LS, TLSv1.1 和TLSv1.2。 SSL，SSLv2和SSLv3 老的JVM也可能支持，但由于有已知的安全漏洞，不建议使用。 | string | TLS | ||
| ssl.provider | 用于SSL连接的安全提供程序的名称。默认值由JVM的安全程序提供。 | string | null | 中 | |
| ssl.trustmanager.algorithm | 信任管理工厂用于SSL连接的算法。默认为Java虚拟机配置的信任算法。 | string | PKIX | 中 | |
| ssl.truststore.location | 信任文件的存储位置。 | string | null | 中 | |
| ssl.truststore.password | 信任存储文件的密码。 如果密码未设置，则仍然可以访问信任库，但完整性检查将被禁用。 | password | null | 中 | |
| ssl.truststore.type | 信任存储文件的文件格式。 | string | JKS | 中 | |
| alter.config.policy.class.name | 应该用于验证的alter configs策略类。 该类应该实现org.apache.kafka.server.policy.alterconfigpolicy接口。 | class | null | 低 | |
| authorizer.class.name | 用于认证授权的程序类 | string | "" | 低 | |
| create.topic.policy.class.name | 用于验证的创建topic策略类。 该类应该实现org.apache.kafka.server.policy.createtopicpolicy接口。 | class | null | 低 | |
| listener.security.protocol.map | 侦听器名称和安全协议之间的映射。必须定义为相同的安全协议可用于多个端口或IP。例如，即使两者都需要ssl，内部和外部流量也可以分开。具体的说，用户可以定义名字为INTERNAL和EXTERNAL的侦听器，这个属性为：internal：ssl，external：ssl。 如图所示，键和值由冒号分隔，映射条目以逗号分隔。 每个监听者名字只能在映射表上出现一次。 通过向配置名称添加规范化前缀（侦听器名称小写），可以为每个侦听器配置不同的安全性（ssl和sasl）设置。 例如，为内部监听器设置不同的密钥仓库，将会设置名称为“listener.name.internal.ssl.keystore.location”的配置。 如果没有设置侦听器名称的配置，配置将回退到通用配置（即`ssl.keystore.location`）。 | string | PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL | 低 | |
| metric.reporters | 度量报告的类列表，通过实现MetricReporter接口，允许插入新度量标准类。JmxReporter包含注册JVM统计。 | list | "" | 低 | |
| metrics.num.samples | 维持计算度量的样本数 | int | 2 | [1,...] | 低 |
| metrics.recording.level | 指标的最高记录级别 | string | INFO | 低 | |
| metrics.sample.window.ms | 计算度量样本的时间窗口 | long | 30000 | [1,...] | 低 |
| quota.window.num | 在内存中保留客户端限额的样本数 | int | 11 | [1,...] | 低 |
| quota.window.size.seconds | 每个客户端限额的样本时间跨度 | int | 1 | [1,...] | 低 |
| replication.quota.window.num | 在内存中保留副本限额的样本数 | int | 11 | [1,...] | 低 |
| replication.quota.window.size.seconds | 每个副本限额样本数的时间跨度 | int | 1 | [1,...] | 低 |
| ssl.endpoint.identification.algorithm | 端点身份标识算法，使用服务器证书验证服务器主机名 | string | null | 低 | |
| ssl.secure.random.implementation | 用于SSL加密操作的SecureRandom PRNG实现 | string | null | 低 | |
| transaction.abort.timed.out.transaction.cleanup.interval.ms | 回滚已超时的事务的时间间隔 | int | 60000 | [1,...] | 低 |
| transaction.remove.expired.transaction.cleanup.interval.ms | 删除由于transactional.id.expiration.ms传递过程而过期的事务的时间间隔 | int | 3600000 | [1,...] | low |
| zookeeper.sync.time.ms | ZK follower同步可落后leader多久/td> | int | 2000 | 低 |
二、Topic配置
- 可以使用如下命令在新建topic时配置属性：
bin\windows\kafka-topics.bat --zookeeper localhost:2181 --create --topic testTopic --partitions 1 --replication-factor 1 --config max.message.bytes=64000 --config flush.messages=1 - 可以使用alter configs命令修改或设置已建立的topic，如下命令修改更新testTopic的最大的消息大小：
bin\windows\kafka-configs.bat --zookeeper localhost:2181 --entity-type topics --entity-name testTopic --alter --add-config max.message.bytes=128000 - 可以执行以下命令验证结果：
bin\windows\kafka-configs.bat --zookeeper localhost:2181 --entity-type topics --entity-name testTopic --describe - 移除配置：
bin\windows\kafka-configs.bat --zookeeper localhost:2181 --entity-type topics --entity-name testTopic --alter --delete-config max.message.bytes
| 名称 | 描述 | 类型 | 默认值 | 有效值 | 服务器默认属性 | 重要性 |
|---|---|---|---|---|---|---|
| cleanup.policy | 该配置项可以是 "delete" 或 "compact"。 它指定在旧日志段上使用的保留策略。 默认策略 ("delete") 将在达到保留时间或大小限制时丢弃旧段。 "compact" 设置将启用该topic的日志压缩 。 | list | delete | [compact, delete] | log.cleanup.policy | medium |
| compression.type | 为给定的topic指定最终压缩类型。这个配置接受标准的压缩编解码器 ('gzip', 'snappy', lz4) 。它为'uncompressed'时意味着不压缩，当为'producer'时，这意味着保留producer设置的原始压缩编解码器。 | string | producer | [uncompressed, snappy, lz4, gzip, producer] | compression.type | medium |
| delete.retention.ms | 保留 日志压缩 topics的删除墓碑标记的时间。此设置还对consumer从偏移量0开始时必须完成读取的时间进行限制，以确保它们获得最后阶段的有效快照(否则，在完成扫描之前可能会收集到删除墓碑)。 | long | 86400000 | [0,...] | log.cleaner.delete.retention.ms | medium |
| file.delete.delay.ms | 删除文件系统上的一个文件之前所需等待的时间。 | long | 60000 | [0,...] | log.segment.delete.delay.ms | medium |
| flush.messages | 这个设置允许指定一个时间间隔n，每隔n个消息我们会强制把数据fsync到log。例如，如果设置为1，我们会在每条消息之后同步。如果是5，我们会在每五个消息之后进行fsync。一般来说，我们建议您不要设置它，而是通过使用replication机制来持久化数据，和允许更高效的操作系统后台刷新功能。这个设置可以针对每个topic的情况自定义 (请参阅 topic的配置部分). | long | 9223372036854775807 | [0,...] | log.flush.interval.messages | medium |
| flush.ms | 这个设置允许指定一个时间间隔，每隔一段时间我们将强制把数据fsync到log。例如，如果这个设置为1000，我们将在1000 ms后执行fsync。一般来说，我们建议您不要设置它，而是通过使用replication机制来持久化数据，和允许更高效的操作系统后台刷新功能。 | long | 9223372036854775807 | [0,...] | log.flush.interval.ms | medium |
| follower.replication.throttled.replicas | 应该在follower侧限制日志复制的副本列表。该列表应以[PartitionId]：[BrokerId]，[PartitionId]：[BrokerId]：...的形式描述一组副本，或者也可以使用通配符“*”来限制该topic的所有副本。 | list | "" | [partitionId],[brokerId]:[partitionId],[brokerId]:... | follower.replication.throttled.replicas | medium |
| index.interval.bytes | 此设置控制Kafka向其偏移索引添加索引条目的频率。默认设置确保我们大约每4096个字节索引一条消息。更多的索引允许读取更接近日志中的确切位置，但这会使索引更大。您可能不需要改变该值。 | int | 4096 | [0,...] | log.index.interval.bytes | medium |
| leader.replication.throttled.replicas | 应该在leader侧限制日志复制的副本列表。该列表应以[PartitionId]：[BrokerId]，[PartitionId]：[BrokerId]：...的形式描述一组副本，或者也可以使用通配符“*”来限制该topic的所有副本。 | list | "" | [partitionId],[brokerId]:[partitionId],[brokerId]:... | leader.replication.throttled.replicas | medium |
| max.message.bytes | Kafka允许的最大记录批次大小。如果这个参数被增加了且consumers是早于0.10.2版本，那么consumers的fetch size必须增加到该值，以便他们可以取得这么大的记录批次。 在最新的消息格式版本中，记录总是分组成多个批次以提高效率。在以前的消息格式版本中，未压缩的记录不会分组到多个批次，并且限制在该情况下只能应用单条记录。 | int | 1000012 | [0,...] | message.max.bytes | medium |
| message.format.version | 指定broker将用于将消息附加到日志的消息格式版本。该值应该是有效的ApiVersion。如：0.8.2，0.9.0.0，0.10.0，查看ApiVersion获取更多细节。通过设置特定的消息格式版本，用户将发现磁盘上的所有现有消息都小于或等于指定的版本。不正确地设置此值将导致旧版本的使用者中断，因为他们将收到他们不理解的格式的消息。 | string | 1.0-IV0 | log.message.format.version | medium | |
| message.timestamp.difference.max.ms | broker接收消息时所允许的时间戳与消息中指定的时间戳之间的最大差异。如果message.timestamp.type=CreateTime，则如果时间戳的差异超过此阈值，则将拒绝消息。如果message.timestamp.type=LogAppendTime，则忽略此配置。 | long | 9223372036854775807 | [0,...] | log.message.timestamp.difference.max.ms | medium |
| message.timestamp.type | 定义消息中的时间戳是消息创建时间还是日志附加时间。值应该是“CreateTime”或“LogAppendTime” | string | CreateTime | log.message.timestamp.type | medium | |
| min.cleanable.dirty.ratio | 此配置控制日志compaction程序尝试清理日志的频率(假设启用了log compaction )。默认情况下，我们将避免清除超过50%的日志已经合并的日志。这个比率限制了重复在日志中浪费的最大空间(最多为50%，日志中最多有50%可能是重复的)。一个更高的比率将意味着更少，更高效的清理，但将意味着在日志中浪费更多的空间。 | double | 0.5 | [0,...,1] | log.cleaner.min.cleanable.ratio | medium |
| min.compaction.lag.ms | 消息在日志中保持未压缩的最短时间。仅适用于被合并的日志。 | long | 0 | [0,...] | log.cleaner.min.compaction.lag.ms | medium |
| min.insync.replicas | 当producer将ack设置为“all”(或“-1”)时，此配置指定必须确认写入才能被认为成功的副本的最小数量。如果这个最小值无法满足，那么producer将引发一个异常(NotEnough Replicas或NotEnough ReplicasAfterAppend)。 当使用时，min.insync.Copicas和ack允许您执行更好的持久化保证。一个典型的场景是创建一个复制因子为3的topic，将min.insync.Copicas设置为2，并生成带有“All”的ack。这将确保如果大多数副本没有接收到写，则producer将引发异常。 | int | 1 | [1,...] | min.insync.replicas | medium |
| preallocate | 如果在创建新的日志段时应该预先分配磁盘上的文件，则为True。 | boolean | false | log.preallocate | medium | |
| retention.bytes | 如果使用“delete”保留策略，此配置控制分区(由日志段组成)在放弃旧日志段以释放空间之前的最大大小。默认情况下，没有大小限制，只有时间限制。由于此限制是在分区级别强制执行的，因此，将其乘以分区数，计算出topic保留值，以字节为单位。 | long | -1 | log.retention.bytes | medium | |
| retention.ms | 如果使用“delete”保留策略，此配置控制保留日志的最长时间，然后将旧日志段丢弃以释放空间。这代表了用户读取数据的速度的SLA。 | long | 604800000 | log.retention.ms | medium | |
| segment.bytes | 此配置控制日志的段文件大小。保留和清理总是一次完成一个文件，所以更大的段大小意味着更少的文件，但对保留的粒度控制更少。 | int | 1073741824 | [14,...] | log.segment.bytes | medium |
| segment.index.bytes | 此配置控制将偏移量映射到文件位置的索引大小。我们预先分配这个索引文件并且只在日志滚动后收缩它。您通常不需要更改此设置。 | int | 10485760 | [0,...] | log.index.size.max.bytes | medium |
| segment.jitter.ms | 从预定的分段滚动时间减去最大随机抖动，以避免段滚动产生惊群效应。 | long | 0 | [0,...] | log.roll.jitter.ms | medium |
| segment.ms | 这个配置控制在一段时间后，Kafka将强制日志滚动，即使段文件没有满，以确保保留空间可以删除或合并旧数据。 | long | 604800000 | [0,...] | log.roll.ms | medium |
| unclean.leader.election.enable | 指示是否启用不在ISR集合中的副本选为领导者作为最后的手段，即使这样做可能导致数据丢失。 | boolean | false | unclean.leader.election.enable | medium |
三、Producer配置
| NAME | DESCRIPTION | TYPE | DEFAULT | VALID VALUES | IMPORTANCE |
|---|---|---|---|---|---|
| bootstrap.servers | 这是一个用于建立初始连接到kafka集群的"主机/端口对"配置列表。不论这个参数配置了哪些服务器来初始化连接，客户端都是会均衡地与集群中的所有服务器建立连接。—配置的服务器清单仅用于初始化连接，以便找到集群中的所有服务器。配置格式： host1:port1,host2:port2,.... 由于这些主机是用于初始化连接，以获得整个集群（集群是会动态变化的），因此这个配置清单不需要包含整个集群的服务器。（当然，为了避免单节点风险，这个清单最好配置多台主机）。 | list | high | ||
| key.serializer | 关键字的序列化类，实现以下接口： org.apache.kafka.common.serialization.Serializer 接口。 | class | high | ||
| value.serializer | 值的序列化类，实现以下接口： org.apache.kafka.common.serialization.Serializer 接口。 | class | high | ||
| acks | 此配置是 Producer 在确认一个请求发送完成之前需要收到的反馈信息的数量。 这个参数是为了保证发送请求的可靠性。以下配置方式是允许的：acks=0 如果设置为0，则 producer 不会等待服务器的反馈。该消息会被立刻添加到 socket buffer 中并认为已经发送完成。在这种情况下，服务器是否收到请求是没法保证的，并且参数retries也不会生效（因为客户端无法获得失败信息）。每个记录返回的 offset 总是被设置为-1。 acks=1 如果设置为1，leader节点会将记录写入本地日志，并且在所有 follower 节点反馈之前就先确认成功。在这种情况下，如果 leader 节点在接收记录之后，并且在 follower 节点复制数据完成之前产生错误，则这条记录会丢失。 acks=all 如果设置为all，这就意味着 leader 节点会等待所有同步中的副本确认之后再确认这条记录是否发送完成。只要至少有一个同步副本存在，记录就不会丢失。这种方式是对请求传递的最有效保证。 acks=-1与acks=all是等效的。 | string | 1 | [all, -1, 0, 1] | high |
| buffer.memory | Producer 用来缓冲等待被发送到服务器的记录的总字节数。如果记录发送的速度比发送到服务器的速度快， Producer 就会阻塞，如果阻塞的时间超过 max.block.ms 配置的时长，则会抛出一个异常。 这个配置与 Producer 的可用总内存有一定的对应关系，但并不是完全等价的关系，因为 Producer 的可用内存并不是全部都用来缓存。一些额外的内存可能会用于压缩(如果启用了压缩)，以及维护正在运行的请求。 | long | 33554432 | [0,...] | high |
| compression.type | Producer 生成数据时可使用的压缩类型。默认值是none(即不压缩)。可配置的压缩类型包括：none, gzip, snappy, 或者 lz4 。压缩是针对批处理的所有数据，所以批处理的效果也会影响压缩比(更多的批处理意味着更好的压缩)。 | string | none | high | |
| retries | 若设置大于0的值，则客户端会将发送失败的记录重新发送，尽管这些记录有可能是暂时性的错误。请注意，这种 retry 与客户端收到错误信息之后重新发送记录并无区别。允许 retries 并且没有设置max.in.flight.requests.per.connection 为1时，记录的顺序可能会被改变。比如：当两个批次都被发送到同一个 partition ，第一个批次发生错误并发生 retries 而第二个批次已经成功，则第二个批次的记录就会先于第一个批次出现。 | int | 0 | [0,...,2147483647] | high |
| ssl.key.password | key store 文件中私钥的密码。这对于客户端来说是可选的。 | password | null | high | |
| ssl.keystore.location | key store 文件的位置。这对于客户端来说是可选的，可用于客户端的双向身份验证。 | string | null | high | |
| ssl.keystore.password | key store 文件的密码。这对于客户端是可选的，只有配置了 ssl.keystore.location 才需要配置该选项。 | password | null | high | |
| ssl.truststore.location | trust store 文件的位置。 | string | null | high | |
| ssl.truststore.password | trust store 文件的密码。如果一个密码没有设置到 trust store ，这个密码仍然是可用的，但是完整性检查是禁用的。 | password | null | high | |
| batch.size | 当将多个记录被发送到同一个分区时， Producer 将尝试将记录组合到更少的请求中。这有助于提升客户端和服务器端的性能。这个配置控制一个批次的默认大小（以字节为单位）。 当记录的大小超过了配置的字节数， Producer 将不再尝试往批次增加记录。 发送到 broker 的请求会包含多个批次的数据，每个批次对应一个 partition 的可用数据 小的 batch.size 将减少批处理，并且可能会降低吞吐量(如果 batch.size = 0的话将完全禁用批处理)。 很大的 batch.size 可能造成内存浪费，因为我们一般会在 batch.size 的基础上分配一部分缓存以应付额外的记录。 | int | 16384 | [0,...] | medium |
| client.id | 发出请求时传递给服务器的 ID 字符串。这样做的目的是为了在服务端的请求日志中能够通过逻辑应用名称来跟踪请求的来源，而不是只能通过IP和端口号跟进。 | string | "" | medium | |
| connections.max.idle.ms | 在此配置指定的毫秒数之后，关闭空闲连接。 | long | 540000 | medium | |
| linger.ms | producer 会将两个请求发送时间间隔内到达的记录合并到一个单独的批处理请求中。通常只有当记录到达的速度超过了发送的速度时才会出现这种情况。然而，在某些场景下，即使处于可接受的负载下，客户端也希望能减少请求的数量。这个设置是通过添加少量的人为延迟来实现的&mdash；即，与其立即发送记录， producer 将等待给定的延迟时间，以便将在等待过程中到达的其他记录能合并到本批次的处理中。这可以认为是与 TCP 中的 Nagle 算法类似。这个设置为批处理的延迟提供了上限:一旦我们接受到记录超过了分区的 batch.size ，Producer 会忽略这个参数，立刻发送数据。但是如果累积的字节数少于 batch.size ，那么我们将在指定的时间内“逗留”(linger)，以等待更多的记录出现。这个设置默认为0(即没有延迟)。例如：如果设置linger.ms=5 ，则发送的请求会减少并降低部分负载，但同时会增加5毫秒的延迟。 | long | 0 | [0,...] | medium |
| max.block.ms | 该配置控制 KafkaProducer.send()和KafkaProducer.partitionsFor() 允许被阻塞的时长。这些方法可能因为缓冲区满了或者元数据不可用而被阻塞。用户提供的序列化程序或分区程序的阻塞将不会被计算到这个超时。 | long | 60000 | [0,...] | medium |
| max.request.size | 请求的最大字节数。这个设置将限制 Producer 在单个请求中发送的记录批量的数量，以避免发送巨大的请求。这实际上也等同于批次的最大记录数的限制。请注意，服务器对批次的大小有自己的限制，这可能与此不同。 | int | 1048576 | [0,...] | medium |
| partitioner.class | 指定计算分区的类，实现 org.apache.kafka.clients.producer.Partitioner 接口。 | class | org.apache.kafka.clients.producer.internals.DefaultPartitioner | medium | |
| receive.buffer.bytes | 定义读取数据时 TCP 接收缓冲区（SO_RCVBUF）的大小，如果设置为-1，则使用系统默认值。 | int | 32768 | [-1,...] | medium |
| request.timeout.ms | 客户端等待请求响应的最大时长。如果超时未收到响应，则客户端将在必要时重新发送请求，如果重试的次数达到允许的最大重试次数，则请求失败。这个参数应该比 replica.lag.time.max.ms （Broker 的一个参数）更大，以降低由于不必要的重试而导致的消息重复的可能性。 | int | 30000 | [0,...] | medium |
| sasl.jaas.config | SASL 连接使用的 JAAS 登陆上下文参数，以 JAAS 配置文件的格式进行配置。 JAAS 配置文件格式可参考这里。值的格式: ' (=)*;' | password | null | medium | |
| sasl.kerberos.service.name | Kafka 运行时的 Kerberos 主体名称。可以在 Kafka 的 JAAS 配置文件或者 Kafka 的配置文件中配置。 | string | null | medium | |
| sasl.mechanism | 用于客户端连接的 SASL 机制。可以是任意安全可靠的机制。默认是 GSSAPI 机制。 | string | GSSAPI | medium | |
| security.protocol | 与 brokers 通讯的协议。可配置的值有: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL. | string | PLAINTEXT | medium | |
| send.buffer.bytes | 定义发送数据时的 TCP 发送缓冲区（SO_SNDBUF）的大小。如果设置为-1，则使用系统默认值。 | int | 131072 | [-1,...] | medium |
| ssl.enabled.protocols | 可用于 SSL 连接的协议列表。 | list | TLSv1.2,TLSv1.1,TLSv1 | medium | |
| ssl.keystore.type | key store 文件的文件格类型。这对于客户端来说是可选的。 | string | JKS | medium | |
| ssl.protocol | 用于生成SSLContext的SSL协议。默认设置是TLS，大多数情况下不会有问题。在最近的jvm版本中，允许的值是TLS、tlsv1.1和TLSv1.2。在旧的jvm中可能会支持SSL、SSLv2和SSLv3，但是由于存在已知的安全漏洞，因此不建议使用。 | string | TLS | medium | |
| ssl.provider | 用于 SSL 连接security provider 。默认值是当前 JVM 版本的默认 security provider 。 | string | null | medium | |
| ssl.truststore.type | trust store 的文件类型。 | string | JKS | medium | |
| enable.idempotence | 当设置为true时， Producer 将确保每个消息在 Stream 中只写入一个副本。如果为false，由于 Broker 故障导致 Producer 进行重试之类的情况可能会导致消息重复写入到 Stream 中。请注意,启用幂等性需要确保max.in.flight.requests.per.connection小于或等于5，retries 大于等于0，并且ack必须设置为all 。如果这些值不是由用户明确设置的，那么将自动选择合适的值。如果设置了不兼容的值，则将抛出一个ConfigException的异常。 | boolean | false | low | |
| interceptor.classes | 配置 interceptor 类的列表。实现org.apache.kafka.clients.producer.ProducerInterceptor接口之后可以拦截(并可能改变)那些 Producer 还没有发送到 kafka 集群的记录。默认情况下，没有 interceptor 。 | list | null | low | |
| max.in.flight.requests.per.connection | 在发生阻塞之前，客户端的一个连接上允许出现未确认请求的最大数量。注意，如果这个设置大于1，并且有失败的发送，则消息可能会由于重试而导致重新排序(如果重试是启用的话)。 | int | 5 | [1,...] | low |
| metadata.max.age.ms | 刷新元数据的时间间隔，单位毫秒。即使没有发现任何分区的 leadership 发生变更也会强制刷新以便能主动发现新的 Broker 或者新的分区。 | long | 300000 | [0,...] | low |
| metric.reporters | 用于指标监控报表的类清单。实现org.apache.kafka.common.metrics.MetricsReporter接口之后允许插入能够通知新的创建度量的类。JmxReporter 总是包含在注册的 JMX 统计信息中。 | list | "" | low | |
| metrics.num.samples | 计算 metrics 所需要维持的样本数量。 | int | 2 | [1,...] | low |
| metrics.recording.level | metrics 的最高纪录级别。 | string | INFO | [INFO, DEBUG] | low |
| metrics.sample.window.ms | 计算 metrics 样本的时间窗口。 | long | 30000 | [0,...] | low |
| reconnect.backoff.max.ms | 当重新连接到一台多次连接失败的 Broker 时允许等待的最大毫秒数。如果配置该参数，则每台主机的 backoff 将呈指数级增长直到达到配置的最大值。当统计到 backoff 在增长，系统会增加20%的随机波动以避免大量的连接失败。 | long | 1000 | [0,...] | low |
| reconnect.backoff.ms | 在尝试重新连接到给定的主机之前，需要等待的基本时间。这避免了在一个紧凑的循环中反复连接到同一个主机。这个 backoff 机制应用于所有客户端尝试连接到 Broker 的请求。 | long | 50 | [0,...] | low |
| retry.backoff.ms | 在尝试将一个失败的请求重试到给定的 topic 分区之前需要等待的时间。这避免在某些失败场景下在紧凑的循环中重复发送请求。 | long | 100 | [0,...] | low |
| sasl.kerberos.kinit.cmd | Kerberos kinit 命令的路径。 | string | /usr/bin/kinit | low | |
| sasl.kerberos.min.time.before.relogin | 重新尝试登陆之前,登录线程的休眠时间。 | long | 60000 | low | |
| sasl.kerberos.ticket.renew.jitter | 随机抖动增加到更新时间的百分比。 | double | 0.05 | low | |
| sasl.kerberos.ticket.renew.window.factor | 登录线程将持续休眠直到上一次刷新到 ticket 的过期时间窗口，在此时间窗口它将尝试更新 ticket 。 | double | 0.8 | low | |
| ssl.cipher.suites | 密码套件列表。密码套件是利用 TLS 或 SSL 网络协议来实现网络连接的安全设置，是一个涵盖认证，加密，MAC和密钥交换算法的组合。默认情况下，支持所有可用的密码套件。 | list | null | low | |
| ssl.endpoint.identification.algorithm | 使用服务器证书验证服务器主机名的 endpoint 识别算法。 | string | null | low | |
| ssl.keymanager.algorithm | key manager factory 用于 SSL 连接的算法。默认值是Java虚拟机配置的 key manager factory 算法。 | string | SunX509 | low | |
| ssl.secure.random.implementation | 用于 SSL 加密操作的 SecureRandom PRNG 实现。 | string | null | low | |
| ssl.trustmanager.algorithm | trust manager factory 用于SSL连接的算法。默认值是Java虚拟机配置的 trust manager factory 算法。 | string | PKIX | low | |
| transaction.timeout.ms | 主动中止进行中的事务之前，事务协调器等待 Producer 更新事务状态的最长时间（以毫秒为单位）。如果此值大于 Broker 中的 max.transaction.timeout.ms 设置的时长，则请求将失败并提示"InvalidTransactionTimeout"错误。 | int | 60000 | low | |
| transactional.id | 用于事务交付的 TransactionalId。 这使跨越多个生产者会话的可靠性语义成为可能，因为它可以保证客户在开始任何新的事务之前，使用相同的 TransactionalId 的事务都已经完成。 如果没有提供 TransactionalId ，则 Producer 被限制为幂等递送。 请注意，如果配置了 TransactionalId，则必须启用 enable.idempotence 。 缺省值为空，这意味着无法使用事务。 | string | null | non-empty string | low |
四、Consumer配置
在0.9.0.0中，引入了新的Java消费者来替代早期基于Scala的简单和高级消费者。新老客户端的配置如下。
1、新消费者配置
| NAME | DESCRIPTION | TYPE | DEFAULT | VALID VALUES | IMPORTANCE |
|---|---|---|---|---|---|
| bootstrap.servers | host/port,用于和kafka集群建立初始化连接。因为这些服务器地址仅用于初始化连接，之后会自动发现全部的kafka集群成员（集群随时会变化），所以此列表不需要包含完整的集群地址（但尽量多配置几个，以防止配置的服务器宕机）。 | list | high | ||
| key.deserializer | key的解析序列化接口实现类（Deserializer）。 | class | high | ||
| value.deserializer | value的解析序列化接口实现类（Deserializer）。 | class | high | ||
| fetch.min.bytes | 服务器拉取请求返回的最小数据量，如果数据不足，请求将等待数据积累。默认设置为1字节，表示只要单个字节的数据可用或者读取等待请求超时，就会应答读取请求。将此值设置的越大将导致服务器等待数据累积的越长，这可能以一些额外延迟为代价提高服务器吞吐量。 | int | 1 | [0,...] | high |
| group.id | 消费者所属消费者组的唯一标识。如果消费者用于订阅或offset管理策略的组管理功能，则此属性是必须的。 | string | "" | high | |
| heartbeat.interval.ms | 当使用Kafka的分组管理功能时，心跳到消费者协调器之间的预计时间。心跳用于确保消费者的会话保持活动状态，并当有新消费者加入或离开组时方便重新平衡。该值必须比session.timeout.ms小，通常不高于1/3。它可以调整的更低，以控制正常重新平衡的预期时间。 | int | 3000 | high | |
| max.partition.fetch.bytes | 服务器将返回每个分区的最大数据量。如果拉取的第一个非空分区中第一个消息大于此限制，则仍然会返回消息，以确保消费者可以正常的工作。broker接受的最大消息大小通过message.max.bytes（broker config）或max.message.bytes (topic config)定义。参阅fetch.max.bytes以限制消费者请求大小。 | int | 1048576 | [0,...] | high |
| session.timeout.ms | 用于发现消费者故障的超时时间。消费者周期性的发送心跳到broker，表示其还活着。如果会话超时期满之前没有收到心跳，那么broker将从分组中移除消费者，并启动重新平衡。请注意，该值必须在broker配置的group.min.session.timeout.ms和group.max.session.timeout.ms允许的范围内。 | int | 10000 | high | |
| ssl.key.password | 密钥存储文件中的私钥的密码。 客户端可选 | password | null | high | |
| ssl.keystore.location | 密钥存储文件的位置， 这对于客户端是可选的，并且可以用于客户端的双向认证。 | string | null | high | |
| ssl.keystore.password | 密钥仓库文件的仓库密码。客户端可选，只有ssl.keystore.location配置了才需要。 | password | null | high | |
| ssl.truststore.location | 信任仓库文件的位置 | string | null | high | |
| ssl.truststore.password | 信任仓库文件的密码 | password | null | high | |
| auto.offset.reset | 当Kafka中没有初始offset或如果当前的offset不存在时（例如，该数据被删除了），该怎么办。 earliest：自动将偏移重置为最早的偏移 latest：自动将偏移重置为最新偏移 none：如果消费者组找到之前的offset，则向消费者抛出异常 其他：抛出异常给消费者。 | string | latest | [latest, earliest, none] | medium |
| connections.max.idle.ms | 指定在多少毫秒之后关闭闲置的连接 | long | 540000 | medium | |
| enable.auto.commit | 如果为true，消费者的offset将在后台周期性的提交 | boolean | true | medium | |
| exclude.internal.topics | 内部topic的记录（如偏移量）是否应向消费者公开。如果设置为true，则从内部topic接受记录的唯一方法是订阅它。 | boolean | true | medium | |
| fetch.max.bytes | 服务器为拉取请求返回的最大数据值。这不是绝对的最大值，如果在第一次非空分区拉取的第一条消息大于该值，该消息将仍然返回，以确保消费者继续工作。接收的最大消息大小通过message.max.bytes (broker config) 或 max.message.bytes (topic config)定义。注意，消费者是并行执行多个提取的。 | int | 52428800 | [0,...] | medium |
| isolation.level | 控制如何读取事务性写入的消息。如果设置为read_committed，consumer.poll()将只返回已提交的事务性消息。如果设置为read_uncommitted（默认），consumer.poll()将返回所有消息，甚至已中止的事务性消息。非事务性消息将以任意一种模式无条件返回。消息将始终按偏移顺序返回。因此，在read_committed模式下，consumer.poll()只返回最后一个稳定偏移量（LSO）的消息，该偏移量小于第一个打开事务的偏移量。尤其是在属于正在进行的交易的消息之后出现的任何消息将被保留，直到相关交易完成。因此，read committed当有飞行中的交易时，消费者将无法读取高水位线。此外，当read committed时，seektoend方法将返回LSO | string | read_uncommitted | [read_committed, read_uncommitted] | medium |
| max.poll.interval.ms | 使用消费者组管理时poll()调用之间的最大延迟。消费者在获取更多记录之前可以空闲的时间量的上限。如果此超时时间期满之前poll()没有调用，则消费者被视为失败，并且分组将重新平衡，以便将分区重新分配给别的成员。 | int | 300000 | [1,...] | medium |
| max.poll.records | 在单次调用poll()中返回的最大记录数。 | int | 500 | [1,...] | medium |
| partition.assignment.strategy | 当使用组管理时，客户端将使用分区分配策略的类名来分配消费者实例之间的分区所有权 | list | class org.apache.kafka.clients.consumer.RangeAssignor | medium | |
| receive.buffer.bytes | 读取数据时使用的TCP接收缓冲区（SO_RCVBUF）的大小。 如果值为-1，则将使用OS默认值。 | int | 65536 | [-1,...] | medium |
| request.timeout.ms | 配置控制客户端等待请求响应的最长时间。 如果在超时之前未收到响应，客户端将在必要时重新发送请求，如果重试耗尽则客户端将重新发送请求。 | int | 305000 | [0,...] | medium |
| sasl.jaas.config | JAAS配置文件中SASL连接登录上下文参数。 这里描述JAAS配置文件格式。 该值的格式为： '(=)*;' | password | null | medium | |
| sasl.kerberos.service.name | Kafka运行Kerberos principal名。可以在Kafka的JAAS配置文件或在Kafka的配置文件中定义。 | string | null | medium | |
| sasl.mechanism | 用于客户端连接的SASL机制。安全提供者可用的机制。GSSAPI是默认机制。 | string | GSSAPI | medium | |
| security.protocol | 用于与broker通讯的协议。 有效值为：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。 | string | PLAINTEXT | medium | |
| send.buffer.bytes | 发送数据时要使用的TCP发送缓冲区（SO_SNDBUF）的大小。 如果值为-1，则将使用OS默认值。 | int | 131072 | [-1,...] | medium |
| ssl.enabled.protocols | 启用SSL连接的协议列表。 | list | TLSv1.2,TLSv1.1,TLSv1 | medium | |
| ssl.keystore.type | key仓库文件的文件格式，客户端可选。 | string | JKS | medium | |
| ssl.protocol | 用于生成SSLContext的SSL协议。 默认设置是TLS，这对大多数情况都是适用的。 最新的JVM中的允许值为TLS，TLSv1.1和TLSv1.2。 较旧的JVM可能支持SSL，SSLv2和SSLv3，但由于已知的安全漏洞，不建议使用SSL。 | string | TLS | medium | |
| ssl.provider | 用于SSL连接的安全提供程序的名称。 默认值是JVM的默认安全提供程序。 | string | null | medium | |
| ssl.truststore.type | 信任存储文件的文件格式。 | string | JKS | medium | |
| auto.commit.interval.ms | 如果enable.auto.commit设置为true，则消费者偏移量自动提交给Kafka的频率（以毫秒为单位）。 | int | 5000 | [0,...] | low |
| check.crcs | 自动检查CRC32记录的消耗。 这样可以确保消息发生时不会在线或磁盘损坏。 此检查增加了一些开销，因此在寻求极致性能的情况下可能会被禁用。 | boolean | true | low | |
| client.id | 在发出请求时传递给服务器的id字符串。 这样做的目的是通过允许将逻辑应用程序名称包含在服务器端请求日志记录中，来跟踪ip/port的请求源。 | string | "" | low | |
| fetch.max.wait.ms | 如果没有足够的数据满足fetch.min.bytes，服务器将在接收到提取请求之前阻止的最大时间。 | int | 500 | [0,...] | low |
| interceptor.classes | 用作拦截器的类的列表。 你可实现ConsumerInterceptor接口以允许拦截（也可能变化）消费者接收的记录。 默认情况下，没有拦截器。 | list | null | low | |
| metadata.max.age.ms | 在一定时间段之后（以毫秒为单位的），强制更新元数据，即使没有任何分区领导变化，任何新的broker或分区。 | long | 300000 | [0,...] | low |
| metric.reporters | 用作度量记录员类的列表。实现MetricReporter接口以允许插入通知新的度量创建的类。JmxReporter始终包含在注册JMX统计信息中。 | list | "" | low | |
| metrics.num.samples | 保持的样本数以计算度量。 | int | 2 | [1,...] | low |
| metrics.recording.level | 最高的记录级别。 | string | INFO | [INFO, DEBUG] | low |
| metrics.sample.window.ms | 计算度量样本的时间窗口。 | long | 30000 | [0,...] | low |
| reconnect.backoff.max.ms | 重新连接到重复连接失败的代理时等待的最长时间（毫秒）。如果提供，每台主机的回退将在每次连续连接失败时以指数形式增加，直到达到这个最大值。在计算回退增加后，增加20%的随机抖动以避免连接风暴。 | long | 1000 | [0,...] | low |
| reconnect.backoff.ms | 尝试重新连接指定主机之前等待的时间，避免频繁的连接主机，这种机制适用于消费者向broker发送的所有请求。 | long | 50 | [0,...] | low |
| retry.backoff.ms | 尝试重新发送失败的请求到指定topic分区之前的等待时间。避免在某些故障情况下，频繁的重复发送。 | long | 100 | [0,...] | low |
| sasl.kerberos.kinit.cmd | kinit命令路径。 | string | /usr/bin/kinit | low | |
| sasl.kerberos.min.time.before.relogin | 尝试/恢复之间的登录线程的休眠时间。 | long | 60000 | low | |
| sasl.kerberos.ticket.renew.jitter | 添加到更新时间的随机抖动百分比。 | double | 0.05 | low | |
| sasl.kerberos.ticket.renew.window.factor | 登录线程将休眠，直到从上次刷新到ticket的指定的时间窗口因子到期，此时将尝试续订ticket。 | double | 0.8 | low | |
| ssl.cipher.suites | 密码套件列表，用于TLS或SSL网络协议的安全设置，认证，加密，MAC和密钥交换算法的明明组合。默认情况下，支持所有可用的密码套件。 | list | null | low | |
| ssl.endpoint.identification.algorithm | 使用服务器证书验证服务器主机名的端点识别算法。 | string | null | low | |
| ssl.keymanager.algorithm | 密钥管理器工厂用于SSL连接的算法。 默认值是为Java虚拟机配置的密钥管理器工厂算法。 | string | SunX509 | low | |
| ssl.secure.random.implementation | 用于SSL加密操作的SecureRandom PRNG实现。 | string | null | low | |
| ssl.trustmanager.algorithm | 信任管理器工厂用于SSL连接的算法。 默认值是为Java虚拟机配置的信任管理器工厂算法。 | string | PKIX | low |
2、老消费者配置
| PROPERTY | DEFAULT | DESCRIPTION |
|---|---|---|
| group.id | 标识消费者所属消费者组(独一的)。通过设置相同的组ID，多个消费者表明属于该消 | |
| 指定ZooKeeper连接字符串，格式为hostname：port，其中host和port是ZooKeeper服务器的主机和端口。 为了使ZooKeeper宕机时连接到其他ZooKeeper节点，你还可以以hostname1:host1，hostname2:port2，hostname3:port3的形式指定多个主机。 | ||
| consumer.id | null | 如果未设置将自动生成。 |
| socket.timeout.ms | 30 * 1000 | 网络请求socker的超时时间。实际的超时是 max.fetch.wait+socket.timeout.ms的时间。 |
| socket.receive.buffer.bytes | 64 * 1024 | 网络请求socker的接收缓存大小 |
| fetch.message.max.bytes | 1024 * 1024 | 每个拉取请求的每个topic分区尝试获取的消息的字节大小。这些字节将被读入每个分区的内存，因此这有助于控制消费者使用的内存。 拉取请求的大小至少与服务器允许的最大消息的大小一样大，否则生产者可能发送大于消费者可以拉取的消息。 |
| num.consumer.fetchers | 1 | 用于拉取数据的拉取线程数。 |
| auto.commit.enable | true | 如果为true，请定期向ZooKeeper提交消费者已经获取的消息的偏移量。 当进程失败时，将使用这种承诺偏移量作为新消费者开始的位置。 |
| auto.commit.interval.ms | 60 * 1000 | 消费者offset提交到zookeeper的频率（以毫秒为单位） |
| queued.max.message.chunks | 2 | 消费缓存消息块的最大大小。每个块可以达到fetch.message.max.bytes。 |
| rebalance.max.retries | 4 | 当新的消费者加入消费者组时，消费者集合尝试“重新平衡”负载，并为每个消费者分配分区。如果消费者集合在分配时发生时发生变化，则重新平衡将失败并重试。此设置控制尝试之前的最大尝试次数。 |
| fetch.min.bytes | 1 | 拉取请求返回最小的数据量。如果没有足够的数据，请求将等待数据积累，然后应答请求。 |
| fetch.wait.max.ms | 100 | 如果没有足够的数据（fetch.min.bytes），服务器将在返回请求数据之前阻塞的最长时间。 |
| rebalance.backoff.ms | 2000 | 重新平衡时重试之间的回退时间。如果未设置，则使用zookeeper.sync.time.ms中的值。 |
| refresh.leader.backoff.ms | 200 | 回退时间等待，然后再尝试选举一个刚刚失去leader的分区。 |
| auto.offset.reset | largest | 如果ZooKeeper中没有初始偏移量，或偏移值超出范围，该怎么办？ |
| consumer.timeout.ms | -1 | 如果在指定的时间间隔后没有消息可用，则向用户发出超时异常 |
| exclude.internal.topics | true | 来自内部topic的消息（如偏移量）是否应该暴露给消费者。 |
| client.id | group id value | 客户端ID是每个请求中发送的用户指定的字符串，用于帮助跟踪调用。 它应该逻辑地标识发出请求的应用程序。 |
| zookeeper.session.timeout.ms | 6000 | ZooKeeper会话超时。如果消费者在这段时间内没有对ZooKeeper心跳，那么它被认为是死亡的，并且会发生重新平衡。 |
| zookeeper.connection.timeout.ms | 6000 | 与zookeeper建立连接时客户端等待的最长时间。 |
| zookeeper.sync.time.ms | 2000 | ZK follower可以罗ZK leader多久 |
| offsets.storage | zookeeper | 选择存储偏移量的位置（zookeeper或kafka）。 |
| offsets.channel.backoff.ms | 1000 | 重新连接offset通道或重试失败的偏移提取/提交请求时的回退周期。 |
| offsets.channel.socket.timeout.ms | 10000 | 读取offset拉取/提交响应的Socker的超时时间。此超时也用于查询offset manager的ConsumerMetadata请求。 |
| offsets.commit.max.retries | 5 | 失败时重试偏移提交的最大次数。此重试计数仅适用于停机期间的offset提交，它不适用于自动提交线程的提交。它也不适用于在提交offset之前查询偏移协调器的尝试。即如果消费者元数据请求由于任何原因而失败，则将重试它，并且重试不计入该限制。 |
| dual.commit.enabled | true | 如果使用“kafka”作为offsets.storage，则可以向ZooKeeper（除Kafka之外）进行双重提交offset。在从基于zookeeper的offset存储迁移到kafka存储的时候可以这么做。对于任何给定的消费者组，在该组中的所有实例已迁移到提交到broker（而不是直接到ZooKeeper）的新的版本之后，可以关闭这个。 |
| partition.assignment.strategy | range | 在“range”或“roundrobin”策略之间选择将分区分配给消费者流。 |
五、Connect配置
| NAME | DESCRIPTION | TYPE | DEFAULT | VALID VALUES | IMPORTANCE |
|---|---|---|---|---|---|
| config.storage.topic | kafka topic仓库配置 | string | high | ||
| group.id | 唯一的字符串，用于标识此worker所属的Connect集群组。 | string | high | ||
| key.converter | 用于Kafka Connect和写入到Kafka的序列化消息的之间格式转换的转换器类。 这可以控制写入或从kafka读取的消息中的键的格式，并且由于这与连接器无关，因此它允许任何连接器使用任何序列化格式。 常见格式的示例包括JSON和Avro。 | class | high | ||
| offset.storage.topic | 连接器的offset存储到哪个topic中 | string | high | ||
| status.storage.topic | 追踪连接器和任务状态存储到哪个topic中 | string | high | ||
| value.converter | 用于Kafka Connect格式和写入Kafka的序列化格式之间转换的转换器类。 控制了写入或从Kafka读取的消息中的值的格式，并且由于这与连接器无关，因此它允许任何连接器使用任何序列化格式。 常见格式的示例包括JSON和Avro。 | class | high | ||
| internal.key.converter | 用于在Kafka Connect格式和写入Kafka的序列化格式之间转换的转换器类。 这可以控制写入或从Kafka读取的消息中的key的格式，并且由于这与连接器无关，因此它允许任何连接器使用任何序列化格式。 常见格式的示例包括JSON和Avro。 此设置用于控制框架内部使用的记账数据的格式，例如配置和偏移量，因此用户可以使用运行各种Converter实现。 | class | low | ||
| internal.value.converter | 用于在Kafka Connect格式和写入Kafka的序列化格式之间转换的转换器类。 这控制了写入或从Kafka读取的消息中的值的格式，并且由于这与连接器无关，因此它允许任何连接器使用任何序列化格式。 常见格式的示例包括JSON和Avro。 此设置用于控制框架内部使用的记账数据的格式，例如配置和偏移量，因此用户可以使用运行各种Converter实现。 | class | low | ||
| bootstrap.servers | 用于建立与Kafka集群的初始连接的主机/端口列表。此列表用来发现完整服务器集的初始主机。 该列表的格式应为host1：port1，host2：port2，....由于这些服务器仅用于初始连接以发现完整的集群成员资格（可能会动态更改），因此,不需要包含完整的服务器（尽管如此，你需要多配置几个，以防止配置的宕机）。 | list | localhost:9092 | high | |
| heartbeat.interval.ms | 心跳间隔时间。心跳用于确保会话保持活动，并在新成员加入或离开组时进行重新平衡。 该值必须设置为低于session.timeout.ms，但通常应设置为不高于该值的1/3。 | int | 3000 | high | |
| rebalance.timeout.ms | 限制所有组中消费者的任务处理数据和提交offset所需的时间。如果超时，那么woker将从组中删除，这也将导致offset提交失败。 | int | 60000 | high | |
| session.timeout.ms | 用于察觉worker故障的超时时间。worker定时发送心跳以表明自己是活着的。如果broker在会话超时时间到期之前没有接收到心跳，那么broker将从分组中移除该worker，并启动重新平衡。注意，该值必须在group.min.session.timeout.ms和group.max.session.timeout.ms范围内。 | int | 10000 | high | |
| ssl.key.password | 密钥存储文件中私钥的密码。 这对于客户端是可选的。 | password | null | high | |
| ssl.keystore.location | 密钥存储文件的位置。 这对于客户端是可选的，可以用于客户端的双向身份验证。 | string | null | high | |
| ssl.keystore.password | 密钥存储文件的存储密码。 客户端是可选的，只有配置了ssl.keystore.location才需要。 | password | null | high | |
| ssl.truststore.location | 信任存储文件的位置。 | string | null | high | |
| ssl.truststore.password | 信任存储文件的密码。 | password | null | high | |
| connections.max.idle.ms | 多少毫秒之后关闭空闲的连接。 | long | 540000 | medium | |
| receive.buffer.bytes | 读取数据时使用的TCP接收缓冲区（SO_RCVBUF）的大小。 如果值为-1，则将使用OS默认值。 | int | 32768 | [0,...] | medium |
| request.timeout.ms | 配置控制客户端等待请求响应的最长时间。 如果在超时之前未收到响应，客户端将在必要时重新发送请求，如果重试耗尽，则该请求将失败。 | int | 40000 | [0,...] | medium |
| sasl.jaas.config | 用于JAAS配置文件的SASL连接的JAAS登录上下文参数格式。这里描述了JAAS配置文件的格式。该值的格式为：' (=)*;' | password | null | medium | |
| sasl.kerberos.service.name | Kafka运行的Kerberos principal名称。 可以在Kafka的JAAS配置或Kafka的配置中定义。 | string | null | medium | |
| sasl.mechanism | 用户客户端连接的SASL机制。可以提供者任何安全机制。 GSSAPI是默认机制。 | string | GSSAPI | medium | |
| security.protocol | 用于和broker通讯的策略。有效的值有：PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL。 | string | PLAINTEXT | medium | |
| send.buffer.bytes | 发送数据时使用TCP发送缓冲区（SO_SNDBUF）的大小。如果值为-1，则将使用OS默认。 | int | 131072 | [0,...] | medium |
| ssl.enabled.protocols | 启用SSL连接的协议列表。 | list | TLSv1.2,TLSv1.1,TLSv1 | medium | |
| ssl.keystore.type | 密钥存储文件的文件格式。 对于客户端是可选的。 | string | JKS | medium | |
| ssl.protocol | 用于生成SSLContext的SSL协议。 默认设置是TLS，这对大多数情况都是适用的。 最新的JVM中的允许值为TLS，TLSv1.1和TLSv1.2。 旧的JVM可能支持SSL，SSLv2和SSLv3，但由于已知的安全漏洞，不建议使用SSL。 | string | TLS | medium | |
| ssl.provider | 用于SSL连接的安全提供程序的名称。 默认值是JVM的默认安全提供程序。 | string | null | medium | |
| ssl.truststore.type | 信任存储文件的文件格式。 | string | JKS | medium | |
| worker.sync.timeout.ms | 当worker与其他worker不同步并需要重新同步配置时，需等待一段时间才能离开组，然后才能重新加入。 | int | 3000 | medium | |
| worker.unsync.backoff.ms | 当worker与其他worker不同步，并且无法在worker.sync.timeout.ms 期间追赶上，在重新连接之前，退出Connect集群的时间。 | int | 300000 | medium | |
| access.control.allow.methods | 通过设置Access-Control-Allow-Methods标头来设置跨源请求支持的方法。 Access-Control-Allow-Methods标头的默认值允许GET，POST和HEAD的跨源请求。 | string | "" | low | |
| access.control.allow.origin | 将Access-Control-Allow-Origin标头设置为REST API请求。要启用跨源访问，请将其设置为应该允许访问API的应用程序的域，或者 *" 以允许从任何的域。 默认值只允许从REST API的域访问。 | string | "" | low | |
| client.id | 在发出请求时传递给服务器的id字符串。这样做的目的是通过允许逻辑应用程序名称包含在请求消息中，来跟踪请求来源。而不仅仅是ip/port | string | "" | low | |
| config.storage.replication.factor | 当创建配置仓库topic时的副本数 | short | 3 | [1,...] | low |
| metadata.max.age.ms | 在没有任何分区leader改变，主动地发现新的broker或分区的时间。 | long | 300000 | [0,...] | low |
| metric.reporters | 用作度量报告程序的类的列表。实现MetricReporter接口允许插入将被通知创建新度量的类。jmxreporter总是包含在注册jmx统计信息中。 | list | "" | low | |
| metrics.num.samples | 保留计算metrics的样本数 | int | 2 | [1,...] | low |
| metrics.recording.level | 度量的最高记录级别。 | string | INFO | [INFO, DEBUG] | low |
| metrics.sample.window.ms | 计算度量样本的时间窗口。 | long | 30000 | [0,...] | low |
| offset.flush.interval.ms | 尝试提交任务偏移量的间隔。 | long | 60000 | low | |
| offset.flush.timeout.ms | 在取消进程并恢复要在之后尝试提交的offset数据之前，等待消息刷新并分配要提交到offset仓库的offset数据的最大毫秒数。 | long | 5000 | low | |
| offset.storage.partitions | 创建offset仓库topic的分区数 | int | 25 | [1,...] | low |
| offset.storage.replication.factor | 创建offset仓库topic的副本数 | short | 3 | [1,...] | low |
| plugin.path | 包含插件(连接器,转换器,转换)逗号(,)分隔的路径列表。该列表应包含顶级目录，其中包括以下任何组合：a）包含jars与插件及其依赖关系的目录 b）具有插件及其依赖项的uber-jars c）包含插件类的包目录结构的目录及其依赖关系,注意：将遵循符号链接来发现依赖关系或插件。 示例：plugin.path=/usr/local/share/java,/usr/local/share/kafka/plugins,/opt/connectors | list | null | low | |
| reconnect.backoff.max.ms | 无法连接broker时等待的最大时间（毫秒）。如果设置，则每个host的将会持续的增加，直到达到最大值。计算增加后，再增加20％的随机抖动，以避免高频的反复连接。 | long | 1000 | [0,...] | low |
| reconnect.backoff.ms | 尝试重新连接到主机之前等待的时间。 避免了高频率反复的连接主机。 这种机制适用于消费者向broker发送的所有请求。 | long | 50 | [0,...] | low |
| rest.advertised.host.name | 如果设置，其他wokers将通过这个hostname进行连接。 | string | null | low | |
| rest.advertised.port | 如果设置，其他的worker将通过这个端口进行连接。 | int | null | low | |
| rest.host.name | REST API的主机名。如果设置，它将只绑定到这个接口。 | string | null | low | |
| rest.port | 用于监听REST API的端口 | int | 8083 | low | |
| retry.backoff.ms | 失败请求重新尝试之前的等待时间，避免了在某些故障的情况下，频繁的重复发送请求。 | long | 100 | [0,...] | low |
| sasl.kerberos.kinit.cmd | Kerberos kinit命令路径. | string | /usr/bin/kinit | low | |
| sasl.kerberos.min.time.before.relogin | 尝试refresh之间登录线程的休眠时间. | long | 60000 | low | |
| sasl.kerberos.ticket.renew.jitter | 添加到更新时间的随机抖动百分比。 | double | 0.05 | low | |
| sasl.kerberos.ticket.renew.window.factor | 登录线程将休眠，直到从上次刷新ticket到期，此时将尝试续订ticket。 | 0.8 | low | ||
| ssl.cipher.suites | 密码套件列表。用于TLS或SSL网络协议协商网络连接的安全设置的认证，加密，MAC和密钥交换算法的命名组合。 默认情况下，支持所有可用的密码套件。 | list | null | low | |
| ssl.endpoint.identification.algorithm | 末端识别算法使用服务器证书验证服务器主机名。 | string | null | low | |
| ssl.keymanager.algorithm | 用于SSL连接的key管理工厂的算法，默认值是Java虚拟机配置的密钥管理工厂算法。 | string | SunX509 | low | |
| ssl.secure.random.implementation | 用于SSL加密操作的SecureRandom PRNG实现。 | string | null | low | |
| ssl.trustmanager.algorithm | 用于SSL连接的信任管理仓库算法。默认值是Java虚拟机配置的信任管理器工厂算法。 | string | PKIX | low | |
| status.storage.partitions | 用于创建状态仓库topic的分区数 | int | 5 | [1,...] | low |
| status.storage.replication.factor | 用于创建状态仓库topic的副本数 | short | 3 | [1,...] | low |
| task.shutdown.graceful.timeout.ms | 等待任务正常关闭的时间，这是总时间，不是每个任务，所有任务触发关闭，然后依次等待。 | long | 5000 | low |
六、Streams配置
| NAME | DESCRIPTION | TYPE | DEFAULT | VALID VALUES | IMPORTANCE |
|---|---|---|---|---|---|
| application.id | 流处理应用程序标识。必须在Kafka集群中是独一无二的。 1）默认客户端ID前缀，2）成员资格管理的group-id，3）changgelog的topic前缀 | string | high | ||
| bootstrap.servers | 用于建立与Kafka集群的初始连接的主机/端口列表。 客户端将会连接所有服务器，跟指定哪些服务器无关 - 通过指定的服务器列表会自动发现全部的服务器。此列表格式host1：port1，host2：port2，...由于这些服务器仅用于初始连接以发现完整的集群成员（可能会动态更改），所以此列表不需要包含完整集 的服务器（您可能需要多个服务器，以防指定的服务器关闭）。 | list | high | ||
| replication.factor | 流处理程序创建更改日志topic和重新分配topic的副本数 | int | 1 | high | |
| state.dir | 状态存储的目录地址。 | string | /tmp/kafka-streams | high | |
| cache.max.bytes.buffering | 用于缓冲所有线程的最大内存字节数 | long | 10485760 | [0,...] | medium |
| client.id | 发出请求时传递给服务器的id字符串。 这样做的目的是通过允许将逻辑应用程序名称包含在服务器端请求日志记录中，来追踪请求源的ip/port。 | string | "" | medium | |
| default.deserialization.exception.handler | 实现org.apache.kafka.streams.errors.DeserializationExceptionHandlerInterface的异常处理类。 | class | org.apache.kafka.streams.errors.LogAndFailExceptionHandler | medium | |
| default.key.serde | 用于实现Serde接口的key的默认序列化器/解串器类。 | class | org.apache.kafka.common.serialization.Serdes$ByteArraySerde | medium | |
| default.production.exception.handler | 实现org.apache.kafka.streams.errors.ProductionExceptionHandler接口的异常处理类。 | class | org.apache.kafka.streams.errors.DefaultProductionExceptionHandler | medium | |
| default.timestamp.extractor | 实现TimestampExtractor接口的默认时间戳提取器类。 | class | org.apache.kafka.streams.processor.FailOnInvalidTimestamp | medium | |
| default.value.serde | 用于实现Serde接口的值的默认serializer / deserializer类。 | class | org.apache.kafka.common.serialization.Serdes$ByteArraySerde | medium | |
| max.task.idle.ms | 当并非所有分区缓冲区都包含记录时，流任务将保持空闲的最长时间，以避免跨多个输入流处理可能出现的无序记录。 | long | 0 | medium | |
| num.standby.replicas | 每个任务的备用副本数。 | int | 0 | medium | |
| num.stream.threads | 执行流处理的线程数。 | int | 1 | medium | |
| processing.guarantee | 应使用的加工保证。可能的值为at_least_once（默认）和exact_once。 | string | at_least_once | [at_least_once, exactly_once] | medium |
| security.protocol | 用于与broker沟通的协议。 有效值为：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。 | string | PLAINTEXT | medium | |
| topology.optimization | 告诉kafka流是否应优化拓扑的配置，默认情况下禁用。 | string | none | [none, all] | medium |
| application.server | host:port指向用户嵌入定义的末端，可用于发现单个KafkaStreams应用程序中状态存储的位置 | string | "" | low | |
| buffered.records.per.partition | 每个分区缓存的最大记录数。 | int | 1000 | low | |
| commit.interval.ms | 用于保存process位置的频率。 注意，如果'processing.guarantee'设置为'exact_once'，默认值为100，否则默认值为30000。 | long | 30000 | low | |
| connections.max.idle.ms | 关闭闲置的连接时间（以毫秒为单位）。 | long | 540000 | low | |
| metadata.max.age.ms | 即使我们没有看到任何分区leader发生变化，主动发现新的broker或分区，强制更新元数据时间（以毫秒为单位）。 | long | 300000 | [0,...] | low |
| metric.reporters | metric reporter的类列表。实现MetricReporter接口，JmxReporter始终包含在注册JMX统计信息中。 | list | "" | low | |
| metrics.num.samples | 保持的样本数以计算度量。 | int | 2 | [1,...] | low |
| metrics.recording.level | 日志级别。 | string | INFO | [INFO, DEBUG] | low |
| metrics.sample.window.ms | 时间窗口计算度量标准。 | long | 30000 | [0,...] | low |
| partition.grouper | 实现PartitionGrouper接口的Partition grouper类。 | class | org.apache.kafka.streams.processor.DefaultPartitionGrouper | low | |
| poll.ms | 阻塞输入等待的时间（以毫秒为单位）。 | long | 100 | low | |
| receive.buffer.bytes | 读取数据时使用的TCP接收缓冲区（SO_RCVBUF）的大小。 如果值为-1，则将使用OS默认值。 | int | 32768 | [-1,...] | low |
| reconnect.backoff.max.ms | 因故障无法重新连接broker，重新连接的等待的最大时间（毫秒）。如果提供，每个主机会连续增加，直到达到最大值。随机递增20％的随机抖动以避免连接风暴。 | long | 1000 | [0,...] | low |
| reconnect.backoff.ms | 尝试重新连接之前等待的时间。避免在高频繁的重复连接服务器。 这种backoff适用于消费者向broker发送的所有请求。 | long | 50 | [0,...] | low |
| request.timeout.ms | 控制客户端等待请求响应的最长时间。如果在配置时间内未收到响应，客户端将在需要时重新发送请求，如果重试耗尽，则请求失败。 | int | 40000 | [0,...] | low |
| retries | 设置大于零的值将导致客户端重新发送任何失败的请求，并可能出现暂时性错误。 | int | 0 | [0,...,2147483647] | low |
| retry.backoff.ms | 尝试重试失败请求之前等待的时间。以避免了在某些故障情况下，在频繁重复发送请求。 | long | 100 | [0,...] | low |
| rocksdb.config.setter | 一个Rocks DB配置setter类，或实现RocksDBConfigSetter接口的类名 | class | null | low | |
| send.buffer.bytes | 发送数据时要使用的TCP发送缓冲区（SO_SNDBUF）的大小。 如果值为-1，则将使用OS默认值。 | int | 131072 | [-1,...] | low |
| state.cleanup.delay.ms | 在分区迁移删除状态之前等待的时间（毫秒）。 | long | 600000 | low | |
| upgrade.from | 允许以向后兼容的方式从0.10.0/0.10.1/0.10.2/0.11.0/1.0/1.1版升级到1.2版（或更高版本）。从1.2升级到较新版本时，不需要指定此配置。默认值为空。接受值为“0.10.0”、“0.10.1”、“0.10.2”、“0.11.0”、“1.0”、“1.1”（从相应的旧版本升级）。 | string | null | [null, 0.10.0, 0.10.1, 0.10.2, 0.11.0, 1.0, 1.1] | low |
| windowstore.changelog.additional.retention.ms | 添加到Windows维护管理器以确保数据不会从日志中过早删除。默认为1天 | long | 86400000 | low |
七、AdminClient配置
| NAME | DESCRIPTION | TYPE | DEFAULT | VALID VALUES | IMPORTANCE |
|---|---|---|---|---|---|
| bootstrap.servers | host/port,用于和kafka集群建立初始化连接。因为这些服务器地址仅用于初始化连接，并通过现有配置的来发现全部的kafka集群成员（集群随时会变化），所以此列表不需要包含完整的集群地址（但尽量多配置几个，以防止配置的服务器宕机）。 | list | high | ||
| ssl.key.password | 密钥仓库文件中的私钥密码。对于客户端是可选的。 | password | null | high | |
| ssl.keystore.location | 密钥仓库文件的位置。这对于客户端是可选的，可以用于客户端的双向认证。 | string | null | high | |
| ssl.keystore.password | 密钥仓库文件的仓库密钥。这对于客户端是可选的，只有配置了ssl.keystore.location才需要。 | password | null | high | |
| ssl.truststore.location | 信任存储文件的位置。 | string | null | high | |
| ssl.truststore.password | 信任存储文件的密码。如果未设置密码，对信任库的访问仍然可用，但是完整性检查将被禁用。 | password | null | high | |
| client.id | 在发出请求时传递给服务器的id字符串。这样做的目的是通过允许在服务器端请求日志记录中包含逻辑应用程序名称来跟踪请求源的ip/port。 | string | "" | medium | |
| connections.max.idle.ms | 关闭闲置连接的时间。 | long | 300000 | medium | |
| receive.buffer.bytes | 读取数据时使用的TCP接收缓冲区（SO_RCVBUF）的大小。如果值为-1，则将使用OS默认值。 | int | 65536 | [-1,...] | medium |
| request.timeout.ms | 配置控制客户端等待请求响应的最长时间。如果在超时之前未收到响应，客户端将在必要时重新发送请求，如果重试耗尽，则该请求将失败。 | int | 120000 | [0,...] | medium |
| sasl.jaas.config | JAAS配置文件使用的格式的SASL连接的JAAS登录上下文参数。这里描述JAAS配置文件格式。该值的格式为：' (=)*;' | password | null | medium | |
| sasl.kerberos.service.name | Kafka运行的Kerberos principal名。可以在Kafka的JAAS配置或Kafka的配置中定义。 | string | null | medium | |
| sasl.mechanism | 用于客户端连接的SASL机制。安全提供者可用的任何机制。GSSAPI是默认机制。 | string | GSSAPI | medium | |
| security.protocol | 与broker通讯的协议。有效的值有: PLAINTEXT, SSL, SASL_PLAINTEXT,SASL_SSL. | string | PLAINTEXT | medium | |
| send.buffer.bytes | 发送数据时时使用TCP发送缓冲区（SO_SNDBUF）的大小。如果值为-1，则使用OS默认值。 | int | 131072 | [-1,...] | medium |
| ssl.enabled.protocols | 启用SSL连接的协议列表。 | list | TLSv1.2,TLSv1.1,TLSv1 | medium | |
| ssl.keystore.type | 密钥仓库文件的文件格式。对于客户端是可选的。 | string | JKS | medium | |
| ssl.protocol | 用于生成SSLContext的SSL协议。默认设置是TLS，这对大多数情况都是适用的。最新的JVM中允许的值是TLS,TLSv1.1和TLSv1.2。较旧的JVM可能支持SSL,SSLv2和SSLv3,但由于已知的安全漏洞,不建议使用。 | string | TLS | medium | |
| ssl.provider | 用于SSL连接的安全提供程序的名称。 默认值是JVM的默认安全提供程序。 | string | null | medium | |
| ssl.truststore.type | 信任仓库文件的文件格式 | string | JKS | medium | |
| metadata.max.age.ms | 我们强制更新元数据的时间段（以毫秒为单位），即使我们没有任何分区leader发生变化，主动发现任何新的broker或分区。 | long | 300000 | [0,...] | low |
| metric.reporters | 用作指标记录的类的列表。实现MetricReporter接口，以允许插入将被通知新的度量创建的类。JmxReporter始终包含在注册JMX统计信息中。 | list | "" | low | |
| metrics.num.samples | 用于计算度量维护的样例数。 | int | 2 | [1,...] | low |
| metrics.recording.level | 度量的最高记录级别。 | string | INFO | [INFO, DEBUG] | low |
| metrics.sample.window.ms | 时间窗口计算度量标准。 | long | 30000 | [0,...] | low |
| reconnect.backoff.max.ms | 重新连接到重复无法连接的broker程序时等待的最大时间（毫秒）。如果提供，每个主机的回退将会连续增加，直到达到最大值。 计算后退增加后，增加20％的随机抖动以避免连接风暴。 | long | 1000 | [0,...] | low |
| reconnect.backoff.ms | 尝试重新连接到给定主机之前等待的基本时间量。这避免了在频繁的重复连接主机。此配置适用于client对broker的所有连接尝试。 | long | 50 | [0,...] | low |
| retries | 在失败之前重试调用的最大次数 | int | 5 | [0,...] | low |
| retry.backoff.ms | 尝试重试失败的请求之前等待的时间。这样可以避免在某些故障情况下以频繁的重复发送请求。 | long | 100 | [0,...] | low |
| sasl.kerberos.kinit.cmd | Kerberos kinit命令路径。 | string | /usr/bin/kinit | low | |
| sasl.kerberos.min.time.before.relogin | 刷新尝试之间的登录线程睡眠时间。 | long | 60000 | low | |
| sasl.kerberos.ticket.renew.jitter | 添加到更新时间的随机抖动百分比。 | double | 0.05 | low | |
| sasl.kerberos.ticket.renew.window.factor | 登录线程将休眠，直到从上次刷新到“票”到期时间的指定窗口为止，此时将尝试续订“票”。 | double | 0.8 | low | |
| ssl.cipher.suites | 密码套件列表。是TLS或SSL网络协议来协商用于网络连接的安全设置的认证，加密，MAC和密钥交换算法的命名组合。默认情况下，支持所有可用的密码套件。 | list | null | low | |
| ssl.endpoint.identification.algorithm | 使用服务器证书验证服务器主机名的端点识别算法。 | string | null | low | |
| ssl.keymanager.algorithm | 用于SSL连接的密钥管理工厂算法。默认值是Java虚拟机配置的密钥管理器工厂算法。 | string | SunX509 | low | |
| ssl.secure.random.implementation | 用于SSL加密操作的SecureRandom PRNG实现。 | string | null | low | |
| ssl.trustmanager.algorithm | 用于SSL连接的信任管理工厂算法，默认是Java虚拟机机制。 | string | PKIX | low |
参考链接：
http://kafka.apachecn.org/documentation.html#configuration
http://www.orchome.com/472
698
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
