以下內容部分翻譯至 http://kafka.apache.org/intro

kafka介紹

我們認為，一個流處理平臺具有三個關鍵能力：

1. 發布和訂閱消息（流），在這方面，它類似于一個消息隊列或企業消息系統。

2. 以容錯的方式存儲消息（流）。

3. 在消息流發生時處理它們。

什么是kakfa的優勢？

它應用于2大類應用：

1. 構建實時的流數據管道，可靠地獲取系統和應用程序之間的數據。

2. 構建實時流的應用程序，對數據流進行轉換或反應。

要了解kafka是如何做這些事情的，讓我們從下到上深入探討kafka的能力。

首先幾個概念：

1. kafka作為一個集群運行在一個或多個服務器上。

2. kafka集群存儲的消息是以topic為類別記錄的。

3. 每個消息（也叫記錄record，我習慣叫消息）是由一個key，一個value和時間戳構成。

kafka有四個核心API：

• 應用程序使用 Producer API 發布消息到1個或多個topic（主題）。

• 應用程序使用 Consumer API 來訂閱一個或多個topic，并處理產生的消息。

• 應用程序使用 Streams API 充當一個流處理器，從1個或多個topic消費輸入流，并生產一個輸出流到1個或多個輸出topic，有效地將輸入流轉換到輸出流。

• Connector API允許構建或運行可重復使用的生產者或消費者，將topic連接到現有的應用程序或數據系統。例如，一個關系數據庫的連接器可捕獲每一個變化。

image

Client和Server之間的通訊，是通過一條簡單、高性能并且和開發語言無關的TCP協議。并且該協議保持與老版本的兼容。Kafka提供了Java Client（客戶端）。除了Java Client外，還有非常多的其它編程語言的Client。

首先來了解一下Kafka所使用的基本術語：

Topic

Kafka將消息種子(Feed)分門別類，每一類的消息稱之為一個主題(Topic).

Producer

發布消息的對象稱之為主題生產者(Kafka topic producer)

Consumer

訂閱消息并處理發布的消息的種子的對象稱之為主題消費者(consumers)

Broker

已發布的消息保存在一組服務器中，稱之為Kafka集群。集群中的每一個服務器都是一個代理(Broker). 消費者可以訂閱一個或多個主題（topic），并從Broker拉數據，從而消費這些已發布的消息。

主題和日志 (Topic和Log)

讓我們更深入的了解Kafka中的Topic。

Topic是發布的消息的類別或者種子Feed名。對于每一個Topic，Kafka集群維護這一個分區的log，就像下圖中的示例：

image

每一個分區都是一個順序的、不可變的消息隊列， 并且可以持續的添加。分區中的消息都被分了一個序列號，稱之為偏移量(offset)，在每個分區中此偏移量都是唯一的。

image

分布式(Distribution)

Log的分區被分布到集群中的多個服務器上。每個服務器處理它分到的分區。 根據配置每個分區還可以復制到其它服務器作為備份容錯。 每個分區有一個leader，零或多個follower。Leader處理此分區的所有的讀寫請求，而follower被動的復制數據。如果leader宕機，其它的一個follower會被推舉為新的leader。 一臺服務器可能同時是一個分區的leader，另一個分區的follower。 這樣可以平衡負載，避免所有的請求都只讓一臺或者某幾臺服務器處理。

Geo-Replication(異地數據同步技術)

Kafka MirrorMaker為群集提供geo-replication支持。借助MirrorMaker，消息可以跨多個數據中心或云區域進行復制。 您可以在active/passive場景中用于備份和恢復; 或者在active/passive方案中將數據置于更接近用戶的位置，或數據本地化。

生產者(Producers)

生產者往某個Topic上發布消息。生產者也負責選擇發布到Topic上的哪一個分區。最簡單的方式從分區列表中輪流選擇。也可以根據某種算法依照權重選擇分區。開發者負責如何選擇分區的算法。

消費者(Consumers)

image

2個kafka集群托管4個分區（P0-P3），2個消費者組，消費組A有2個消費者實例，消費組B有4個。

