Kafka集群性能测试实战指南：从规划到验证，全面掌握高效测试方案

#作者：程宏斌

概述

在分布式实时数据流场景下，随着数据量的增长，对Kafka集群的性能和稳定性的要求也很⾼。本篇博客将从⽣产者和消费者两⽅⾯来做性能测试，针对具体的业务和数据量，来调优Kafka集群。

内容

测试环境

本次测试的环境信息由三台物理机组成，具体信息如下所⽰：

测试⼯具

Kafka系统提供了测试⼯具kafka-producer-perf-test.sh和kafka-consumer-perf-test.sh，通过该⼯具可以对⽣产者性能和消费者性能进⾏测试，获取⼀组最佳的参数值，进⽽提升⽣产者的发送效率和消费者的读取效率。这⾥如果需要实现带有线程参数功能的⼯具，可以修改⼯具源代码，新建⼀个kafka-producer-perf- test-0.8.sh脚本，实现内容如下：

使⽤⽼版本的ProducerPerformance⼯具类

exec $(dirname $0)/kafka-run-class.sh kafka.tools.ProducerPerformance "$@"

⽣产者测试

⽣产者测试，分别从线程数、分区数、副本数、Broker数、同步与异步模式、批处理⼤⼩、消息长度⼤⼩、数据压缩等维度来进⾏.

线程数

创建⼀个拥有6个分区、1个副本的Topic，设置不同的线程数并发送相同的数据量，查看性能变化。测试脚本如下：
创建主题

 ./kafka-topics.sh --create  --zookeeper 10.209.241.173:2181,10.209.241.178:2181,10.209.241.189:2181 --topic my

生产测试

./kafka-producer-perf-test.sh --topic mytest --record-size 10240 --num-records 200000 --producer-props bootstrap.servers=10.209.241.179:9092,10.209.241.187:9092,10.209.241.192:9092  --throughput -1

结论
向⼀个拥有6个分区、1个副本的Topic中，发送500万条消息记录时，随着线程数的增加，每秒发送的消息记录会逐渐增加。在线程数为25时，每秒发送的消息记录达到最佳值，随后再增加线程数，每秒发送的消息记录数反⽽会减少。

分区数

（1） 新建⼀个拥有12个分区、1个副本的主题；
（2） 新建⼀个拥有24个分区、1个副本的主题；
（3） 向拥有12个分区、1个副本的主题中发送相同数量的消息记录，查看性能变化；
（4） 向拥有24个分区、1个副本的主题中发送相同数量的消息记录，查看性能变化。
执⾏命令如下：
创建⼀个拥有12个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_producer_perf_p12 --partitions 12 --replication-factor 1

创建⼀个拥有24个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_producer_perf_p24 --partitions 24 --replication-factor 1

⽤⼀个线程发送数据到拥有12个分区的主题中

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_p12 --threads 1 --broker-list dn1:9092, dn2:9092, dn3:9092

⽤⼀个线程发送数据到拥有24个分区的主题中

[hadoop@dn1 ~]$ kafka-producer-perf-tes.sh --messages 5000000 --topics test_producer_perf_p24 --threads 1 --broker-list dn1:9092, dn2:9092, dn3:9092

结论
从测试结果来看，分区数越多，单线程⽣产者的吞吐量越⼩。

副本数

（1） 创建⼀个拥有两个副本、6个分区的主题；
（2） 创建⼀个拥有3个副本、6个分区的主题；
（3） 向拥有两个副本、6个分区的主题中发送相同数量的消息记录，查看性能变化；
（4） 向拥有3个副本、6个分区的主题中发送相同数量的消息记录，查看性能变化；
执⾏命令如下：
创建⼀个拥有两个副本、6个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181,dn3:2181 --topic test_producer_perf_r2 --partitions 6 --replication-factor 2

创建⼀个拥有3个副本、6个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_producer_perf_r3 --partitions 6 --replication-factor 3

⽤3个线程发送数据到拥有两个副本的主题中

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_r2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092

⽤3个线程发送数据到拥有3个副本的主题中

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_r3 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092

结论
从测试结果来看，副本数越多，吞吐量越⼩。

Broker数量

通过增加Broker节点数量来查看性能变化，脚本如下：
Kafka节点数为4个时，异步发送消息记录

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_b3 --threads 3 --broker-list dn1:9092,dn2:9092, dn3:9092, dn4:9092 --batch-size 3000 --request-timeout-ms 100000

结论
从测试结果来看，增加Kafka Broker数量，吞吐量会增加。

同步与异步模式

分别使⽤同步和异步模式发送相同数量的消息记录，查看性能变化。执⾏脚本如下：
创建⼀个有⽤3个副本、6个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_producer_perf_s2 --partitions 6 --replication-factor 3

使⽤同步模式发送消息数据

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --sync

使⽤异步模式发送消息记录

[hadoop@dn1 ~]$ kafka-producer-perf-test h --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092

