Kafka性能测试实例

不念不忘少年蓝@ 2022-01-30 15:37 233阅读 0赞

# 1.概述 #

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

# 2.内容 #

## 2.1 测试环境 ##

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

## ![666745-20181209203937106-1226673950.png][] ##

## 2.2 测试工具 ##

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 "$@"

### 2.2.1 生产者测试参数 ###

![666745-20181209204019736-1863850080.png][]

### 2.2.2 消费者测试参数 ###

![666745-20181209204054247-804978831.png][]

# 3.生产者测试 #

生产者测试，分别从线程数、分区数、副本数、Broker数、同步与异步模式、批处理大小、消息长度大小、数据压缩等维度来进行。

## 3.1 线程数 ##

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

![复制代码][copycode.gif]

# 创建主题
    [hadoop@dn1 ~]$ kafka-topics.sh --create --zookeeper dn1:2181, dn2:2181,
     dn3:2181 --topic test_producer_perf --partitions 6 --replication-factor 1
    
    # 设置1个线程数
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.sh --messages 5000000
      --topics test_producer_perf --threads 1 --broker-list  dn1:9092, dn2:9092,
     dn3:9092
    
    # 设置10个线程数
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.sh --messages 5000000
      --topics test_producer_perf --threads 10 --broker-list  dn1:9092,
     dn2:9092, dn3:9092
    
    # 设置20个线程数
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.sh --messages 5000000
      --topics test_producer_perf --threads 20 --broker-list  dn1:9092,
     dn2:9092, dn3:9092
    
    # 设置25个线程数
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.sh --messages 5000000
      --topics test_producer_perf --threads 25 --broker-list  dn1:9092,
     dn2:9092, dn3:9092
    
    # 设置30个线程数
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.sh --messages 5000000
      --topics test_producer_perf --threads 30 --broker-list  dn1:9092,
     dn2:9092, dn3:9092

![复制代码][copycode.gif]

### 3.1.1 测试结果 ###

![666745-20181209204535179-758153566.png][]

### 3.1.2 结论 ###

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

## 3.2 分区数 ##

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

执行命令如下：

![复制代码][copycode.gif]

# 创建一个拥有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-0.8.sh --messages 5000000
      --topics test_producer_perf_p12 --threads 1 --broker-list  dn1:9092,
     dn2:9092, dn3:9092
    
    # 用一个线程发送数据到拥有24个分区的主题中
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.sh --messages 5000000
      --topics test_producer_perf_p24 --threads 1 --broker-list  dn1:9092,
     dn2:9092, dn3:9092

![复制代码][copycode.gif]

### 3.2.1 测试结果 ###

![666745-20181209224304483-636891023.png][]

### 3.2.2 结论 ###

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

## 3.3 副本数 ##

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

执行命令如下：

![复制代码][copycode.gif]

# 创建一个拥有两个副本、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-0.8.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-0.8.sh --messages 5000000
      --topics test_producer_perf_r3 --threads 3 --broker-list  dn1:9092,
     dn2:9092, dn3:9092

![复制代码][copycode.gif]

### 3.3.1 测试结果 ###

![666745-20181209224722093-127244098.png][]

### 3.3.2 结论 ###

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

### 3.4 Broker数量 ###

通过增加Broker节点数量来查看性能变化，脚本如下：

# Kafka节点数为4个时，异步发送消息记录
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.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

### 3.4.1 测试结果 ###

![666745-20181209225012861-185940575.png][]

### 3.4.2 结论 ###

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

## 3.5 同步与异步模式 ##

分别使用同步和异步模式发送相同数量的消息记录，查看性能变化。执行脚本如下：

![复制代码][copycode.gif]

# 创建一个有用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-0.8.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-0.8.sh --messages 5000000
      --topics test_producer_perf_s2 --threads 3 --broker-list  dn1:9092,
     dn2:9092, dn3:9092

![复制代码][copycode.gif]

### 3.5.1 测试结果 ###

![666745-20181209225226658-1878413535.png][]

### 3.5.2 结论 ###

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

## 3.6 批处理大小 ##

使用异步模式发送相同数量的消息数据，改变批处理量的大小，查看性能变化，执行脚本如下：