正像傳統的消息系統一樣，Kafka保證消息的順序不變。 再詳細扯幾句。傳統的隊列模型保持消息，并且保證它們的先后順序不變。但是， 盡管服務器保證了消息的順序，消息還是異步的發送給各個消費者，消費者收到消息的先后順序不能保證了。這也意味著并行消費將不能保證消息的先后順序。用過傳統的消息系統的同學肯定清楚，消息的順序處理很讓人頭痛。如果只讓一個消費者處理消息，又違背了并行處理的初衷。 在這一點上Kafka做的更好，盡管并沒有完全解決上述問題。 Kafka采用了一種分而治之的策略：分區。 因為Topic分區中消息只能由消費者組中的唯一一個消費者處理，所以消息肯定是按照先后順序進行處理的。但是它也僅僅是保證Topic的一個分區順序處理，不能保證跨分區的消息先后處理順序。 所以，如果你想要順序的處理Topic的所有消息，那就只提供一個分區。

Kafka的保證(Guarantees)

• 生產者發送到一個特定的Topic的分區上，消息將會按照它們發送的順序依次加入，也就是說，如果一個消息M1和M2使用相同的producer發送，M1先發送，那么M1將比M2的offset低，并且優先的出現在日志中。

• 消費者收到的消息也是此順序。

• 如果一個Topic配置了復制因子（replication factor）為N， 那么可以允許N-1服務器宕機而不丟失任何已經提交（committed）的消息。

有關這些保證的更多詳細信息，請參見文檔的設計部分。

kafka作為一個消息系統

Kafka的流與傳統企業消息系統相比的概念如何？

傳統的消息有兩種模式：隊列和發布訂閱。 在隊列模式中，消費者池從服務器讀取消息（每個消息只被其中一個讀取）; 發布訂閱模式：消息廣播給所有的消費者。這兩種模式都有優缺點，隊列的優點是允許多個消費者瓜分處理數據，這樣可以擴展處理。但是，隊列不像多個訂閱者，一旦消息者進程讀取后故障了，那么消息就丟了。而發布和訂閱允許你廣播數據到多個消費者，由于每個訂閱者都訂閱了消息，所以沒辦法縮放處理。

kafka中消費者組有兩個概念：隊列：消費者組（consumer group）允許同名的消費者組成員瓜分處理。發布訂閱：允許你廣播消息給多個消費者組（不同名）。

kafka的每個topic都具有這兩種模式。

kafka有比傳統的消息系統更強的順序保證。

傳統的消息系統按順序保存數據，如果多個消費者從隊列消費，則服務器按存儲的順序發送消息，但是，盡管服務器按順序發送，消息異步傳遞到消費者，因此消息可能亂序到達消費者。這意味著消息存在并行消費的情況，順序就無法保證。消息系統常常通過僅設1個消費者來解決這個問題，但是這意味著沒用到并行處理。

kafka做的更好。通過并行topic的parition —— kafka提供了順序保證和負載均衡。每個partition僅由同一個消費者組中的一個消費者消費到。并確保消費者是該partition的唯一消費者，并按順序消費數據。每個topic有多個分區，則需要對多個消費者做負載均衡，但請注意，相同的消費者組中不能有比分區更多的消費者，否則多出的消費者一直處于空等待，不會收到消息。

kafka作為一個存儲系統

所有發布消息到消息隊列和消費分離的系統，實際上都充當了一個存儲系統（發布的消息先存儲起來）。Kafka比別的系統的優勢是它是一個非常高性能的存儲系統。

寫入到kafka的數據將寫到磁盤并復制到集群中保證容錯性。并允許生產者等待消息應答，直到消息完全寫入。

kafka的磁盤結構 - 無論你服務器上有50KB或50TB，執行是相同的。

client來控制讀取數據的位置。你還可以認為kafka是一種專用于高性能，低延遲，提交日志存儲，復制，和傳播特殊用途的分布式文件系統。

kafka的流處理