结论
从测试结果来看，使⽤异步模式发送消息数据，⽐使⽤同步模式发送消息数据，吞吐量是同步模式的3倍左右。

批处理⼤⼩

使⽤异步模式发送相同数量的消息数据，改变批处理量的⼤⼩，查看性能变化，执⾏脚本如下：
以批处理模式发送，⼤⼩为1000条

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 1000 --request-timeout-ms 100000

以批处理模式发送，⼤⼩为3000条

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 3000 --request-timeout-ms 100000

以批处理模式发送，⼤⼩为5000条

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 5000 --request-timeout-ms 100000

以批处理模式发送，⼤⼩为7000条

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 7000 --request-timeout-ms 100000

结论
从测试的结果来看，发送的消息随着批处理⼤⼩增加⽽增加。当批处理⼤⼩增加到3000~5000时，吞吐量达到最佳值。⽽后再增加批处理⼤⼩，吞吐量的性能会下降。

消息长度的⼤⼩

改变消息的长度⼤⼩，查看性能变化，执⾏脚本如下：
发送消息，长度为100字节

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 3000 --request-timeout-ms 100000 --message-size 100

发送消息，长度为200字节

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 3000 --request-timeout-ms 100000 --message-size 200

发送消息，长度为500字节

[hadoop@dn1 ~]$ kafka-producer-perf-test.sh --messages 5000000 --topics test_producer_perf_s2 --threads 3 --broker-list dn1:9092, dn2:9092, dn3:9092 --batch-size 3000 --request-timeout-ms 100000 --message-size 500

结论
从测试结果来看，随着消息长度的增加，每秒所能发送的消息数量逐渐减少（nMsg/sec）。但是，每秒发送的消息的总⼤⼩（MB/sec），会随着消息长度的增加⽽增加。

消费者测试

消费者测试，可以从线程数、分区数、副本数等维度来进⾏测试。

线程数

创建⼀个拥有6个分区、1个备份的Topic，⽤不同的线程数读取相同的数据量，查看性能变化。测试脚本如下：
创建主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_consumer_perf --partitions 6 --replication-factor 1

设置1个线程数

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh –zookeeper dn1:2181,dn2:2181,dn3:2181 --messages 5000000 --topic test_consumer_perf --group g1 --threads 1

设置3个线程数

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh –zookeeper dn1:2181,dn2:2181,dn3:2181 --messages 5000000 --topic test_consumer_perf --group g2 --threads 3

设置6个线程数

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh –zookeeper dn1:2181,dn2:2181,dn3:2181 --messages 5000000 --topic test_consumer_perf --group g3 --threads 6

结论
随着线程数的增加，每秒读取的消息记录会逐渐增加。在线程数与消费主题的分区相等时，吞吐量达到最佳值。随后，再增加线程数，新增的线程数将会处于空闲状态，对提升消费者程序的吞吐量没有帮助。

分区数

新建⼀个Topic，改变它的分区数，读取相同数量的消息记录，查看性能变化，执⾏脚本如下：
创建⼀个拥有12个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_consumer_perf_p12 --partitions 12 --replication-factor 1

创建⼀个拥有24个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 --topic test_consumer_perf_p24 --partitions 24 --replication-factor 1

⽤⼀个线程读取数据到拥有12个分区的主题中

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh –zookeeper dn1:2181,dn2:2181,dn3:2181 --messages 5000000 –topic test_consumer_perf_p12_--group g2 --threads 1 

⽤⼀个线程读取数据到拥有12个分区的主题中

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh –zookeeper  dn1:2181,dn2:2181,dn3:2181 --messages 5000000 –topic test_consumer_perf_p24_--group g3 --threads 1 

结论
当分区数增加时，如果线程数保持不变，则消费者程序的吞吐量性能会下降。

副本数

新建Topic，改变Topic的副本数，读取相同数量的消息记录，查看性能变化，执⾏脚本如下：
创建⼀个有⽤两个副本、6个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 –topic test_consumer_perf_r2 --partitions 6  --replication-factor 2 

创建⼀个有3个副本、6个分区的主题

[hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181, dn3:2181 –topic test_consumer_perf_r3 --partitions 6 --replication-factor 3 

⽤3个线程读取数据到拥有两个副本的主题中

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh –zookeeper dn1:2181 ,dn2:2181,dn3:2181 --messages 5000000 –topic test_consumer_perf_r2_--group g2 --threads 3 

⽤3个线程读取数据到拥有3个副本的主题中

[hadoop@dn1 ~]$ kafka-consumer-perf-test.sh --zookeeper dn1:2181 ,dn2:2181,dn3:2181 --messages 5000000 –topic test_consumer_perf_r3_--group g3 --threads 3 

结论
副本数对消费者程序的吞吐量影响较⼩，消费者程序是从Topic的每个分区的Leader上读取数据的，⽽与副本数⽆关。