Kafka性能測試實例

1.概述

在分佈式實時數據流場景下，隨着數據量的增加，對Kafka集羣的性能和穩定性的要求也很高。本篇博客將從生產者和消費者兩方面來作性能測試，針對具體的業務和數據量，來調優Kafka集羣。

2.內容

2.1 測試環境

本次測試的環境信息由三臺物理機組成，具體信息以下所示：

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 生產者測試參數

 

2.2.2 消費者測試參數

3.生產者測試

生產者測試，分別從線程數、分區數、副本數、Broker數、同步與異步模式、批處理大小、消息長度大小、數據壓縮等維度來進行。

3.1 線程數

建立一個擁有6個分區、1個副本的Topic，設置不一樣的線程數併發送相同的數據量，查看性能變化。測試腳本以下：

# 建立主題
[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

3.1.1 測試結果

3.1.2 結論

向一個擁有6個分區、1個副本的Topic中，發送500萬條消息記錄時，隨着線程數的增長，每秒發送的消息記錄會逐漸增長。在線程數爲25時，每秒發送的消息記錄達到最佳值，隨後再增長線程數，每秒發送的消息記錄數反而會減小。

3.2 分區數

（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-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

3.2.1 測試結果

3.2.2 結論

從測試結果來看，分區數越多，單線程生產者的吞吐量越小。

3.3 副本數

（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-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

3.3.1 測試結果

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 測試結果

3.4.2 結論

從測試結果來看，增長Kafka Broker數量，吞吐量會增長。

3.5 同步與異步模式

分別使用同步和異步模式發送相同數量的消息記錄，查看性能變化。執行腳本以下：

# 建立一個有用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

3.5.1 測試結果

3.5.2 結論

從測試結果來看，使用異步模式發送消息數據，比使用同步模式發送消息數據，吞吐量是同步模式的3倍左右。

3.6 批處理大小

使用異步模式發送相同數量的消息數據，改變批處理量的大小，查看性能變化，執行腳本以下：

# 以批處理模式發送，大小爲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

3.6.1 測試結果

3.6.2 結論

從測試的結果來看，發送的消息隨着批處理大小增長而增長。當批處理大小增長到3000~5000時，吞吐量達到最佳值。然後再增長批處理大小，吞吐量的性能會降低。

3.7 消息長度的大小

改變消息的長度大小，查看性能變化，執行腳本以下：

# 發送消息，長度爲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

3.7.1 測試結果

3.7.2 結論

從測試結果來看，隨着消息長度的增長，每秒所能發送的消息數量逐漸減小（nMsg/sec）。可是，每秒發送的消息的總大小（MB/sec），會隨着消息長度的增長而增長。

4.消費者測試

消費者測試，能夠從線程數、分區數、副本數等維度來進行測試。

4.1 線程數

建立一個擁有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

4.1.1 測試結果

4.1.2 結論

隨着線程數的增長，每秒讀取的消息記錄會逐漸增長。在線程數與消費主題的分區相等時，吞吐量達到最佳值。隨後，再增長線程數，新增的線程數將會處於空閒狀態，對提高消費者程序的吞吐量沒有幫助。

4.2 分區數

新建一個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

4.2.1 測試結果

4.2.2 結論

當分區數增長時，若是線程數保持不變，則消費者程序的吞吐量性能會降低。

4.3 副本數 

新建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

4.3.1 測試結果

4.3.2 結論

副本數對消費者程序的吞吐量影響較小，消費者程序是從Topic的每一個分區的Leader上讀取數據的，而與副本數無關。 

5.總結

Kafka性能測試步驟並不複雜，你們能夠根據實際的測試環境、數據量，經過對生產者和消費者不一樣維度的測試，來獲取一組最佳的調優參數值。

6.結束語

這篇博客就和你們分享到這裏，若是你們在研究學習的過程中有什麼問題，能夠加羣進行討論或發送郵件給我，我會盡我所能爲您解答，與君共勉！

另外，博主出書了《Kafka並不難學》，喜歡的朋友或同窗， 能夠在公告欄那裏點擊購買連接購買博主的書進行學習，在此感謝你們的支持。