僅僅讀，寫和存儲是不夠的，kafka的目標是實時的流處理。

在kafka中，流處理持續獲取輸入topic的數據，進行處理加工，然后寫入輸出topic。例如，一個零售APP，接收銷售和出貨的輸入流，統計數量或調整價格后輸出。

可以直接使用producer和consumer API進行簡單的處理。對于復雜的轉換，Kafka提供了更強大的Streams API。可構建聚合計算或連接流到一起的復雜應用程序。

助于解決此類應用面臨的硬性問題：處理無序的數據，代碼更改的再處理，執行狀態計算等。

Sterams API在Kafka中的核心：使用producer和consumer API作為輸入，利用Kafka做狀態存儲，使用相同的組機制在stream處理器實例之間進行容錯保障。

拼在一起

消息傳遞，存儲和流處理的組合看似反常，但對于Kafka作為流式處理平臺的作用至關重要。

像HDFS這樣的分布式文件系統允許存儲靜態文件來進行批處理。這樣系統可以有效地存儲和處理來自過去的歷史數據。

傳統企業的消息系統允許在你訂閱之后處理未來的消息：在未來數據到達時處理它。

Kafka結合了這兩種能力，這種組合對于kafka作為流處理應用和流數據管道平臺是至關重要的。

批處理以及消息驅動應用程序的流處理的概念：通過組合存儲和低延遲訂閱，流處理應用可以用相同的方式對待過去和未來的數據。它是一個單一的應用程序，它可以處理歷史的存儲數據，當它處理到最后一個消息時，它進入等待未來的數據到達，而不是結束。

同樣，對于流數據管道（pipeline），訂閱實時事件的組合使得可以將Kafka用于非常低延遲的管道；但是，可靠地存儲數據的能力使得它可以將其用于必須保證傳遞的關鍵數據，或與僅定期加載數據或長時間維護的離線系統集成在一起。流處理可以在數據到達時轉換它。

使用場景

1. Messaging

對于一些常規的消息系統,kafka是個不錯的選擇;partitons/replication和容錯,可以使kafka具有良好的擴展性和性能優勢.不過到目前為止,我們應該很清楚認識到,kafka并沒有提供JMS中的"事務性""消息傳輸擔保(消息確認機制)""消息分組"等企業級特性;kafka只能使用作為"常規"的消息系統,在一定程度上,尚未確保消息的發送與接收絕對可靠(比如,消息重發,消息發送丟失等)

2. Websit activity tracking

kafka可以作為"網站活性跟蹤"的最佳工具;可以將網頁/用戶操作等信息發送到kafka中.并實時監控,或者離線統計分析等

3. Log Aggregation

kafka的特性決定它非常適合作為"日志收集中心";application可以將操作日志"批量""異步"的發送到kafka集群中,而不是保存在本地或者DB中;kafka可以批量提交消息/壓縮消息等,這對producer端而言,幾乎感覺不到性能的開支.此時consumer端可以使hadoop等其他系統化的存儲和分析系統.

原理

kafka的設計初衷是希望作為一個統一的信息收集平臺,能夠實時的收集反饋信息,并需要能夠支撐較大的數據量,且具備良好的容錯能力.

1、持久性

kafka使用文件存儲消息,這就直接決定kafka在性能上嚴重依賴文件系統的本身特性.且無論任何OS下,對文件系統本身的優化幾乎沒有可能.文件緩存/直接內存映射等是常用的手段.因為kafka是對日志文件進行append操作,因此磁盤檢索的開支是較小的;同時為了減少磁盤寫入的次數,broker會將消息暫時buffer起來,當消息的個數(或尺寸)達到一定閥值時,再flush到磁盤,這樣減少了磁盤IO調用的次數.

2、性能