![复制代码][copycode.gif]

# 以批处理模式发送，大小为1000条
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.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-0.8.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-0.8.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-0.8.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

![复制代码][copycode.gif]

### 3.6.1 测试结果 ###

![666745-20181209225439600-1847161992.png][]

3.6.2 结论

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

## 3.7 消息长度的大小 ##

改变消息的长度大小，查看性能变化，执行脚本如下：

![复制代码][copycode.gif]

# 发送消息，长度为100字节
    [hadoop@dn1 ~]$ kafka-producer-perf-test-0.8.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-0.8.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-0.8.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

![复制代码][copycode.gif]

### 3.7.1 测试结果 ###

![666745-20181209225616114-1270879047.png][]

### 3.7.2 结论 ###

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

# 4.消费者测试 #

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

## 4.1 线程数 ##

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

![复制代码][copycode.gif]

# 创建主题
    [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

![复制代码][copycode.gif]

### 4.1.1 测试结果 ###

![666745-20181209222754429-2084486157.png][]

### 4.1.2 结论 ###

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

## 4.2 分区数 ##

新建一个Topic，改变它的分区数，读取相同数量的消息记录，查看性能变化，执行脚本如下：

![复制代码][copycode.gif]

# 创建一个拥有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

![复制代码][copycode.gif]

### 4.2.1 测试结果 ###

![666745-20181209225833387-1311325182.png][]

### 4.2.2 结论 ###

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

## 4.3 副本数  ##

新建Topic，改变Topic的副本数，读取相同数量的消息记录，查看性能变化，执行脚本如下：

![复制代码][copycode.gif]

# 创建一个有用两个副本、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

![复制代码][copycode.gif]

### 4.3.1 测试结果 ###

![666745-20181209230054414-812503574.png][]

4.3.2 结论

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

# 5.总结 #

Kafka性能测试步骤并不复杂，大家可以根据实际的测试环境、数据量，通过对生产者和消费者不同维度的测试，来获取一组最佳的调优参数值。

# 6.结束语 #

这篇博客就和大家分享到这里，如果大家在研究学习的过程当中有什么问题，可以加群进行讨论或发送邮件给我，我会尽我所能为您解答，与君共勉！

另外，博主出书了《[Kafka并不难学][Kafka]》，喜欢的朋友或同学， 可以在公告栏那里点击购买链接购买博主的书进行学习，在此感谢大家的支持。

[666745-20181209203937106-1226673950.png]: /images/20220130/b8e92dd64f8e4a6f86a981542f798127.png
[666745-20181209204019736-1863850080.png]: /images/20220130/a127d34afaf944859f41f8bd18521480.png
[666745-20181209204054247-804978831.png]: /images/20220130/aea095f150b54679ba1b286a733e222c.png
[copycode.gif]: /images/20220130/0ca721668bc9466ca8e53117e12b02a4.png
[666745-20181209204535179-758153566.png]: /images/20220130/2b306758f27a4663b0a4db812834a75e.png
[666745-20181209224304483-636891023.png]: /images/20220130/e851b767c2f042ecabee75e04dec8b24.png
[666745-20181209224722093-127244098.png]: /images/20220130/2a8e7a842c86459481e03ea7e3139ddf.png
[666745-20181209225012861-185940575.png]: /images/20220130/9d848c24d61442d1886e6de91c0e8274.png
[666745-20181209225226658-1878413535.png]: /images/20220130/3c8de11ee11a4a58b10434ad29ba1a59.png
[666745-20181209225439600-1847161992.png]: /images/20220130/5447b379bed44106ac348775108e676b.png
[666745-20181209225616114-1270879047.png]: /images/20220130/2939dd474361446390dad8e57acfeb6a.png
[666745-20181209222754429-2084486157.png]: /images/20220130/7f48eb955fd748dcb6af0c843587f797.png
[666745-20181209225833387-1311325182.png]: /images/20220130/1e89bbd06d684cc48e79e200b908aad3.png
[666745-20181209230054414-812503574.png]: /images/20220130/a9adf5fbdd804e4fb0e376c912fbda2b.png
[Kafka]: https://item.jd.com/12455361.html