需要考慮的影響性能點很多,除磁盤IO之外,我們還需要考慮網絡IO,這直接關系到kafka的吞吐量問題.kafka并沒有提供太多高超的技巧;對于producer端,可以將消息buffer起來,當消息的條數達到一定閥值時,批量發送給broker;對于consumer端也是一樣,批量fetch多條消息.不過消息量的大小可以通過配置文件來指定.對于kafka broker端,似乎有個sendfile系統調用可以潛在的提升網絡IO的性能:將文件的數據映射到系統內存中,socket直接讀取相應的內存區域即可,而無需進程再次copy和交換. 其實對于producer/consumer/broker三者而言,CPU的開支應該都不大,因此啟用消息壓縮機制是一個良好的策略;壓縮需要消耗少量的CPU資源,不過對于kafka而言,網絡IO更應該需要考慮.可以將任何在網絡上傳輸的消息都經過壓縮.kafka支持gzip/snappy等多種壓縮方式.

3、生產者

負載均衡: producer將會和Topic下所有partition leader保持socket連接;消息由producer直接通過socket發送到broker,中間不會經過任何"路由層".事實上,消息被路由到哪個partition上,有producer客戶端決定.比如可以采用"random""key-hash""輪詢"等,如果一個topic中有多個partitions,那么在producer端實現"消息均衡分發"是必要的.

其中partition leader的位置(host:port)注冊在zookeeper中,producer作為zookeeper client,已經注冊了watch用來監聽partition leader的變更事件.

異步發送：將多條消息暫且在客戶端buffer起來，并將他們批量的發送到broker，小數據IO太多，會拖慢整體的網絡延遲，批量延遲發送事實上提升了網絡效率。不過這也有一定的隱患，比如說當producer失效時，那些尚未發送的消息將會丟失。

4、消費者

consumer端向broker發送"fetch"請求,并告知其獲取消息的offset;此后consumer將會獲得一定條數的消息;consumer端也可以重置offset來重新消費消息.

在JMS實現中,Topic模型基于push方式,即broker將消息推送給consumer端.不過在kafka中,采用了pull方式,即consumer在和broker建立連接之后,主動去pull(或者說fetch)消息;這中模式有些優點,首先consumer端可以根據自己的消費能力適時的去fetch消息并處理,且可以控制消息消費的進度(offset);此外,消費者可以良好的控制消息消費的數量,batch fetch.

kafka安裝和簡單使用(以mac為例)

安裝

# kafka依賴zookeeper 這里使用brew安裝， 自動會安裝　zookeeper
?
brew install kafka
==> Installing dependencies for kafka: zookeeper
==> Installing kafka dependency: zookeeper
==> Downloading https://homebrew.bintray.com/bottles/zookeeper-3.4.13.high_sierra.bottle.tar.gz
######################################################################## 100.0%
==> Pouring zookeeper-3.4.13.high_sierra.bottle.tar.gz
==> Caveats
To have launchd start zookeeper now and restart at login:
 brew services start zookeeper
Or, if you don't want/need a background service you can just run:
 zkServer start
==> Summary
??  /usr/local/Cellar/zookeeper/3.4.13: 244 files, 33.4MB
==> Installing kafka
==> Downloading https://homebrew.bintray.com/bottles/kafka-2.0.0.high_sierra.bottle.tar.gz
######################################################################## 100.0%
==> Pouring kafka-2.0.0.high_sierra.bottle.tar.gz
==> Caveats
To have launchd start kafka now and restart at login:
 brew services start kafka
Or, if you don't want/need a background service you can just run:
 zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties & kafka-server-start /usr/local/etc/kafka/server.properties
==> Summary
??  /usr/local/Cellar/kafka/2.0.0: 160 files, 46.8MB
==> Caveats
==> zookeeper
To have launchd start zookeeper now and restart at login:
 brew services start zookeeper
Or, if you don't want/need a background service you can just run:
 zkServer start
==> kafka
To have launchd start kafka now and restart at login:
 brew services start kafka
Or, if you don't want/need a background service you can just run:
 zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties & kafka-server-start /usr/local/etc/kafka/server.properties

上面可以看出 配置文件在 /usr/local/etc/kafka 下面</pre>

kafka的文件目錄

 brew list kafka
/usr/local/Cellar/kafka/2.0.0/.bottle/etc/ (14 files)
/usr/local/Cellar/kafka/2.0.0/bin/connect-distributed
/usr/local/Cellar/kafka/2.0.0/bin/connect-standalone
/usr/local/Cellar/kafka/2.0.0/bin/kafka-acls
/usr/local/Cellar/kafka/2.0.0/bin/kafka-broker-api-versions
/usr/local/Cellar/kafka/2.0.0/bin/kafka-configs
/usr/local/Cellar/kafka/2.0.0/bin/kafka-console-consumer
/usr/local/Cellar/kafka/2.0.0/bin/kafka-console-producer
/usr/local/Cellar/kafka/2.0.0/bin/kafka-consumer-groups
/usr/local/Cellar/kafka/2.0.0/bin/kafka-consumer-perf-test
/usr/local/Cellar/kafka/2.0.0/bin/kafka-delegation-tokens
/usr/local/Cellar/kafka/2.0.0/bin/kafka-delete-records
/usr/local/Cellar/kafka/2.0.0/bin/kafka-dump-log
/usr/local/Cellar/kafka/2.0.0/bin/kafka-log-dirs
/usr/local/Cellar/kafka/2.0.0/bin/kafka-mirror-maker
/usr/local/Cellar/kafka/2.0.0/bin/kafka-preferred-replica-election
/usr/local/Cellar/kafka/2.0.0/bin/kafka-producer-perf-test
/usr/local/Cellar/kafka/2.0.0/bin/kafka-reassign-partitions
/usr/local/Cellar/kafka/2.0.0/bin/kafka-replica-verification
/usr/local/Cellar/kafka/2.0.0/bin/kafka-run-class
/usr/local/Cellar/kafka/2.0.0/bin/kafka-server-start
/usr/local/Cellar/kafka/2.0.0/bin/kafka-server-stop
/usr/local/Cellar/kafka/2.0.0/bin/kafka-streams-application-reset
/usr/local/Cellar/kafka/2.0.0/bin/kafka-topics
/usr/local/Cellar/kafka/2.0.0/bin/kafka-verifiable-consumer
/usr/local/Cellar/kafka/2.0.0/bin/kafka-verifiable-producer
/usr/local/Cellar/kafka/2.0.0/bin/trogdor
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-security-migration
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-server-start
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-server-stop
/usr/local/Cellar/kafka/2.0.0/bin/zookeeper-shell
/usr/local/Cellar/kafka/2.0.0/homebrew.mxcl.kafka.plist
/usr/local/Cellar/kafka/2.0.0/libexec/bin/ (30 files)
/usr/local/Cellar/kafka/2.0.0/libexec/libs/ (81 files)

brew將kafka安裝在/usr/local/Cellar/kafka/2.0.0下
另外 kafka的配置文件 在 /usr/local/etc/kafka下面，配置文件也可以在其他地方，啟動的時候指定就可以了。
?

我們看下配置：/usr/local/Cellar/kafka/2.0.0 文件

tree -L 2
.
├── INSTALL_RECEIPT.json
├── LICENSE
├── NOTICE
├── bin
│   ├── connect-distributed
│   ├── connect-standalone
│   ├── kafka-acls
│   ├── kafka-broker-api-versions
│   ├── kafka-configs
│   ├── kafka-console-consumer
│   ├── kafka-console-producer
│   ├── kafka-consumer-groups
│   ├── kafka-consumer-perf-test
│   ├── kafka-delegation-tokens
│   ├── kafka-delete-records
│   ├── kafka-dump-log
│   ├── kafka-log-dirs
│   ├── kafka-mirror-maker
│   ├── kafka-preferred-replica-election
│   ├── kafka-producer-perf-test
│   ├── kafka-reassign-partitions
│   ├── kafka-replica-verification
│   ├── kafka-run-class
│   ├── kafka-server-start
│   ├── kafka-server-stop
│   ├── kafka-streams-application-reset
│   ├── kafka-topics
│   ├── kafka-verifiable-consumer
│   ├── kafka-verifiable-producer
│   ├── trogdor
│   ├── zookeeper-security-migration
│   ├── zookeeper-server-start
│   ├── zookeeper-server-stop
│   └── zookeeper-shell
├── homebrew.mxcl.kafka.plist
└── libexec
 ├── bin
 ├── config -> ../../../../etc/kafka
 └── libs

bin: 程序的文件
libexec: 執行的文件、庫等， 執行的很多都是在這里面
下面介紹一下 bin子目錄；

bin主要是 用于啟動的sh腳本

 /usr/local/Cellar/kafka/2.0.0/libexec/bin  ll -a | awk '{print $9}'
?
.
..
connect-distributed.sh
connect-standalone.sh
kafka-acls.sh
kafka-broker-api-versions.sh
kafka-configs.sh
kafka-console-consumer.sh
kafka-console-producer.sh
kafka-consumer-groups.sh
kafka-consumer-perf-test.sh
kafka-delegation-tokens.sh
kafka-delete-records.sh
kafka-dump-log.sh
kafka-log-dirs.sh
kafka-mirror-maker.sh
kafka-preferred-replica-election.sh
kafka-producer-perf-test.sh
kafka-reassign-partitions.sh
kafka-replica-verification.sh
kafka-run-class.sh
kafka-server-start.sh
kafka-server-stop.sh
kafka-streams-application-reset.sh
kafka-topics.sh
kafka-verifiable-consumer.sh
kafka-verifiable-producer.sh
trogdor.sh
zookeeper-security-migration.sh
zookeeper-server-start.sh
zookeeper-server-stop.sh
zookeeper-shell.sh

?

看一下 kafka-server-start.sh

#!/bin/bash
# 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.
?
if [ $# -lt 1 ];
then
 echo "USAGE: $0 [-daemon] server.properties [--override property=value]*"
 exit 1
fi
base_dir=$(dirname $0)
?
if [ "x$KAFKA_LOG4J_OPTS" = "x" ]; then
 export KAFKA_LOG4J_OPTS="-Dlog4j.configuration=file:$base_dir/../config/log4j.properties"
fi
?
if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
 export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
fi
?
EXTRA_ARGS=${EXTRA_ARGS-'-name kafkaServer -loggc'}
?
COMMAND=$1
case $COMMAND in
 -daemon)
 EXTRA_ARGS="-daemon "$EXTRA_ARGS
 shift
 ;;
 *)
 ;;
esac
?
exec $base_dir/kafka-run-class.sh $EXTRA_ARGS kafka.Kafka "$@"

上面就是判斷 一下參數，然后調用 kafka-run-class.sh 加一些參數執行，這里就不介紹了

配置

zookeeper配置

vim /usr/local/etc/kafka/zookeeper.properties
?

# 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.
# the directory where the snapshot is stored.
dataDir=/usr/local/var/lib/zookeeper # 數據目錄
# the port at which the clients will connect
clientPort=2181 # 端口， 在kafka 中需要配置到這個端口上
# disable the per-ip limit on the number of connections since this is a non-production config
maxClientCnxns=0 # 最大連接數
?```
?
?
?
### kafka服務器配置
vim /usr/local/etc/kafka/
?
?```bash
考慮到配置說明太多，
cat /usr/local/etc/kafka/server.properties | grep "^#" -v |grep -v "^$"
broker.id=0 # 主要是 配置不同的節點服務器，集群中唯一標識
?
# 下面是一些性能參數
num.network.threads=3 
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
?
# 數據日志保存位置， kafka通過日志文件進行持久化的
log.dirs=/usr/local/var/lib/kafka-logs
num.partitions=1
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
?

這里統一集群中的，連接相同的zookeeper

zookeeper.connect=localhost:2181
zookeeper.connection.timeout.ms=6000
group.initial.rebalance.delay.ms=0
?
另外一個比較重要的是： 
服務開啟的監聽的端口
listeners=PLAINTEXT://:9092</pre>

修改配置 啟動 3個broker

在一臺機器上啟動三個broker監聽在不同端口上， 另外啟動zookeeper, 使用/usr/local/Cellar/kafka/2.0.0/libexec/bin/下的腳本啟動

先啟動zookeeper

/usr/local/Cellar/kafka/2.0.0/libexec/bin/zookeeper-server-start.sh /usr/local/etc/kafka/zookeeper.properties

zookeeper-server-start.sh 后面跟配置文件 即可

復制配置

cd /usr/local/etc/kafka/
cp server.properties server-00.properties
cp server.properties server-01.properties
cp server.properties server-02.properties
?
# 修改配置
vim server-00.properties
broker.id=0
listeners=PLAINTEXT://:9092
log.dirs=/usr/local/var/lib/kafka-logs-00
# 主要是修改上面的內容， 修改完 三個配置
?
?
# 啟動broker
/usr/local/Cellar/kafka/2.0.0/libexec/bin/kafka-server-start.sh /usr/local/etc/kafka/server-00.properties
?
# 第二個
/usr/local/Cellar/kafka/2.0.0/libexec/bin/kafka-server-start.sh /usr/local/etc/kafka/server-01.properties
?
?
# 第三個
/usr/local/Cellar/kafka/2.0.0/libexec/bin/kafka-server-start.sh /usr/local/etc/kafka/server-02.properties</pre>

### 簡單使用

# 創建topic
cd /usr/local/Cellar/kafka/2.0.0/libexec/bin/
./kafka-topics.sh --help # 查看使用
?
./kafka-topics.sh --zookeeper localhost:2181 --create --topic test --partitions 3 --replication-factor 3
?
# 查看topic的信息
./kafka-topics.sh --zookeeper localhost:2181 --describe --topic test
Topic:test  PartitionCount:3  ReplicationFactor:3  Configs:
 Topic: test  Partition: 0  Leader: 0  Replicas: 0,1,2  Isr: 0,1,2
 Topic: test  Partition: 1  Leader: 1  Replicas: 1,2,0  Isr: 1,2,0
 Topic: test  Partition: 2  Leader: 2  Replicas: 2,0,1  Isr: 2,0,1

# 列出所有的 topic
./kafka-topics.sh --zookeeper localhost:2181 --list
?
?
# 下面使用kafka的cli的方式演示生產者和消費者
?
./kafka-console-consumer.sh --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --topic test
?
# 上面消費者就啟動起來了
?
?
# 啟動生產者， > 后面輸入消息， 在消費者就可以接受到
./kafka-console-producer.sh --broker-list localhost:9092,localhost:9093,localhost:9094 --topic test
?
 ~ ./kafka-console-producer.sh --broker-list localhost:9092,localhost:9093,localhost:9094 --topic test
>hello
>world
>kafka hello world
?
~  ./kafka-console-consumer.sh --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --topic test
hello
world
kafka hello world
?</pre>

### kafka數據日志

### 配置在  log.dirs=/usr/local/var/lib/kafka-logs-00
?
~ cd /usr/local/var/lib/
 ~  ls
kafka-logs-00 kafka-logs-01 kafka-logs-02 zookeeper
?
.
├── __consumer_offsets-0
├── __consumer_offsets-12
├── __consumer_offsets-15
├── __consumer_offsets-18
├── __consumer_offsets-21
├── __consumer_offsets-24
├── __consumer_offsets-27
├── __consumer_offsets-3
├── __consumer_offsets-30
├── __consumer_offsets-33
├── __consumer_offsets-36
├── __consumer_offsets-39
├── __consumer_offsets-42
├── __consumer_offsets-45
├── __consumer_offsets-48
├── __consumer_offsets-6
├── __consumer_offsets-9
├── cleaner-offset-checkpoint
├── log-start-offset-checkpoint
├── meta.properties
├── recovery-point-offset-checkpoint
├── replication-offset-checkpoint
├── test-0
├── test-1
└── test-2
?
# 這里的文件對應不同的partition， offset等。</pre>

本文只是介紹搭建kafka， 具體接入到具體項目中使用，后面的文章后更新補充上。