kafka官網翻譯二：API使用，配置，設計

2. API

卡夫卡包括五個核心API：

1. 該生產 API允許應用程序發送數據流的卡夫卡集羣中的主題。
2. 該消費者 API允許應用程序從卡夫卡集羣中的主題讀取數據流。
3. 該流 API允許將來自輸入主題數據流輸出的主題。
4. 所述連接 API允許實現連接器，其連續地從一些源系統或應用拉進卡夫卡或從卡夫卡推入一些水槽系統或應用程序。
5. 該的AdminClient API允許管理和檢查課題，經紀人和其他卡夫卡對象。

Kafka通過獨立於語言的協議公開了所有功能，客戶端可以使用許多編程語言。但是，只有Java客戶端是作爲主要Kafka項目的一部分進行維護的，其他的則作爲獨立的開源項目提供。非Java客戶的名單可在這裏。

2.1生產者API

Producer API允許應用程序將數據流發送到Kafka集羣中的主題。

信息內數信亦 範範範辛中中內數信息中信息

要使用生產者，你可以使用下面的maven依賴：

1 2 3 4 五 6

<dependency>     <groupId>org.apache.kafka</groupId>     <artifactId>kafka-clients</artifactId>     <version>1.0.0</version> </dependency>

2.2消費者API

Consumer API允許應用程序從Kafka集羣中的主題讀取數據流。

展示如何使用消費者的例子在javadoc中給出 。

要使用使用者，你可以使用下面的maven依賴：

1 2 3 4 五 6

<dependency>     <groupId>org.apache.kafka</groupId>     <artifactId>kafka-clients</artifactId>     <version>1.0.0</version> </dependency>

2.3流API

該流 API允許將來自輸入主題數據流輸出的主題。

展示如何使用這個庫的例子在javadoc中給出

有關使用Streams API的其他文檔可以在這裏找到。

要使用Kafka Streams，您可以使用以下maven依賴項：

1 2 3 4 五 6

<dependency>     <groupId>org.apache.kafka</groupId>     <artifactId>kafka-streams</artifactId>     <version>1.0.0</version> </dependency>

2.4連接API

Connect API允許實現不斷從一些源數據系統中拉入Kafka的連接器，或者從Kafka推入一些接收器數據系統。

Connect的許多用戶不需要直接使用這個API，但是他們可以使用預先建立的連接器而不需要編寫任何代碼。有關使用Connect的更多信息，請點擊這裏。

那些想要實現自定義連接器的人可以看到javadoc。

2.5 AdminClient API

AdminClient API支持管理和檢查主題，代理，acl和其他Kafka對象。

要使用AdminClient API，請添加以下Maven依賴項：

1 2 3 4 五 6

<dependency>     <groupId>org.apache.kafka</groupId>     <artifactId>kafka-clients</artifactId>     <version>1.0.0</version> </dependency>

有關AdminClient API的更多信息，請參閱javadoc。

2.6傳統的API

卡夫卡還包括一個更有限的傳統生產者和消費者API。這些舊的Scala API已被棄用，只能用於兼容目的。關於他們的信息可以在這裏 找到。

 

 

3.配置

Kafka使用屬性文件格式的鍵值對進行配置。這些值可以從文件或編程方式提供。

3.1經紀人配置

基本配置如下：

• broker.id
• log.dirs
• zookeeper.connect

下面 將更詳細地討論主題級別的配置和默認設置。

名稱	描述	類型	默認	有效值	重要性
zookeeper.connect	Zookeeper主機字符串	串			高
advertised.host.name	DEPRECATED：僅在未設置“advertised.listeners”或“listeners”時使用。改用`advertised.listeners`。主機名發佈到ZooKeeper供客戶使用。在IaaS環境中，這可能需要與代理綁定的接口不同。如果未設置，則將使用“host.name”的值（如果已配置）。否則，它將使用從java.net.InetAddress.getCanonicalHostName（）返回的值。	串	空值		高
advertised.listeners	監聽器發佈到ZooKeeper供客戶端使用，如果不同於`​​listeners`配置屬性。在IaaS環境中，這可能需要與代理綁定的接口不同。如果沒有設置，將使用`listeners`的值。與“監聽者”不同，發佈0.0.0.0元地址是無效的。	串	空值		高
advertised.port	DEPRECATED：僅在未設置“advertised.listeners”或“listeners”時使用。改用`advertised.listeners`。發佈到ZooKeeper供客戶端使用的端口。在IaaS環境中，這可能需要與代理綁定的端口不同。如果沒有設置，它將發佈代理綁定到的相同端口。	INT	空值		高
auto.create.topics.enable	在服務器上啓用自動創建主題	布爾	真正		高
auto.leader.rebalance.enable	啓用自動領導者平衡。後臺線程會定期檢查並觸發領導平衡	布爾	真正		高
background.threads	用於各種後臺處理任務的線程數	INT	10	[1，...]	高
broker.id	此服務器的代理ID。如果未設置，則會生成唯一的代理標識。爲避免zookeeper生成的代理標識與用戶配置的代理標識之間的衝突，生成的代理標識從reserved.broker.max.id + 1開始。	INT	-1		高
compression.type	指定給定主題的最終壓縮類型。此配置接受標準壓縮編解碼器（'gzip'，'snappy'，'lz4'）。它另外接受相當於不壓縮的“未壓縮” 和“製作者”，這意味着保留製作者設置的原始壓縮編解碼器。	串	製片人		高
delete.topic.enable	啓用刪除主題。如果此配置已關閉，則通過管理工具刪除主題將不起作用	布爾	真正		高
主機名	DEPRECATED：僅在未設置“偵聽器”時使用。使用`listeners`來代替。經紀人的主機名。如果這個設置，它只會綁定到這個地址。如果沒有設置，它將綁定到所有接口	串	“”		高
leader.imbalance.check.interval.seconds	分區重新平衡檢查的頻率由控制器觸發	長	300		高
leader.imbalance.per.broker.percentage	每個經紀人允許的領導者不平衡比率。如果每個經紀人的價值高於這個值，控制器會觸發一個領導者的平衡。該值以百分比形式指定。	INT	10		高
聽衆	監聽器列表 - 逗號分隔的我們將監聽的URI列表和監聽器名稱。如果偵聽器名稱不是安全協議，則還必須設置listener.security.protocol.map。指定主機名爲0.0.0.0以綁定到所有接口。保留主機名爲空以綁定到默認界面。合法偵聽器列表的示例：PLAINTEXT：// myhost：9092，SSL：//：9091 CLIENT：//0.0.0.0：9092，REPLICATION：// localhost：9093	串	空值		高
log.dir	保存日誌數據的目錄（對log.dirs屬性的補充）	串	的/ tmp /卡夫卡-日誌		高
log.dirs	日誌數據保存的目錄。如果未設置，則使用log.dir中的值	串	空值		高
log.flush.interval.messages	在將消息刷新到磁盤之前，在日誌分區上累積的消息數量	長	9223372036854775807	[1，...]	高
log.flush.interval.ms	任何主題中的消息在刷新到磁盤之前都保留在內存中的最長時間（以毫秒爲單位）。如果未設置，則使用log.flush.scheduler.interval.ms中的值	長	空值		高
log.flush.offset.checkpoint.interval.ms	我們更新作爲日誌恢復點的最後一次刷新的持久記錄的頻率	INT	60000	[0，...]	高
log.flush.scheduler.interval.ms	日誌刷新器檢查是否需要將任何日誌刷新到磁盤的頻率（以毫秒爲單位）	長	9223372036854775807		高
log.flush.start.offset.checkpoint.interval.ms	我們更新記錄起始偏移量的持續記錄的頻率	INT	60000	[0，...]	高
log.retention.bytes	刪除之前日誌的最大大小	長	-1		高
log.retention.hours	保留日誌文件的小時數（以小時爲單位），大寫爲log.retention.ms屬性	INT	168		高
log.retention.minutes	在刪除日誌文件之前保留日誌的分鐘數（以分鐘爲單位），次要log.retention.ms屬性。如果未設置，則使用log.retention.hours中的值	INT	空值		高
log.retention.ms	保留日誌文件的毫秒數（以毫秒爲單位），如果未設置，則使用log.retention.minutes中的值	長	空值		高
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中的值	長	空值		高
log.roll.ms	新日誌段轉出之前的最長時間（以毫秒爲單位）。如果未設置，則使用log.roll.hours中的值	長	空值		高
log.segment.bytes	單個日誌文件的最大大小	INT	1073741824	[14，...]	高
log.segment.delete.delay.ms	從文件系統中刪除文件之前等待的時間	長	60000	[0，...]	高
message.max.bytes	卡夫卡允許的最大記錄批量大小。如果這個數字增加，並且有超過0.10.2的消費者，那麼消費者的提取大小也必須增加，以便他們可以取得這麼大的記錄批次。 在最新的消息格式版本中，記錄總是分組分批以提高效率。在以前的消息格式版本中，未壓縮的記錄不會分組到批次中，並且此限制僅適用於該情況下的單個記錄。 這可以使用主題級別max.message.bytes配置爲每個主題設置。	INT	1000012	[0，...]	高
min.insync.replicas	當生產者將ack設置爲“全部”（或“-1”）時，min.insync.replicas指定必須確認寫入被認爲成功的最小副本數。如果這個最小值不能滿足，那麼生產者將會引發一個異常（NotEnoughReplicas或NotEnoughReplicasAfterAppend）。 當一起使用時，min.insync.replicas和acks允許您執行更大的耐久性保證。一個典型的情況是創建一個複製因子爲3的主題，將min.insync.replicas設置爲2，並使用“全部”選項來產生。這將確保生產者如果大多數副本沒有收到寫入引發異常。	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	用於從源代理複製消息的讀取器線程數。增加此值可以提高跟隨者代理中的I / O並行度。	INT	1		高
offset.metadata.max.bytes	與偏移量提交相關聯的元數據條目的最大大小	INT	4096		高
offsets.commit.required.acks	提交之前所需的確認可以被接受。一般來說，默認值（-1）不應該被覆蓋	短	-1		高
offsets.commit.timeout.ms	偏移提交將被延遲，直到偏移量主題的所有副本都收到提交或達到此超時。這與生產者請求超時類似。	INT	5000	[1，...]	高
offsets.load.buffer.size	將偏移量加載到緩存中時從批量偏移段讀取的批量大小。	INT	5242880	[1，...]	高
offsets.retention.check.interval.ms	檢查失效偏移的頻率	長	600000	[1，...]	高
offsets.retention.minutes	比這個保留期更早的偏置將被丟棄	INT	1440	[1，...]	高
offsets.topic.compression.codec	用於偏移主題的壓縮編解碼器 - 壓縮可用於實現“原子”提交	INT	0		高
offsets.topic.num.partitions	偏移提交主題的分區數量（部署後不應更改）	INT	50	[1，...]	高
offsets.topic.replication.factor	偏移量主題的複製因子（設置得更高以確保可用性）。內部主題創建將失敗，直到羣集大小滿足此複製因子要求。	短	3	[1，...]	高
offsets.topic.segment.bytes	爲了便於更快的日誌壓縮和緩存加載，偏移量的主題段字節應保持相對較小	INT	104857600	[1，...]	高
港口	DEPRECATED：僅在未設置“偵聽器”時使用。使用`listeners`來代替。端口監聽和接受連接	INT	9092		高
queued.max.requests	阻塞網絡線程之前允許排隊的請求數量	INT	500	[1，...]	高
quota.consumer.default	DEPRECATED：僅在未配置動態默認配額時使用 要麼 在Zookeeper中。如果clientId / consumer組區分的每個客戶端獲取的字節數多於此值，那麼任何使用者都將被限制	長	9223372036854775807	[1，...]	高
quota.producer.default	DEPRECATED：僅在未配置動態默認配額時使用 ， 要麼 在Zookeeper中。如果產生的字節數大於每秒鐘的這個值，任何由clientId區分的生產者都將受到限制	長	9223372036854775807	[1，...]	高
replica.fetch.min.bytes	每個提取響應的預期最小字節數。如果沒有足夠的字節，請等待replicaMaxWaitTimeMs	INT	1		高
replica.fetch.wait.max.ms	跟隨者副本發出的每個獲取請求的最長等待時間。此值始終應始終小於replica.lag.time.max.ms，以防止針對低吞吐量主題頻繁收縮ISR	INT	500		高
replica.high.watermark.checkpoint.interval.ms	高水印被保存到磁盤的頻率	長	5000		高
replica.lag.time.max.ms	如果一個追隨者至少沒有發送任何提取請求，或者至少在這段時間內沒有消耗掉領導者的日誌偏移量，那麼領導者會從isr	長	10000		高
replica.socket.receive.buffer.bytes	套接字接收緩衝區的網絡請求	INT	65536		高
replica.socket.timeout.ms	網絡請求的套接字超時。它的值應該至少是replica.fetch.wait.max.ms	INT	30000		高
request.timeout.ms	配置控制客戶端等待請求響應的最長時間。如果在超時過去之前未收到響應，則客戶端將在必要時重新發送請求，或者如果重試耗盡，則請求失敗。	INT	30000		高
socket.receive.buffer.bytes	套接字服務器插槽的SO_RCVBUF緩衝區。如果值爲-1，則將使用操作系統默認值。	INT	102400		高
socket.request.max.bytes	套接字請求中的最大字節數	INT	104857600	[1，...]	高
socket.send.buffer.bytes	套接字服務器套接字的SO_SNDBUF緩衝區。如果值爲-1，則將使用操作系統默認值。	INT	102400		高
transaction.max.timeout.ms	交易的最大允許超時時間。如果客戶請求的交易時間超過這個時間，那麼代理將在InitProducerIdRequest中返回一個錯誤。這樣可以防止客戶過度超時，從而阻礙消費者閱讀交易中包含的主題。	INT	900000	[1，...]	高
transaction.state.log.load.buffer.size	將生產者ID和事務加載到緩存中時，從事務日誌段讀取的批量大小。	INT	5242880	[1，...]	高
transaction.state.log.min.isr	覆蓋事務主題的min.insync.replicas配置。	INT	2	[1，...]	高
transaction.state.log.num.partitions	事務主題的分區數量（部署後不應更改）。	INT	50	[1，...]	高
transaction.state.log.replication.factor	交易主題的複製因子（設置更高以確保可用性）。內部主題創建將失敗，直到羣集大小滿足此複製因子要求。	短	3	[1，...]	高
transaction.state.log.segment.bytes	事務主題段字節應保持相對較小，以便於更快的日誌壓縮和緩存負載	INT	104857600	[1，...]	高
transactional.id.expiration.ms	事務協調器在未收到任何事務狀態更新之前主動過期生產者的事務標識之前將等待的最長時間（以毫秒爲單位）。	INT	604800000	[1，...]	高
unclean.leader.election.enable	指示是否啓用不在ISR集合中的副本作爲最後的選擇，儘管這樣做可能導致數據丟失	布爾	假		高
zookeeper.connection.timeout.ms	客戶端等待與zookeeper建立連接的最長時間。如果未設置，則使用zookeeper.session.timeout.ms中的值	INT	空值		高
zookeeper.session.timeout.ms	Zookeeper會話超時	INT	6000		高
zookeeper.set.acl	將客戶端設置爲使用安全ACL	布爾	假		高
broker.id.generation.enable	在服務器上啓用自動代理ID生成。啓用時，應該檢查爲reserved.broker.max.id配置的值。	布爾	真正		中
broker.rack	經紀人的機架。這將在機架感知複製分配中用於容錯。例如：`RACK1`，`us-east-1d`	串	空值		中
connections.max.idle.ms	空閒連接超時：服務器套接字處理器線程關閉閒置超過此的連接	長	600000		中
controlled.shutdown.enable	啓用服務器的受控關閉	布爾	真正		中
controlled.shutdown.max.retries	受控關機可能由於多種原因而失敗。這決定了發生這種故障時的重試次數	INT	3		中
controlled.shutdown.retry.backoff.ms	在每次重試之前，系統需要時間從導致先前故障的狀態（控制器故障切換，副本延遲等）中恢復。此配置確定重試之前等待的時間量。	長	5000		中
controller.socket.timeout.ms	控制器到代理通道的套接字超時	INT	30000		中
default.replication.factor	自動創建主題的默認複製因子	INT	1		中
delete.records.purgatory.purge.interval.requests	刪除記錄請求purge的清除間隔（請求數）	INT	1		中
fetch.purgatory.purge.interval.requests	提取請求purge的清除間隔（請求數）	INT	1000		中
group.initial.rebalance.delay.ms	在執行第一次再平衡之前，團隊協調員將等待更多消費者加入新團隊的時間。延遲時間越長意味着重新平衡的可能性越小，但是直到處理開始的時間增加。	INT	3000		中
group.max.session.timeout.ms	註冊用戶的最大允許會話超時。較長的超時使消費者有更多的時間來處理心跳之間的消息，代價是檢測失敗的時間更長。	INT	300000		中
group.min.session.timeout.ms	註冊用戶允許的最小會話超時。更短的超時導致以更頻繁的消費者心跳爲代價的更快速的故障檢測，這可能壓倒經紀人資源。	INT	6000		中
inter.broker.listener.name	用於經紀人之間溝通的聽衆名稱。如果未設置，則偵聽器名稱由security.inter.broker.protocol定義。同時設置此和security.inter.broker.protocol屬性是錯誤的。	串	空值		中
inter.broker.protocol.version	指定將使用哪個版本的代理間協議。在所有經紀人升級到新版本之後，這通常會受到衝擊。一些有效值的示例如下：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的完整列表。	串	1.0- IV0		中
log.cleaner.backoff.ms	沒有日誌清理的時間	長	15000	[0，...]	中
log.cleaner.dedupe.buffer.size	用於所有清理程序線程的日誌重複數據消除的總內存	長	134217728		中
log.cleaner.delete.retention.ms	刪除記錄保留多久？	長	86400000		中
log.cleaner.enable	啓用日誌清理器進程在服務器上運行。應該啓用，如果使用cleanup.policy = compact任何主題，包括內部偏移主題。如果被禁用的話，這些話題將不會被壓縮，並且會不斷增長。	布爾	真正		中
log.cleaner.io.buffer.load.factor	日誌清理器重複數據刪除緩存負載因 完全重複數據刪除緩衝區的百分比可以變成。更高的值將允許一次清理更多的日誌，但會導致更多的散列衝突	雙	0.9		中
log.cleaner.io.buffer.size	用於日誌清理程序I / O緩衝區的整個內存跨越所有清理程序線程	INT	524288	[0，...]	中
log.cleaner.io.max.bytes.per.second	日誌清理器將受到限制，所以其讀取和寫入I / O的總和將平均小於此值	雙	1.7976931348623157E308		中
log.cleaner.min.cleanable.ratio	日誌中的髒日誌與總日誌的最小比率，以符合清理的條件	雙	0.5		中
log.cleaner.min.compaction.lag.ms	消息在日誌中保持未壓縮的最短時間。僅適用於正在壓縮的日誌。	長	0		中
log.cleaner.threads	用於日誌清理的後臺線程數量	INT	1	[0，...]	中
log.cleanup.policy	超出保留窗口的段的默認清理策略。以逗號分隔的有效策略列表。有效的政策是：“刪除”和“緊湊”	名單	刪除	[精簡，刪除]	中
log.index.interval.bytes	我們添加一個條目到偏移索引的時間間隔	INT	4096	[0，...]	中
log.index.size.max.bytes	偏移索引的最大大小（以字節爲單位）	INT	10485760	[4，...]	中
log.message.format.version	指定代理將用於將消息附加到日誌的消息格式版本。該值應該是有效的ApiVersion。一些例子是：0.8.2，0.9.0.0，0.10.0，查看ApiVersion獲取更多細節。通過設置特定的消息格式版本，用戶正在證明磁盤上的所有現有消息小於或等於指定的版本。不正確地設置這個值將導致使用舊版本的用戶中斷，因爲他們將接收到他們不理解的格式的消息。	串	1.0- IV0		中
log.message.timestamp.difference.max.ms	代理收到消息時的時間戳和消息中指定的時間戳之間允許的最大差異。如果log.message.timestamp.type = CreateTime，如果時間戳的差值超過此閾值，則會拒絕一條消息。如果log.message.timestamp.type = LogAppendTime，則忽略此配置。允許的最大時間戳差異不應大於log.retention.ms，以避免不必要地頻繁進行日誌滾動。	長	9223372036854775807		中
log.message.timestamp.type	定義消息中的時間戳是消息創建時間還是日誌追加時間。該值應該是“CreateTime”或“LogAppendTime”	串	CreateTime	[CreateTime，LogAppendTime]	中
log.preallocate	創建新分段時應該預先分配文件嗎？如果您在Windows上使用Kafka，則可能需要將其設置爲true。	布爾	假		中
log.retention.check.interval.ms	日誌清理程序檢查是否有日誌符合刪除的頻率（以毫秒爲單位）	長	300000	[1，...]	中
max.connections.per.ip	我們從每個IP地址允許的最大連接數	INT	2147483647	[1，...]	中
max.connections.per.ip.overrides	每個IP或主機名將覆蓋默認的最大連接數	串	“”		中
num.partitions	每個主題的默認日誌分區數量	INT	1	[1，...]	中
principal.builder.class	實現KafkaPrincipalBuilder接口的類的完全限定名，用於構建在授權過程中使用的KafkaPrincipal對象。此配置還支持以前用於通過SSL進行客戶端身份驗證的棄用的PrincipalBuilder接口。如果未定義主體構建器，則默認行爲取決於正在使用的安全協議。對於SSL身份驗證，如果提供了一個主體名稱，則主體名稱將是客戶端證書的可分辨名稱; 否則，如果客戶端身份驗證不是必需的，主體名稱將是匿名的。對於SASL身份驗證，將使用sasl.kerberos.principal.to.local.rulesif GSSAPI正在使用中定義的規則以及其他機制的SASL身份驗證ID 導出主體。對於PLAINTEXT，校長將是匿名的。	類	空值		中
producer.purgatory.purge.interval.requests	生產者請求煉獄的清除間隔（請求數）	INT	1000		中
queued.max.request.bytes	在不再讀取請求之前，允許排隊的字節數	長	-1		中
replica.fetch.backoff.ms	提取分區錯誤時發生的睡眠時間。	INT	1000	[0，...]	中
replica.fetch.max.bytes	嘗試爲每個分區獲取的消息的字節數。這不是絕對最大值，如果第一個非空分區中的第一個記錄批次大於此值，那麼記錄批次仍將被返回以確保可以進行。代理接受的最大記錄批量大小通過message.max.bytes（代理配置）或max.message.bytes（主題配置）進行定義。	INT	1048576	[0，...]	中
replica.fetch.response.max.bytes	整個提取響應的預期最大字節數。記錄是批量提取的，如果第一個記錄批次在第一個非空分區的分區大於這個值，那麼記錄批次仍然會被返回，以確保可以進行。因此，這不是一個絕對的最大值。代理接受的最大記錄批量大小通過message.max.bytes（代理配置）或max.message.bytes（主題配置）進行定義。	INT	10485760	[0，...]	中
reserved.broker.max.id	可以用於broker.id的最大數量	INT	1000	[0，...]	中
sasl.enabled.mechanisms	卡夫卡服務器中啓用的SASL機制列表。該列表可能包含安全提供程序可用的任何機制。只有GSSAPI默認啓用。	名單	GSSAPI		中
sasl.kerberos.kinit.cmd	Kerberos kinit命令路徑。	串	在/ usr / bin中/ kinit命令		中
sasl.kerberos.min.time.before.relogin	登錄線程在刷新嘗試之間的休眠時間	長	60000		中
sasl.kerberos.principal.to.local.rules	從主體名稱到簡稱（通常是操作系統用戶名）的映射規則列表。規則按順序進行評估，並使用匹配主體名稱的第一條規則將其映射到短名稱。列表中後面的任何規則都會被忽略。默認情況下，{username} / {hostname} @ {REALM}形式的主體名稱映射到{username}。有關格式的更多細節，請參閱安全授權和acls。請注意，如果principal.builder.class配置提供了KafkaPrincipalBuilder的擴展，則忽略此配置。	名單	默認		中
sasl.kerberos.service.name	Kafka運行的Kerberos主體名稱。這可以在Kafka的JAAS配置或Kafka的配置中定義。	串	空值		中
sasl.kerberos.ticket.renew.jitter	隨機抖動增加到更新時間的百分比。	雙	0.05		中
sasl.kerberos.ticket.renew.window.factor	登錄線程將休眠，直到已經到達從上次刷新到票證到期的指定窗口時間因子，屆時它將嘗試更新票證。	雙	0.8		中
sasl.mechanism.inter.broker.protocol	用於經紀人間通信的SASL機制。默認是GSSAPI。	串	GSSAPI		中
security.inter.broker.protocol	用於在代理之間進行通信的安全協議。有效值爲：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。同時設置此屬性和inter.broker.listener.name屬性是錯誤的。	串	純文本		中
ssl.cipher.suites	密碼套件列表。這是用於使用TLS或SSL網絡協議來協商網絡連接的安全設置的認證，加密，MAC和密鑰交換算法的命名組合。默認情況下，所有可用的密碼套件都受支持。	名單	空值		中
ssl.client.auth	配置kafka代理來請求客戶端認證。以下設置是常見的： ssl.client.auth=required 如果設置爲需要客戶端身份驗證是必需的 ssl.client.auth=requested這意味着客戶端認證是可選的。不像請求，如果這個選項被設置，客戶端可以選擇不提供關於它自己的認證信息 ssl.client.auth=none 這意味着不需要客戶端身份驗證。	串	沒有	[必填，請求，無]	中
ssl.enabled.protocols	啓用了SSL連接的協議列表。	名單	TLSv1.2工作，TLSv1.1，使用TLSv1		中
ssl.key.password	密鑰存儲文件中的私鑰密碼。這對於客戶端是可選的。	密碼	空值		中
ssl.keymanager.algorithm	密鑰管理器工廠用於SSL連接的算法。信息範範範讀預辛辛	串	SunX509		中
ssl.keystore.location	密鑰存儲文件的位置。這對客戶端是可選的，可以用於客戶端的雙向認證。	串	空值		中
ssl.keystore.password	密鑰存儲文件的商店密碼。這對客戶端是可選的，只有在配置了ssl.keystore.location時才需要。	密碼	空值		中
ssl.keystore.type	密鑰存儲文件的文件格式。這對於客戶端是可選的。	串	JKS		中
ssl.protocol	用於生成SSLContext的SSL協議。默認設置是TLS，在大多數情況下這是很好的。最近的JVM中允許的值是TLS，TLSv1.1和TLSv1.2。較舊的JVM中可能支持SSL，SSLv2和SSLv3，但由於已知的安全漏洞，它們的使用不受歡迎。	串	TLS		中
ssl.provider	用於SSL連接的安全提供程序的名稱。默認值是JVM的默認安全提供程序。	串	空值		中
ssl.trustmanager.algorithm	信任管理器工廠用於SSL連接的算法。默認值是爲Java虛擬機配置的信任管理器工廠算法。	串	PKIX		中
ssl.truststore.location	信任存儲文件的位置。	串	空值		中
ssl.truststore.password	信任存儲文件的密碼。如果密碼未設置，信任庫的訪問仍然可用，但完整性檢查被禁用。	密碼	空值		中
ssl.truststore.type	信任存儲文件的文件格式。	串	JKS		中
alter.config.policy.class.name	應該用於驗證的alter configs策略類。該類應該實現org.apache.kafka.server.policy.AlterConfigPolicy接口。	類	空值		低
authorizer.class.name	應該用於授權的授權者類	串	“”		低
create.topic.policy.class.name	應該用於驗證的創建主題策略類。該類應該實現org.apache.kafka.server.policy.CreateTopicPolicy接口。	類	空值		低
listener.security.protocol.map	偵聽器名稱和安全協議之間的映射。必須定義相同的安全協議才能在多個端口或IP中使用。例如，即使兩者都需要SSL，內部和外部流量也可以分開。具體來說，用戶可以定義名字爲INTERNAL和EXTERNAL的監聽器，這個屬性爲：`INTERNAL：SSL，EXTERNAL：SSL`。如圖所示，鍵和值由冒號分隔，映射條目以逗號分隔。每個偵聽器名稱只能在地圖中出現一次。通過向配置名稱添加標準化前綴（偵聽器名稱小寫），可以爲每個偵聽器配置不同的安全性（SSL和SASL）設置。例如，要爲INTERNAL偵聽器設置不同的密鑰庫，將會設置名稱爲“listener.name.internal.ssl.keystore.location”的配置。	串	PLAINTEXT：明文SSL：SSL，SASL_PLAINTEXT：SASL_PLAINTEXT，SASL_SSL：SASL_SSL		低
metric.reporters	用作度量記錄的類的列表。實現org.apache.kafka.common.metrics.MetricsReporter接口允許插入將被通知新度量創建的類。JmxReporter始終包含在註冊JMX統計信息中。	名單	“”		低
metrics.num.samples	維持用於計算度量的樣本數量。	INT	2	[1，...]	低
metrics.recording.level	指標的最高記錄級別。	串	信息		低
metrics.sample.window.ms	計算指標樣本的時間窗口。	長	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	使用服務器證書驗證服務器主機名的端點識別算法。	串	空值		低
ssl.secure.random.implementation	用於SSL加密操作的SecureRandom PRNG實現。	串	空值		低
transaction.abort.timed.out.transaction.cleanup.interval.ms	回滾已超時的事務的時間間隔	INT	60000	[1，...]	低
transaction.remove.expired.transaction.cleanup.interval.ms	因刪除已到期的交易的時間間隔transactional.id.expiration.ms passing	INT	3600000	[1，...]	低
zookeeper.sync.time.ms	ZK追隨者可以在ZK領導者後面走多遠	INT	2000		低

有關代理配置的更多細節可以在scala類中找到kafka.server.KafkaConfig。

3.2主題級別的配置

與主題相關的配置既包含服務器默認值，也包含可選的每個主題覆蓋值。如果沒有給出每個主題的配置，則使用服務器默認值。可以通過給定一個或多個--config選項來在主題創建時設置覆蓋。本示例使用自定義的最大消息大小和沖刷率創建一個名爲my-topic的主題：

1 2	> bin/kafka-topics.sh --zookeeper localhost:2181 --create --topic my-topic --partitions 1     --replication-factor 1 --config max.message.bytes=64000 --config flush.messages=1

也可以使用alter configs命令稍後更改或設置覆蓋。本示例更新my-topic的最大郵件大小：

1 2	> bin/kafka-configs.sh --zookeeper localhost:2181 --entity-type topics --entity-name my-topic     --alter --add-config max.message.bytes=128000

要檢查在主題上設置的覆蓋，您可以執行

1	> bin/kafka-configs.sh --zookeeper localhost:2181 --entity-type topics --entity-name my-topic --describe

要刪除覆蓋，你可以做

1	> bin/kafka-configs.sh --zookeeper localhost:2181  --entity-type topics --entity-name my-topic --alter --delete-config max.message.bytes

以下是主題級配置。該屬性的服務器默認配置在“服務器默認屬性”標題下給出。給定的服務器默認配置值只適用於主題，如果它沒有明確的主題配置覆蓋。

名稱	描述	類型	默認	有效值	服務器默認屬性	重要性
cleanup.policy	一個字符串，可以是“delete”或“compact”。此字符串指定在舊日誌段上使用的保留策略。默認策略（“刪除”）將在達到保留時間或大小限制時丟棄舊段。“緊湊”設置將啓用該主題的日誌壓縮。	名單	刪除	[精簡，刪除]	log.cleanup.policy	中
compression.type	指定給定主題的最終壓縮類型。這個配置接受標準的壓縮編解碼器（'gzip'，'snappy'，lz4）。它另外接受相當於不壓縮的“未壓縮” 和“製作者”，這意味着保留製作者設置的原始壓縮編解碼器。	串	製片人	[uncompressed，snappy，lz4，gzip，製作人]	compression.type	中
delete.retention.ms	保留時間刪除邏輯壓縮主題的邏輯刪除標記。這個設置也給消費者在從偏移量0開始時必須完成讀取的時間以確保他們獲得最後階段的有效快照（否則刪除在他們完成掃描之前可以收集的墓碑）。	長	86400000	[0，...]	log.cleaner.delete.retention.ms	中
file.delete.delay.ms	The time to wait before deleting a file from the filesystem	long	60000	[0,...]	log.segment.delete.delay.ms	medium
flush.messages	This setting allows specifying an interval at which we will force an fsync of data written to the log. For example if this was set to 1 we would fsync after every message; if it were 5 we would fsync after every five messages. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient. This setting can be overridden on a per-topic basis (see the per-topic configuration section).	long	9223372036854775807	[0,...]	log.flush.interval.messages	medium
flush.ms	This setting allows specifying a time interval at which we will force an fsync of data written to the log. For example if this was set to 1000 we would fsync after 1000 ms had passed. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.	long	9223372036854775807	[0,...]	log.flush.interval.ms	medium
follower.replication.throttled.replicas	A list of replicas for which log replication should be throttled on the follower side. The list should describe a set of replicas in the form [PartitionId]:[BrokerId],[PartitionId]:[BrokerId]:... or alternatively the wildcard '*' can be used to throttle all replicas for this topic.	list	""	[partitionId],[brokerId]:[partitionId],[brokerId]:...	follower.replication.throttled.replicas	medium
index.interval.bytes	This setting controls how frequently Kafka adds an index entry to it's offset index. The default setting ensures that we index a message roughly every 4096 bytes. More indexing allows reads to jump closer to the exact position in the log but makes the index larger. You probably don't need to change this.	int	4096	[0,...]	log.index.interval.bytes	medium
leader.replication.throttled.replicas	A list of replicas for which log replication should be throttled on the leader side. The list should describe a set of replicas in the form [PartitionId]:[BrokerId],[PartitionId]:[BrokerId]:... or alternatively the wildcard '*' can be used to throttle all replicas for this topic.	list	""	[partitionId],[brokerId]:[partitionId],[brokerId]:...	leader.replication.throttled.replicas	medium
max.message.bytes	The largest record batch size allowed by Kafka. If this is increased and there are consumers older than 0.10.2, the consumers' fetch size must also be increased so that the they can fetch record batches this large. In the latest message format version, records are always grouped into batches for efficiency. In previous message format versions, uncompressed records are not grouped into batches and this limit only applies to a single record in that case.	int	1000012	[0,...]	message.max.bytes	medium
message.format.version	Specify the message format version the broker will use to append messages to the logs. The value should be a valid ApiVersion. Some examples are: 0.8.2, 0.9.0.0, 0.10.0, check ApiVersion for more details. By setting a particular message format version, the user is certifying that all the existing messages on disk are smaller or equal than the specified version. Setting this value incorrectly will cause consumers with older versions to break as they will receive messages with a format that they don't understand.	string	1.0-IV0		log.message.format.version	medium
message.timestamp.difference.max.ms	The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. This configuration is ignored if message.timestamp.type=LogAppendTime.	long	9223372036854775807	[0,...]	log.message.timestamp.difference.max.ms	medium
message.timestamp.type	Define whether the timestamp in the message is message create time or log append time. The value should be either `CreateTime` or `LogAppendTime`	string	CreateTime		log.message.timestamp.type	medium
min.cleanable.dirty.ratio	This configuration controls how frequently the log compactor will attempt to clean the log (assuming log compaction is enabled). By default we will avoid cleaning a log where more than 50% of the log has been compacted. This ratio bounds the maximum space wasted in the log by duplicates (at 50% at most 50% of the log could be duplicates). A higher ratio will mean fewer, more efficient cleanings but will mean more wasted space in the log.	double	0.5	[0,...,1]	log.cleaner.min.cleanable.ratio	medium
min.compaction.lag.ms	The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.	long	0	[0,...]	log.cleaner.min.compaction.lag.ms	medium
min.insync.replicas	When a producer sets acks to "all" (or "-1"), this configuration specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. If this minimum cannot be met, then the producer will raise an exception (either NotEnoughReplicas or NotEnoughReplicasAfterAppend). When used together, min.insync.replicas and acks allow you to enforce greater durability guarantees. A typical scenario would be to create a topic with a replication factor of 3, set min.insync.replicas to 2, and produce with acks of "all". This will ensure that the producer raises an exception if a majority of replicas do not receive a write.	int	1	[1,...]	min.insync.replicas	medium
preallocate	True if we should preallocate the file on disk when creating a new log segment.	boolean	false		log.preallocate	medium
retention.bytes	如果我們使用“刪除”保留策略，則此配置將控制分區（由日誌段組成）的最大大小，在我們放棄舊的日誌段釋放空間之前，該分區可以增長到最大。默認情況下，沒有大小限制只有一個時間限制。由於此限制是在分區級別執行的，請將其乘以分區數來計算主題保留（以字節爲單位）。	長	-1		log.retention.bytes	中
retention.ms	如果我們使用“刪除”保留策略，則此配置將控制保留日誌的最長時間，然後放棄舊的日誌段以釋放空間。這代表了消費者必須快速閱讀數據的SLA。	長	604800000		log.retention.ms	中
segment.bytes	此配置控制日誌的段文件大小。保留和清理總是一次完成一個文件，因此較大的段大小意味着較少的文件，但對保留的控制較少。	INT	1073741824	[14，...]	log.segment.bytes	中
segment.index.bytes	此配置控制將偏移量映射到文件位置的索引大小。我們預先分配這個索引文件並且在日誌滾動之後才縮小它。您通常不需要更改此設置。	INT	10485760	[0，...]	log.index.size.max.bytes	中
segment.jitter.ms	從預定的分段滾動時間中減去最大的隨機抖動，以避免雷鳴般的分段滾動	長	0	[0，...]	log.roll.jitter.ms	中
segment.ms	此配置控制Kafka即使段文件未滿也會強制日誌滾動的時間段，以確保保留可以刪除或壓縮舊數據。	長	604800000	[0，...]	log.roll.ms	中
unclean.leader.election.enable	指示是否啓用不在ISR集合中的副本作爲最後的選擇，即使這樣做可能導致數據丟失。	布爾	假		unclean.leader.election.enable	中

3.3生產者配置

以下是Java生產者的配置：

名稱	描述	類型	默認	有效值	重要性
bootstrap.servers	用於建立到Kafka集羣的初始連接的主機/端口對列表。客戶端將使用所有服務器，而不管在這裏指定哪些服務器用於引導 - 該列表僅影響用於發現全套服務器的初始主機。這個清單應該在表格中host1:port1,host2:port2,...。由於這些服務器僅用於初始連接以發現完整的羣集成員資格（可能會動態更改），因此此列表不必包含整套服務器（但可能需要多個服務器，以防服務器關閉） 。	名單			高
key.serializer	用於實現org.apache.kafka.common.serialization.Serializer接口的密鑰的串行器類。	類			高
value.serializer	實現org.apache.kafka.common.serialization.Serializer接口的值的串行器類。	類			高
的ack	在考慮完成請求之前，生產者要求領導者收到的確認的數量。這將控制發送的記錄的持久性。以下設置是允許的： acks=0如果設置爲零，則生產者不會等待來自服務器的任何確認。該記錄將被立即添加到套接字緩衝區並被視爲發送。在這種情況下，retries不能保證服務器已經收到記錄，配置不會生效（因爲客戶端通常不會知道有什麼故障）。爲每個記錄返回的偏移量始終設置爲-1。 acks=1這將意味着領導者會將記錄寫入本地日誌，但是會在沒有等待所有追隨者的完全確認的情況下作出響應。在這種情況下，如果領導者在承認記錄之後但在追隨者複製之前立即失敗，那麼記錄將會丟失。 acks=all這意味着領導者將等待全套的in-sync副本確認記錄。這保證只要至少有一個同步副本保持活動狀態，記錄就不會丟失。這是最有力的保證。這相當於acks = -1設置。	串	1	[all，-1，0，1]	高
buffer.memory	生產者可用於緩衝等待發送到服務器的記錄的總字節數。如果記錄的發送速度比發送給服務器的速度快，那麼生產者將會阻塞，max.block.ms之後會拋出異常。 這個設置應該大致對應於生產者將使用的總內存，但不是硬性限制，因爲不是所有生產者使用的內存都用於緩衝。一些額外的內存將用於壓縮（如果啓用了壓縮）以及維護正在進行的請求。	長	33554432	[0，...]	高
compression.type	生產者生成的所有數據的壓縮類型。默認值是none（即不壓縮）。有效值是none，gzip，snappy，或lz4。壓縮是完整的批量數據，所以配料的效率也會影響壓縮比（更多的配料意味着更好的壓縮）。	串	沒有		高
重試	設置一個大於零的值將導致客戶端重新發送任何發送失敗的記錄，並有可能出現瞬時錯誤。請注意，此重試與客戶端收到錯誤時重新發送記錄沒有區別。允許未設置max.in.flight.requests.per.connection爲1的重試將潛在地更改記錄的順序，因爲如果將兩個批處理髮送到單個分區，並且第一個失敗並重試但第二個成功，則第二個批處理中的記錄可能會首先出現。	INT	0	[0，...，2147483647]	高
ssl.key.password	密鑰存儲文件中的私鑰密碼。這對於客戶端是可選的。	密碼	空值		高
ssl.keystore.location	密鑰存儲文件的位置。這對客戶端是可選的，可以用於客戶端的雙向認證。	串	空值		高
ssl.keystore.password	密鑰存儲文件的商店密碼。這對客戶端是可選的，只有在配置了ssl.keystore.location時才需要。	密碼	空值		高
ssl.truststore.location	信任存儲文件的位置。	串	空值		高
ssl.truststore.password	信任存儲文件的密碼。如果密碼未設置，信任庫的訪問仍然可用，但完整性檢查被禁用。	密碼	空值		高
batch.size	只要有多個記錄被髮送到同一個分區，生產者就會嘗試將記錄一起分成更少的請求。這有助於客戶端和服務器的性能。該配置以字節爲單位控制默認的批量大小。 不會嘗試批量大於此大小的記錄。 發送給經紀人的請求將包含多個批次，每個分區有一個可用於發送數據的分區。 一個小批量大小將使批次不太常見，並可能降低吞吐量（批量大小零將完全禁用批次）。一個非常大的批量大小可能會更浪費一點的內存，因爲我們總是會分配一個指定批量的緩衝區，以預期額外的記錄。	INT	16384	[0，...]	中
client.id	發出請求時傳遞給服務器的id字符串。這樣做的目的是通過允許在服務器端請求日誌中包含一個邏輯應用程序名稱來跟蹤請求的來源，而不僅僅是ip / port。	串	“”		中
connections.max.idle.ms	在此配置指定的毫秒數之後關閉空閒連接。	長	540000		中
linger.ms	生產者將在請求傳輸之間到達的任何記錄分組成單個批量請求。通常情況下，只有在記錄到達速度快於發出時纔會發生。但是，在某些情況下，即使在中等負載下，客戶端也可能希望減少請求的數量。這個設置通過添加少量的人工延遲來實現這一點，即不是立即發出一個記錄，而是等待達到給定延遲的記錄，以允許發送其他記錄，以便發送可以一起批量發送。這可以被認爲與TCP中的Nagle算法類似。這個設置給出了配料延遲的上限：一旦得到batch.size值得記錄的分區將立即發送，不管這個設置如何，但是如果我們有少於這個分區積累的這麼多的字節，我們將在指定的時間“滯留”，等待更多的記錄出現。這個設置默認爲0（即沒有延遲）。linger.ms=5例如，設置可以減少發送的請求數量，但是會對在無效負載中發送的記錄添加高達5毫秒的延遲。	長	0	[0，...]	中
max.block.ms	該配置控制了多長時間，KafkaProducer.send()並且KafkaProducer.partitionsFor()會阻塞。這些方法可能因爲緩衝區已滿或元數據不可用而被阻止。用戶提供的序列化程序或分區程序中的阻塞將不計入此超時。	長	60000	[0，...]	中
max.request.size	請求的最大大小（以字節爲單位）。此設置將限制生產者在單個請求中發送的記錄批次的數量，以避免發送大量請求。這也是最大記錄批量大小的有效上限。請注意，服務器在記錄批量大小上有自己的上限，這可能與此不同。	INT	1048576	[0，...]	中
partitioner.class	實現org.apache.kafka.clients.producer.Partitioner接口的分區器類。	類	org.apache.kafka.clients.producer.internals.DefaultPartitioner		中
receive.buffer.bytes	讀取數據時使用的TCP接收緩衝區（SO_RCVBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	32768	[-1，...]	中
request.timeout.ms	配置控制客戶端等待請求響應的最長時間。如果在超時過去之前未收到響應，則客戶端將在必要時重新發送請求，或者如果重試耗盡，則請求失敗。這應該比replica.lag.time.max.ms（代理配置）大，以減少由於不必要的生產者重試造成的消息重複的可能性。	INT	30000	[0，...]	中
sasl.jaas.config	用於JAAS配置文件使用的格式的SASL連接的JAAS登錄上下文參數。這裏描述JAAS配置文件格式。值的格式是：'（=）*;”	密碼	空值		中
sasl.kerberos.service.name	Kafka運行的Kerberos主體名稱。這可以在Kafka的JAAS配置或Kafka的配置中定義。	串	空值		中
sasl.mechanism	用於客戶端連接的SASL機制。這可能是安全提供者可用的任何機制。GSSAPI是默認的機制。	串	GSSAPI		中
security.protocol	用於與經紀人溝通的協議。有效值爲：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。	串	純文本		中
send.buffer.bytes	發送數據時要使用的TCP發送緩衝區（SO_SNDBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	131072	[-1，...]	中
ssl.enabled.protocols	啓用了SSL連接的協議列表。	名單	TLSv1.2工作，TLSv1.1，使用TLSv1		中
ssl.keystore.type	密鑰存儲文件的文件格式。這對於客戶端是可選的。	串	JKS		中
ssl.protocol	用於生成SSLContext的SSL協議。默認設置是TLS，在大多數情況下這是很好的。最近的JVM中允許的值是TLS，TLSv1.1和TLSv1.2。較舊的JVM中可能支持SSL，SSLv2和SSLv3，但由於已知的安全漏洞，它們的使用不受歡迎。	串	TLS		中
ssl.provider	用於SSL連接的安全提供程序的名稱。默認值是JVM的默認安全提供程序。	串	空值		中
ssl.truststore.type	信任存儲文件的文件格式。	串	JKS		中
enable.idempotence	當設置爲“真”時，製作者將確保每個消息的正好一個副本被寫入流中。如果“錯誤”，生產者由於經紀人失敗等而重試，可以在流中重寫重試消息。請注意，啓用冪等性需要max.in.flight.requests.per.connection小於或等於5，retries大於0，且ack必須是“全部”。如果這些值不是由用戶明確設定的，則將選擇合適的值。如果設置了不兼容的值，則會拋出ConfigException。	布爾	假		低
interceptor.classes	用作攔截器的類的列表。通過實現org.apache.kafka.clients.producer.ProducerInterceptor接口，您可以在生產者發佈到Kafka集羣之前攔截（甚至可能是突變）生產者接收到的記錄。默認情況下，沒有攔截器。	名單	空值		低
max.in.flight.requests.per.connection	在阻止之前，客戶端將在單個連接上發送的未確認請求的最大數量。請注意，如果此設置設置爲大於1，並且發送失敗，則由於重試（即，如果重試已啓用），可能會重新排序消息。	INT	五	[1，...]	低
metadata.max.age.ms	以毫秒爲單位的時間段之後，即使我們沒有看到任何分區領導變化，以主動發現任何新的代理或分區，我們強制更新元數據。	長	300000	[0，...]	低
metric.reporters	用作度量記錄的類的列表。實現org.apache.kafka.common.metrics.MetricsReporter接口允許插入將被通知新度量創建的類。JmxReporter始終包含在註冊JMX統計信息中。	名單	“”		低
metrics.num.samples	維持用於計算度量的樣本數量。	INT	2	[1，...]	低
metrics.recording.level	指標的最高記錄級別。	串	信息	[信息，調試]	低
metrics.sample.window.ms	計算指標樣本的時間窗口。	長	30000	[0，...]	低
reconnect.backoff.max.ms	重新連接到重複連接失敗的代理程序時要等待的最長時間（以毫秒爲單位）。如果提供的話，每個主機的退避將以指數方式增加，對於每個連續的連接失敗，達到這個最大值。計算後退增加後，增加20％隨機抖動以避免連接風暴。	長	1000	[0，...]	低
reconnect.backoff.ms	嘗試重新連接到給定主機之前等待的基本時間。這避免了在一個緊密的循環中重複連接到主機。該退避適用於客戶端向經紀人的所有連接嘗試。	長	50	[0，...]	低
retry.backoff.ms	嘗試重試對給定主題分區的失敗請求之前等待的時間量。這樣可以避免在某些故障情況下重複發送請求。	長	100	[0，...]	低
sasl.kerberos.kinit.cmd	Kerberos kinit命令路徑。	串	在/ usr / bin中/ kinit命令		低
sasl.kerberos.min.time.before.relogin	登錄線程在刷新嘗試之間的休眠時間	長	60000		低
sasl.kerberos.ticket.renew.jitter	隨機抖動增加到更新時間的百分比。	雙	0.05		低
sasl.kerberos.ticket.renew.window.factor	登錄線程將休眠，直到已經到達從上次刷新到票證到期的指定窗口時間因子，屆時它將嘗試更新票證。	雙	0.8		低
ssl.cipher.suites	密碼套件列表。這是用於使用TLS或SSL網絡協議來協商網絡連接的安全設置的認證，加密，MAC和密鑰交換算法的命名組合。默認情況下，所有可用的密碼套件都受支持。	名單	空值		低
ssl.endpoint.identification.algorithm	使用服務器證書驗證服務器主機名的端點識別算法。	串	空值		低
ssl.keymanager.algorithm	密鑰管理器工廠用於SSL連接的算法。信息範範範讀預辛辛	串	SunX509		低
ssl.secure.random.implementation	用於SSL加密操作的SecureRandom PRNG實現。	串	空值		低
ssl.trustmanager.algorithm	信任管理器工廠用於SSL連接的算法。默認值是爲Java虛擬機配置的信任管理器工廠算法。	串	PKIX		低
transaction.timeout.ms	主動中止正在進行的事務之前，事務協調器將等待來自生產者的事務狀態更新的最長時間（以毫秒爲單位）。如果此值大於代理中的max.transaction.timeout.ms設置，則請求將失敗並出現InvalidTransactionTimeout錯誤。	INT	60000		低
transactional.id	用於事務交付的TransactionalId。這使跨越多個生產者會話的可靠性語義成爲可能，因爲它允許客戶保證在開始任何新的事務之前使用相同的TransactionalId的事務已經完成。如果沒有提供TransactionalId，則生產者被限制爲冪等遞送。請注意，如果配置了TransactionalId，則必須啓用enable.idempotence。缺省值爲空，這意味着交易無法使用。	串	空值	非空字符串	低

對於那些對舊版Scala生產者配置感興趣的人，可以在 這裏找到信息。

3.4消費者配置

在0.9.0.0中，我們引入了新的Java消費者作爲舊的基於Scala的簡單和高級消費者的替代品。下面介紹新老用戶的配置。

3.4.1新的消費者配置

以下是新消費者的配置：

名稱	描述	類型	默認	有效值	重要性
bootstrap.servers	用於建立到Kafka集羣的初始連接的主機/端口對列表。客戶端將使用所有服務器，而不管在這裏指定哪些服務器用於引導 - 該列表僅影響用於發現全套服務器的初始主機。這個清單應該在表格中host1:port1,host2:port2,...。由於這些服務器僅用於初始連接以發現完整的羣集成員資格（可能會動態更改），因此此列表不必包含整套服務器（但可能需要多個服務器，以防服務器關閉） 。	名單			高
key.deserializer	實現org.apache.kafka.common.serialization.Deserializer接口的密鑰的反序列化器類。	類			高
value.deserializer	用於實現org.apache.kafka.common.serialization.Deserializer接口的值的反序列化器類。	類			高
fetch.min.bytes	服務器爲獲取請求返回的最小數據量。如果沒有足夠的數據可用，請求將等待那麼多的數據在應答請求之前積累。1字節的默認設置意味着只要有一個字節的數據可用，或者提取請求超時等待數據到達，就會立即應答提取請求。將其設置爲大於1的值將導致服務器等待大量的數據累積，這可以稍稍提高服務器吞吐量，但需要花費一些額外的延遲時間。	INT	1	[0，...]	高
group.id	標識此消費者所屬的消費者羣組的唯一字符串。如果消費者通過使用subscribe(topic)基於卡夫卡的偏移量管理策略來使用組管理功能，則此屬性是必需的。	串	“”		高
heartbeat.interval.ms	在使用Kafka集團管理設施時，心跳與消費者協調員之間的預期時間。心跳是用來確保消費者的會議保持活躍，並促進新消費者加入或離開組時重新平衡。該值必須設置爲低於session.timeout.ms，但通常應設置爲不高於該值的1/3。它可以調整得更低，以控制正常再平衡的預期時間。	INT	3000		高
max.partition.fetch.bytes	服務器將返回每個分區的最大數據量。記錄由用戶批量提取。如果提取的第一個非空分區中的第一個記錄批次大於此限制，則該批次仍將被返回，以確保用戶可以取得進展。代理接受的最大記錄批量大小通過message.max.bytes（代理配置）或max.message.bytes（主題配置）進行定義。請參閱fetch.max.bytes來限制消費者請求大小。	INT	1048576	[0，...]	高
session.timeout.ms	使用Kafka的組管理設施時，用於檢測消費者失敗的超時。消費者定期發送心跳來向經紀人表明其活躍度。如果代理在該會話超時到期之前沒有收到心跳，那麼代理將從該組中刪除該消費者並啓動重新平衡。請注意，該值必須在允許的範圍內，正如代理配置中的group.min.session.timeout.msand所配置的那樣group.max.session.timeout.ms。	INT	10000		高
ssl.key.password	密鑰存儲文件中的私鑰密碼。這對於客戶端是可選的。	密碼	空值		高
ssl.keystore.location	密鑰存儲文件的位置。這對客戶端是可選的，可以用於客戶端的雙向認證。	串	空值		高
ssl.keystore.password	密鑰存儲文件的商店密碼。這對客戶端是可選的，只有在配置了ssl.keystore.location時才需要。	密碼	空值		高
ssl.truststore.location	信任存儲文件的位置。	串	空值		高
ssl.truststore.password	信任存儲文件的密碼。如果密碼未設置，信任庫的訪問仍然可用，但完整性檢查被禁用。	密碼	空值		高
auto.offset.reset	在Kafka中沒有初始偏移時，或者當前的偏移在服務器上不存在（例如，因爲該數據已被刪除），該怎麼辦： 最早：自動將偏移量重置爲最早的偏移量 最新：自動將偏移量重置爲最新的偏移量 none：如果消費者組沒有找到先前的偏移量，則向消費者拋出異常 其他任何事情：向消費者拋出異常。	串	最新	[最新，最早，沒有]	中
connections.max.idle.ms	Close idle connections after the number of milliseconds specified by this config.	long	540000		medium
enable.auto.commit	If true the consumer's offset will be periodically committed in the background.	boolean	true		medium
exclude.internal.topics	Whether records from internal topics (such as offsets) should be exposed to the consumer. If set to true the only way to receive records from an internal topic is subscribing to it.	boolean	true		medium
fetch.max.bytes	服務器爲獲取請求而返回的最大數據量。記錄由消費者批量提取，如果第一個非空分區中的第一個記錄批次大於此值，則記錄批次仍將被返回以確保消費者可以進行。因此，這不是一個絕對的最大值。代理接受的最大記錄批量大小通過message.max.bytes（代理配置）或max.message.bytes（主題配置）進行定義。請注意，消費者並行執行多個提取。	INT	52428800	[0，...]	中
isolation.level	Controls how to read messages written transactionally. If set to read_committed, consumer.poll() will only return transactional messages which have been committed. If set to read_uncommitted' (the default), consumer.poll() will return all messages, even transactional messages which have been aborted. Non-transactional messages will be returned unconditionally in either mode. 消息將始終以偏移順序返回。因此，在read_committed模式下，consumer.poll（）將只返回到最後一個穩定偏移量（LSO）的消息，這比第一個打開事務的偏移量小。特別是在屬於正在進行的交易的消息之後出現的任何消息將被扣留，直到相關的交易完成。因此，read_committed消費者在飛行交易中將無法讀取高水印。 而且，當進入時 read_committed the seekToEnd method will return the LSO	串	READ_UNCOMMITTED	[read_committed，read_uncommitted]	中
max.poll.interval.ms	在使用消費者組管理時，調用poll（）之間的最大延遲。這提出了消費者在獲取更多記錄之前可以閒置的時間量的上界。如果在此超時到期之前未調用poll（），則認爲使用者失敗，並且組將重新平衡以將分區重新分配給其他成員。	INT	300000	[1，...]	中
max.poll.records	在一次調用poll（）中返回的最大記錄數。	INT	500	[1，...]	中
partition.assignment.strategy	當使用組管理時，客戶端將用於在客戶實例之間分配分區所有權的分區分配策略的類名	名單	類org.apache.kafka.clients.consumer.RangeAssignor		中
receive.buffer.bytes	讀取數據時使用的TCP接收緩衝區（SO_RCVBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	65536	[-1，...]	中
request.timeout.ms	配置控制客戶端等待請求響應的最長時間。如果在超時過去之前未收到響應，則客戶端將在必要時重新發送請求，或者如果重試耗盡，則請求失敗。	INT	305000	[0，...]	中
sasl.jaas.config	用於JAAS配置文件使用的格式的SASL連接的JAAS登錄上下文參數。這裏描述JAAS配置文件格式。值的格式是：'（=）*;”	密碼	空值		中
sasl.kerberos.service.name	Kafka運行的Kerberos主體名稱。這可以在Kafka的JAAS配置或Kafka的配置中定義。	串	空值		中
sasl.mechanism	用於客戶端連接的SASL機制。這可能是安全提供者可用的任何機制。GSSAPI是默認的機制。	串	GSSAPI		中
security.protocol	用於與經紀人溝通的協議。有效值爲：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。	串	純文本		中
send.buffer.bytes	發送數據時要使用的TCP發送緩衝區（SO_SNDBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	131072	[-1，...]	中
ssl.enabled.protocols	啓用了SSL連接的協議列表。	名單	TLSv1.2工作，TLSv1.1，使用TLSv1		中
ssl.keystore.type	密鑰存儲文件的文件格式。這對於客戶端是可選的。	串	JKS		中
ssl.protocol	用於生成SSLContext的SSL協議。默認設置是TLS，在大多數情況下這是很好的。最近的JVM中允許的值是TLS，TLSv1.1和TLSv1.2。較舊的JVM中可能支持SSL，SSLv2和SSLv3，但由於已知的安全漏洞，它們的使用不受歡迎。	串	TLS		中
ssl.provider	用於SSL連接的安全提供程序的名稱。默認值是JVM的默認安全提供程序。	串	空值		中
ssl.truststore.type	信任存儲文件的文件格式。	串	JKS		中
auto.commit.interval.ms	消費者偏移的頻率以毫秒爲單位自動提交給Kafka，如果enable.auto.commit設置爲true。	INT	5000	[0，...]	低
check.crcs	自動檢查消耗的記錄的CRC32。這可以確保沒有在線或磁盤損壞的消息發生。這個檢查會增加一些開銷，所以在尋求極高性能的情況下可能會被禁用。	布爾	真正		低
client.id	發出請求時傳遞給服務器的id字符串。這樣做的目的是通過允許在服務器端請求日誌中包含一個邏輯應用程序名稱來跟蹤請求的來源，而不僅僅是ip / port。	串	“”		低
fetch.max.wait.ms	如果沒有足夠的數據立即滿足fetch.min.bytes給定的要求，服務器在應答提取請求之前將阻塞的最大時間量。	INT	500	[0，...]	低
interceptor.classes	用作攔截器的類的列表。實現org.apache.kafka.clients.consumer.ConsumerInterceptor接口允許你攔截（也可能是變異）消費者收到的記錄。默認情況下，沒有攔截器。	名單	空值		低
metadata.max.age.ms	以毫秒爲單位的時間段之後，即使我們沒有看到任何分區領導變化，以主動發現任何新的代理或分區，我們強制更新元數據。	長	300000	[0，...]	低
metric.reporters	用作度量記錄的類的列表。實現org.apache.kafka.common.metrics.MetricsReporter接口允許插入將被通知新度量創建的類。JmxReporter始終包含在註冊JMX統計信息中。	名單	“”		低
metrics.num.samples	維持用於計算度量的樣本數量。	INT	2	[1，...]	低
metrics.recording.level	指標的最高記錄級別。	串	信息	[信息，調試]	低
metrics.sample.window.ms	計算指標樣本的時間窗口。	長	30000	[0，...]	低
reconnect.backoff.max.ms	重新連接到重複連接失敗的代理程序時要等待的最長時間（以毫秒爲單位）。如果提供的話，每個主機的退避將以指數方式增加，對於每個連續的連接失敗，達到這個最大值。計算後退增加後，增加20％隨機抖動以避免連接風暴。	長	1000	[0，...]	低
reconnect.backoff.ms	嘗試重新連接到給定主機之前等待的基本時間。這避免了在一個緊密的循環中重複連接到主機。該退避適用於客戶端向經紀人的所有連接嘗試。	長	50	[0，...]	低
retry.backoff.ms	嘗試重試對給定主題分區的失敗請求之前等待的時間量。這樣可以避免在某些故障情況下重複發送請求。	長	100	[0，...]	低
sasl.kerberos.kinit.cmd	Kerberos kinit命令路徑。	串	在/ usr / bin中/ kinit命令		低
sasl.kerberos.min.time.before.relogin	登錄線程在刷新嘗試之間的休眠時間	長	60000		低
sasl.kerberos.ticket.renew.jitter	隨機抖動增加到更新時間的百分比。	雙	0.05		低
sasl.kerberos.ticket.renew.window.factor	登錄線程將休眠，直到已經到達從上次刷新到票證到期的指定窗口時間因子，屆時它將嘗試更新票證。	雙	0.8		低
ssl.cipher.suites	密碼套件列表。這是用於使用TLS或SSL網絡協議來協商網絡連接的安全設置的認證，加密，MAC和密鑰交換算法的命名組合。默認情況下，所有可用的密碼套件都受支持。	名單	空值		低
ssl.endpoint.identification.algorithm	使用服務器證書驗證服務器主機名的端點識別算法。	串	空值		低
ssl.keymanager.algorithm	密鑰管理器工廠用於SSL連接的算法。信息範範範讀預辛辛	串	SunX509		低
ssl.secure.random.implementation	用於SSL加密操作的SecureRandom PRNG實現。	串	空值		低
ssl.trustmanager.algorithm	信任管理器工廠用於SSL連接的算法。默認值是爲Java虛擬機配置的信任管理器工廠算法。	串	PKIX		低

3.4.2老消費者配置

基本的老消費者配置如下：

• group.id
• zookeeper.connect

屬性	默認	描述
group.id		唯一標識此消費者所屬的消費者進程組的字符串。通過設置相同的組ID，多個進程表明它們都是同一個用戶組的一部分。
zookeeper.connect		hostname:port以主機和端口爲ZooKeeper服務器的主機和端口的形式指定ZooKeeper連接字符串。當ZooKeeper機器停機時，爲了允許通過其他ZooKeeper節點進行連接，還可以在表單中指定多個主機hostname1:port1,hostname2:port2,hostname3:port3。 服務器也可能有一個ZooKeeper chroot路徑作爲其ZooKeeper連接字符串的一部分，該連接字符串將其數據置於全局ZooKeeper命名空間的某個路徑下。如果是這樣，消費者應該在其連接字符串中使用相同的chroot路徑。例如，給/chroot/path你一個chroot路徑將給連接字符串hostname1:port1,hostname2:port2,hostname3:port3/chroot/path。
consumer.id	空值	如果沒有設置，自動生成。
socket.timeout.ms	30 * 1000	網絡請求的套接字超時。實際的超時設置將是max.fetch.wait + socket.timeout.ms。
socket.receive.buffer.bytes	64 * 1024	套接字接收緩衝區的網絡請求
fetch.message.max.bytes	1024 * 1024	在每個提取請求中嘗試爲每個主題分區提取的消息的字節數。這些字節將被讀入每個分區的內存，所以這有助於控制消費者使用的內存。獲取請求大小必須至少與服務器允許的最大消息大小一樣大，否則生產者可能發送大於消費者可以獲取的消息。
num.consumer.fetchers	1	用於提取數據的數量提取器線程。
auto.commit.enable	真正	如果爲true，則定期向ZooKeeper提交消費者已獲取的消息的偏移量。當進程失敗時，將使用此提交的偏移量作爲新消費者開始的位置。
auto.commit.interval.ms	60 * 1000	消費者偏移量承諾給動物園管理員的頻率（以毫秒爲單位）。
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	Backoff time between retries during rebalance. If not set explicitly, the value in zookeeper.sync.time.ms is used.
refresh.leader.backoff.ms	200	Backoff time to wait before trying to determine the leader of a partition that has just lost its leader.
auto.offset.reset	largest	What to do when there is no initial offset in ZooKeeper or if an offset is out of range: * smallest : automatically reset the offset to the smallest offset * largest : automatically reset the offset to the largest offset * anything else: throw exception to the consumer
consumer.timeout.ms	-1	Throw a timeout exception to the consumer if no message is available for consumption after the specified interval
exclude.internal.topics	true	Whether messages from internal topics (such as offsets) should be exposed to the consumer.
client.id	group id value	The client id is a user-specified string sent in each request to help trace calls. It should logically identify the application making the request.
zookeeper.session.timeout.ms	6000	ZooKeeper session timeout. If the consumer fails to heartbeat to ZooKeeper for this period of time it is considered dead and a rebalance will occur.
zookeeper.connection.timeout.ms	6000	The max time that the client waits while establishing a connection to zookeeper.
zookeeper.sync.time.ms	2000	How far a ZK follower can be behind a ZK leader
offsets.storage	zookeeper	Select where offsets should be stored (zookeeper or kafka).
offsets.channel.backoff.ms	1000	The backoff period when reconnecting the offsets channel or retrying failed offset fetch/commit requests.
offsets.channel.socket.timeout.ms	10000	Socket timeout when reading responses for offset fetch/commit requests. This timeout is also used for ConsumerMetadata requests that are used to query for the offset manager.
offsets.commit.max.retries	5	Retry the offset commit up to this many times on failure. This retry count only applies to offset commits during shut-down. It does not apply to commits originating from the auto-commit thread. It also does not apply to attempts to query for the offset coordinator before committing offsets. i.e., if a consumer metadata request fails for any reason, it will be retried and that retry does not count toward this limit.
dual.commit.enabled	true	如果您使用“kafka”作爲offsets.storage，則可以雙向提交到ZooKeeper的偏移量（除了Kafka）。從基於zookeeper的偏移量存儲遷移到基於kafka的偏移量存儲時，這是必需的。對於任何給定的消費者羣體，在該羣組中的所有實例已經遷移到向代理（而不是直接向ZooKeeper）提交偏移的新版本之後，將其關閉是安全的。
partition.assignment.strategy	範圍	在“範圍”或“循環”策略之間進行選擇，以將分區分配給消費者流。 循環分區分配器將所有可用的分區和所有可用的使用者線程放在一起。然後繼續執行從分區到消費者線程的循環分配。如果所有消費者實例的訂閱都是相同的，那麼分區將被均勻分配。（即，所有消費者線程中的分區所有權計數將在一個正好爲1的增量內）。只有在以下情況下才允許循環分配：（a）每個主題在消費者實例中具有相同數量的流（b）訂閱的主題對於組內的每個消費者實例是相同的。 範圍分區在每個主題的基礎上工作。對於每個主題，我們按數字順序排列可用的分區，消費者以字典順序排列。然後，我們將分區數除以消費者流（線程）的總數，以確定分配給每個消費者的分區數。如果它不均勻分配，那麼前幾個消費者將有一個額外的分區。

關於消費者配置的更多細節可以在scala類中找到kafka.consumer.ConsumerConfig。

3.5卡夫卡連接配置

以下是Kafka Connect框架的配置。

名稱	描述	類型	默認	有效值	重要性
config.storage.topic	存儲連接器配置的Kafka主題的名稱	串			高
group.id	標識此工作人員所屬的Connect羣集組的唯一字符串。	串			高
key.converter	轉換器類用於在Kafka Connect格式和寫入Kafka的序列化表單之間進行轉換。這將控制寫入Kafka或從Kafka讀取的消息中的密鑰格式，因爲這與連接器無關，所以它允許任何連接器使用任何序列化格式。常見格式的例子包括JSON和Avro。	類			高
offset.storage.topic	存儲連接器偏移量的Kafka主題的名稱	串			高
status.storage.topic	連接器和任務狀態存儲在卡夫卡主題的名稱	串			高
value.converter	轉換器類用於在Kafka Connect格式和寫入Kafka的序列化表單之間進行轉換。這將控制寫入Kafka或從Kafka讀取的消息中的值的格式，因爲這與連接器無關，所以它允許任何連接器使用任何序列化格式。常見格式的例子包括JSON和Avro。	類			高
internal.key.converter	轉換器類用於在Kafka Connect格式和寫入Kafka的序列化表單之間進行轉換。這將控制寫入Kafka或從Kafka讀取的消息中的密鑰格式，因爲這與連接器無關，所以它允許任何連接器使用任何序列化格式。常見格式的例子包括JSON和Avro。此設置控制框架使用的內部簿記數據的格式，例如配置和偏移，因此用戶通常可以使用任何有效的Converter實現。	類			低
internal.value.converter	轉換器類用於在Kafka Connect格式和寫入Kafka的序列化表單之間進行轉換。這將控制寫入Kafka或從Kafka讀取的消息中的值的格式，因爲這與連接器無關，所以它允許任何連接器使用任何序列化格式。常見格式的例子包括JSON和Avro。此設置控制框架使用的內部簿記數據的格式，例如配置和偏移，因此用戶通常可以使用任何有效的Converter實現。	類			低
bootstrap.servers	用於建立到Kafka集羣的初始連接的主機/端口對列表。客戶端將使用所有服務器，而不管在這裏指定哪些服務器用於引導 - 該列表僅影響用於發現全套服務器的初始主機。這個清單應該在表格中host1:port1,host2:port2,...。由於這些服務器僅用於初始連接以發現完整的羣集成員資格（可能會動態更改），因此此列表不必包含整套服務器（但可能需要多個服務器，以防服務器關閉） 。	名單	本地主機：9092		高
heartbeat.interval.ms	在使用Kafka的團隊管理設施時，心跳與團隊協調員之間的預期時間。心跳信號用於確保工作人員的會話保持活動狀態，並便於新成員加入或離開組時重新平衡。該值必須設置爲低於session.timeout.ms，但通常應設置爲不高於該值的1/3。它可以調整得更低，以控制正常再平衡的預期時間。	INT	3000		高
rebalance.timeout.ms	一旦重新平衡開始，每個工人加入該組的最長時間。這基本上是所有任務清除任何未決數據和提交偏移所需時間的限制。如果超時超時，則工作人員將被從組中移除，這將導致偏移提交失敗。	INT	60000		高
session.timeout.ms	用於檢測工作人員失敗的超時。工人週期性地發送心跳來向經紀人表明其活躍性。如果代理在該會話超時到期之前沒有收到檢測信號，代理將從該組中刪除該工作人員並啓動重新平衡。請注意，該值必須在允許的範圍內，正如代理配置中的group.min.session.timeout.msand所配置的那樣group.max.session.timeout.ms。	INT	10000		高
ssl.key.password	密鑰存儲文件中的私鑰密碼。這對於客戶端是可選的。	密碼	空值		高
ssl.keystore.location	密鑰存儲文件的位置。這對客戶端是可選的，可以用於客戶端的雙向認證。	串	空值		高
ssl.keystore.password	密鑰存儲文件的商店密碼。這對客戶端是可選的，只有在配置了ssl.keystore.location時才需要。	密碼	空值		高
ssl.truststore.location	信任存儲文件的位置。	串	空值		高
ssl.truststore.password	信任存儲文件的密碼。如果密碼未設置，信任庫的訪問仍然可用，但完整性檢查被禁用。	密碼	空值		高
connections.max.idle.ms	在此配置指定的毫秒數之後關閉空閒連接。	長	540000		中
receive.buffer.bytes	讀取數據時使用的TCP接收緩衝區（SO_RCVBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	32768	[0，...]	中
request.timeout.ms	配置控制客戶端等待請求響應的最長時間。如果在超時過去之前未收到響應，則客戶端將在必要時重新發送請求，或者如果重試耗盡，則請求失敗。	INT	40000	[0，...]	中
sasl.jaas.config	用於JAAS配置文件使用的格式的SASL連接的JAAS登錄上下文參數。這裏描述JAAS配置文件格式。值的格式是：'（=）*;”	密碼	空值		中
sasl.kerberos.service.name	Kafka運行的Kerberos主體名稱。這可以在Kafka的JAAS配置或Kafka的配置中定義。	串	空值		中
sasl.mechanism	用於客戶端連接的SASL機制。這可能是安全提供者可用的任何機制。GSSAPI是默認的機制。	串	GSSAPI		中
security.protocol	用於與經紀人溝通的協議。有效值爲：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。	串	純文本		中
send.buffer.bytes	發送數據時要使用的TCP發送緩衝區（SO_SNDBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	131072	[0，...]	中
ssl.enabled.protocols	啓用了SSL連接的協議列表。	名單	TLSv1.2工作，TLSv1.1，使用TLSv1		中
ssl.keystore.type	密鑰存儲文件的文件格式。這對於客戶端是可選的。	串	JKS		中
ssl.protocol	用於生成SSLContext的SSL協議。默認設置是TLS，在大多數情況下這是很好的。最近的JVM中允許的值是TLS，TLSv1.1和TLSv1.2。較舊的JVM中可能支持SSL，SSLv2和SSLv3，但由於已知的安全漏洞，它們的使用不受歡迎。	串	TLS		中
ssl.provider	用於SSL連接的安全提供程序的名稱。默認值是JVM的默認安全提供程序。	串	空值		中
ssl.truststore.type	信任存儲文件的文件格式。	串	JKS		中
worker.sync.timeout.ms	當員工與其他員工不同步並需要重新同步配置時，請在放棄之前等待這段時間，離開組並等待退休時間，然後再重新加入。	INT	3000		中
worker.unsync.backoff.ms	當員工與其他員工不同步並且無法趕上worker.sync.timeout.ms時，在重新加入之前將Connect羣集保留很長時間。	INT	300000		中
access.control.allow.methods	通過設置Access-Control-Allow-Methods標頭來設置跨源請求所支持的方法。Access-Control-Allow-Methods頭的缺省值允許GET，POST和HEAD的交叉源請求。	串	“”		低
access.control.allow.origin	值到訪問控制允許來源頭設置爲REST API requests.To啓用跨源訪問，這設置爲應該被允許訪問的API，或應用程序的域“*”，以允許從任何存取域。默認值只允許從REST API的域進行訪問。	串	“”		低
client.id	發出請求時傳遞給服務器的id字符串。這樣做的目的是通過允許在服務器端請求日誌中包含一個邏輯應用程序名稱來跟蹤請求的來源，而不僅僅是ip / port。	串	“”		低
config.storage.replication.factor	創建配置存儲主題時使用的複製因子	短	3	[1，...]	低
metadata.max.age.ms	以毫秒爲單位的時間段之後，即使我們沒有看到任何分區領導變化，以主動發現任何新的代理或分區，我們強制更新元數據。	長	300000	[0，...]	低
metric.reporters	用作度量記錄的類的列表。實現org.apache.kafka.common.metrics.MetricsReporter接口允許插入將被通知新度量創建的類。JmxReporter始終包含在註冊JMX統計信息中。	名單	“”		低
metrics.num.samples	維持用於計算度量的樣本數量。	INT	2	[1，...]	低
metrics.recording.level	指標的最高記錄級別。	串	信息	[信息，調試]	低
metrics.sample.window.ms	計算指標樣本的時間窗口。	長	30000	[0，...]	低
offset.flush.interval.ms	嘗試爲任務提交抵消的時間間隔。	長	60000		低
offset.flush.timeout.ms	在取消進程並恢復將來嘗試提交的偏移數據之前，等待記錄刷新的最大毫秒數以及將提交的偏移數據提交到偏移存儲的最大毫秒數。	長	5000		低
offset.storage.partitions	創建偏移量存儲主題時使用的分區數量	INT	25	[1，...]	低
offset.storage.replication.factor	創建偏移量存儲主題時使用的複製因子	短	3	[1，...]	低
plugin.path	包含插件（連接器，轉換器，轉換）的由逗號（，）分隔的路徑列表。該列表應包含頂級目錄，其中包括以下任意組合：a）立即包含帶有插件及其依賴項的jar的目錄b）帶有插件及其依賴項的uber-jar項目c）立即包含插件類的包目錄結構依賴關係注意：將遵循符號鏈接來發現依賴關係或插件。例子：plugin.path = / usr / local / share / java，/ usr / local / share / kafka / plugins，/ opt / connectors	名單	空值		低
reconnect.backoff.max.ms	重新連接到重複連接失敗的代理程序時要等待的最長時間（以毫秒爲單位）。如果提供的話，每個主機的退避將以指數方式增加，對於每個連續的連接失敗，達到這個最大值。計算後退增加後，增加20％隨機抖動以避免連接風暴。	長	1000	[0，...]	低
reconnect.backoff.ms	嘗試重新連接到給定主機之前等待的基本時間。這避免了在一個緊密的循環中重複連接到主機。該退避適用於客戶端向經紀人的所有連接嘗試。	長	50	[0，...]	低
rest.advertised.host.name	如果設置了，則這是將要發給其他工作人員連接的主機名。	串	空值		低
rest.advertised.port	如果設置了這個，那麼這個端口將被髮給其他工作人員連接。	INT	空值		低
rest.host.name	REST API的主機名。如果這設置，它將只綁定到這個接口。	串	空值		低
rest.port	REST API偵聽的端口。	INT	8083		低
retry.backoff.ms	嘗試重試對給定主題分區的失敗請求之前等待的時間量。這樣可以避免在某些故障情況下重複發送請求。	長	100	[0，...]	低
sasl.kerberos.kinit.cmd	Kerberos kinit命令路徑。	串	在/ usr / bin中/ kinit命令		低
sasl.kerberos.min.time.before.relogin	登錄線程在刷新嘗試之間的休眠時間	長	60000		低
sasl.kerberos.ticket.renew.jitter	隨機抖動增加到更新時間的百分比。	雙	0.05		低
sasl.kerberos.ticket.renew.window.factor	登錄線程將休眠，直到已經到達從上次刷新到票證到期的指定窗口時間因子，屆時它將嘗試更新票證。	雙	0.8		低
ssl.cipher.suites	密碼套件列表。這是用於使用TLS或SSL網絡協議來協商網絡連接的安全設置的認證，加密，MAC和密鑰交換算法的命名組合。默認情況下，所有可用的密碼套件都受支持。	名單	空值		低
ssl.endpoint.identification.algorithm	使用服務器證書驗證服務器主機名的端點識別算法。	串	空值		低
ssl.keymanager.algorithm	密鑰管理器工廠用於SSL連接的算法。信息範範範讀預辛辛	串	SunX509		低
ssl.secure.random.implementation	用於SSL加密操作的SecureRandom PRNG實現。	串	空值		低
ssl.trustmanager.algorithm	信任管理器工廠用於SSL連接的算法。默認值是爲Java虛擬機配置的信任管理器工廠算法。	串	PKIX		低
status.storage.partitions	創建狀態存儲主題時使用的分區數量	INT	五	[1，...]	低
status.storage.replication.factor	創建狀態存儲主題時使用的複製因子	短	3	[1，...]	低
task.shutdown.graceful.timeout.ms	等待任務正常關閉的時間。這是總時間，而不是每個任務。所有任務都有關閉觸發，然後按順序等待。	長	5000		低

3.6卡夫卡流配置

以下是Kafka Streams客戶端庫的配置。

名稱	描述	類型	默認	有效值	重要性
application.id	流處理應用程序的標識符。在Kafka集羣中必須是唯一的。它被用作1）默認的客戶端ID前綴，2）用於成員資格管理的組ID，3）變更記錄主題前綴。	串			高
bootstrap.servers	用於建立到Kafka集羣的初始連接的主機/端口對列表。客戶端將使用所有服務器，而不管在這裏指定哪些服務器用於引導 - 該列表僅影響用於發現全套服務器的初始主機。這個清單應該在表格中host1:port1,host2:port2,...。由於這些服務器僅用於初始連接以發現完整的羣集成員資格（可能會動態更改），因此此列表不必包含整套服務器（但可能需要多個服務器，以防服務器關閉） 。	名單			高
replication.factor	流處理應用程序創建的更改日誌主題和重新分區主題的複製因子。	INT	1		高
state.dir	州商店的目錄位置。	串	的/ tmp /卡夫卡流		高
cache.max.bytes.buffering	在所有線程中用於緩衝的最大內存字節數	長	10485760	[0，...]	中
client.id	用於內部消費者，生產者和還原消費者的客戶端ID的ID前綴字符串，模式爲“-StreamThread- - ”。	串	“”		中
default.deserialization.exception.handler	實現org.apache.kafka.streams.errors.DeserializationExceptionHandler接口的異常處理類。	類	org.apache.kafka.streams.errors.LogAndFailExceptionHandler		中
default.key.serde	實現org.apache.kafka.common.serialization.Serde接口的鍵的默認序列化器/反序列化器類。	類	org.apache.kafka.common.serialization.Serdes $ ByteArraySerde		中
default.timestamp.extractor	實現org.apache.kafka.streams.processor.TimestampExtractor接口的默認時間戳提取器類。	類	org.apache.kafka.streams.processor.FailOnInvalidTimestamp		中
default.value.serde	實現org.apache.kafka.common.serialization.Serde接口的值的默認序列化器/反序列化器類。	類	org.apache.kafka.common.serialization.Serdes $ ByteArraySerde		中
num.standby.replicas	每個任務的備用副本數量。	INT	0		中
num.stream.threads	執行流處理的線程數。	INT	1		中
processing.guarantee	應該使用的處理保證。可能的值是at_least_once（默認）和exactly_once。	串	至少一次	[at_least_once，exactly_once]	中
security.protocol	用於與經紀人溝通的協議。有效值爲：PLAINTEXT，SSL，SASL_PLAINTEXT，SASL_SSL。	串	純文本		中
application.server	指向嵌入式用戶定義端點的主機：端口對，可用於在單個KafkaStreams應用程序中發現狀態存儲的位置	串	“”		低
buffered.records.per.partition	每個分區緩衝的最大記錄數。	INT	1000		低
commit.interval.ms	處理器位置的保存頻率。（注意，如果'processing.guarantee'設置爲'exactly_once'，則默認值爲100，否則默認值爲30000。	長	30000		低
connections.max.idle.ms	在此配置指定的毫秒數之後關閉空閒連接。	長	540000		低
key.serde	用於實現org.apache.kafka.common.serialization.Serde接口的鍵的序列化器/反序列化器類。這個配置不推薦使用，default.key.serde而是使用	類	空值		低
metadata.max.age.ms	以毫秒爲單位的時間段之後，即使我們沒有看到任何分區領導變化，以主動發現任何新的代理或分區，我們強制更新元數據。	長	300000	[0，...]	低
metric.reporters	用作度量記錄的類的列表。實現org.apache.kafka.common.metrics.MetricsReporter接口允許插入將被通知新度量創建的類。JmxReporter始終包含在註冊JMX統計信息中。	名單	“”		低
metrics.num.samples	維持用於計算度量的樣本數量。	INT	2	[1，...]	低
metrics.recording.level	指標的最高記錄級別。	串	信息	[信息，調試]	低
metrics.sample.window.ms	計算指標樣本的時間窗口。	長	30000	[0，...]	低
partition.grouper	實現org.apache.kafka.streams.processor.PartitionGrouper接口的分區石斑魚類。	類	org.apache.kafka.streams.processor.DefaultPartitionGrouper		低
poll.ms	阻止等待輸入的時間量（以毫秒爲單位）。	長	100		低
receive.buffer.bytes	讀取數據時使用的TCP接收緩衝區（SO_RCVBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	32768	[0，...]	低
reconnect.backoff.max.ms	重新連接到重複連接失敗的代理程序時要等待的最長時間（以毫秒爲單位）。如果提供的話，每個主機的退避將以指數方式增加，對於每個連續的連接失敗，達到這個最大值。計算後退增加後，增加20％隨機抖動以避免連接風暴。	長	1000	[0，...]	低
reconnect.backoff.ms	嘗試重新連接到給定主機之前等待的基本時間。這避免了在一個緊密的循環中重複連接到主機。該退避適用於客戶端向經紀人的所有連接嘗試。	長	50	[0，...]	低
request.timeout.ms	配置控制客戶端等待請求響應的最長時間。如果在超時過去之前未收到響應，則客戶端將在必要時重新發送請求，或者如果重試耗盡，則請求失敗。	INT	40000	[0，...]	低
retry.backoff.ms	嘗試重試對給定主題分區的失敗請求之前等待的時間量。這樣可以避免在某些故障情況下重複發送請求。	長	100	[0，...]	低
rocksdb.config.setter	岩石數據庫配置設置類或類名稱，實現org.apache.kafka.streams.state.RocksDBConfigSetter接口	類	空值		低
send.buffer.bytes	發送數據時要使用的TCP發送緩衝區（SO_SNDBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	131072	[0，...]	低
state.cleanup.delay.ms	在刪除分區遷移後的狀態之前等待的時間（以毫秒爲單位）。只有至少state.cleanup.delay.ms狀態的目錄纔會被刪除	長	600000		低
timestamp.extractor	實現org.apache.kafka.streams.processor.TimestampExtractor接口的時間戳提取器類。這個配置不推薦使用，default.timestamp.extractor而是使用	類	空值		低
value.serde	用於實現org.apache.kafka.common.serialization.Serde接口的值的序列化器/反序列化器類。這個配置不推薦使用，default.value.serde而是使用	類	空值		低
windowstore.changelog.additional.retention.ms	添加到Windows維護組，以確保數據不會過早地從日誌中刪除。允許時鐘漂移。默認爲1天	長	86400000		低
zookeeper.connect	Zookeeper爲Kafka主題管理連接字符串。這個配置不推薦使用，因爲Streams API不再使用Zookeeper，所以會被忽略。	串	“”		低

3.7 AdminClient配置

以下是Kafka Admin客戶端庫的配置。

名稱	描述	類型	默認	有效值	重要性
bootstrap.servers	用於建立到Kafka集羣的初始連接的主機/端口對列表。客戶端將使用所有服務器，而不管在這裏指定哪些服務器用於引導 - 該列表僅影響用於發現全套服務器的初始主機。這個清單應該在表格中host1:port1,host2:port2,...。由於這些服務器僅用於初始連接以發現完整的羣集成員資格（可能會動態更改），因此此列表不必包含整套服務器（但可能需要多個服務器，以防服務器關閉） 。	名單			高
ssl.key.password	密鑰存儲文件中的私鑰密碼。這對於客戶端是可選的。	密碼	空值		高
ssl.keystore.location	密鑰存儲文件的位置。這對客戶端是可選的，可以用於客戶端的雙向認證。	串	空值		高
ssl.keystore.password	密鑰存儲文件的商店密碼。這對客戶端是可選的，只有在配置了ssl.keystore.location時才需要。	密碼	空值		高
ssl.truststore.location	信任存儲文件的位置。	串	空值		高
ssl.truststore.password	信任存儲文件的密碼。如果密碼未設置，信任庫的訪問仍然可用，但完整性檢查被禁用。	密碼	空值		高
client.id	發出請求時傳遞給服務器的id字符串。這樣做的目的是通過允許在服務器端請求日誌中包含一個邏輯應用程序名稱來跟蹤請求的來源，而不僅僅是ip / port。	串	“”		中
connections.max.idle.ms	在此配置指定的毫秒數之後關閉空閒連接。	長	300000		中
receive.buffer.bytes	讀取數據時使用的TCP接收緩衝區（SO_RCVBUF）的大小。如果值爲-1，則將使用操作系統默認值。	INT	65536	[-1，...]	中
request.timeout.ms	配置控制客戶端等待請求響應的最長時間。如果在超時過去之前未收到響應，則客戶端將在必要時重新發送請求，或者如果重試耗盡，則請求失敗。	INT	120000	[0，...]	中
sasl.jaas.config	用於JAAS配置文件使用的格式的SASL連接的JAAS登錄上下文參數。這裏描述JAAS配置文件格式。值的格式是：'（=）*;”	密碼	空值		中
sasl.kerberos.service.name	Kafka運行的Kerberos主體名稱。這可以在Kafka的JAAS配置或Kafka的配置中定義。	串	空值		中
sasl.mechanism	SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.	string	GSSAPI		medium
security.protocol	Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL.	string	PLAINTEXT		medium
send.buffer.bytes	The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.	int	131072	[-1,...]	medium
ssl.enabled.protocols	The list of protocols enabled for SSL connections.	list	TLSv1.2,TLSv1.1,TLSv1		medium
ssl.keystore.type	The file format of the key store file. This is optional for client.	string	JKS		medium
ssl.protocol	The SSL protocol used to generate the SSLContext. Default setting is TLS, which is fine for most cases. Allowed values in recent JVMs are TLS, TLSv1.1 and TLSv1.2. SSL, SSLv2 and SSLv3 may be supported in older JVMs, but their usage is discouraged due to known security vulnerabilities.	string	TLS		medium
ssl.provider	The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.	string	null		medium
ssl.truststore.type	The file format of the trust store file.	string	JKS		medium
metadata.max.age.ms	The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.	long	300000	[0,...]	low
metric.reporters	A list of classes to use as metrics reporters. Implementing the org.apache.kafka.common.metrics.MetricsReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics.	list	""		low
metrics.num.samples	The number of samples maintained to compute metrics.	int	2	[1,...]	low
metrics.recording.level	The highest recording level for metrics.	string	INFO	[INFO, DEBUG]	low
metrics.sample.window.ms	The window of time a metrics sample is computed over.	long	30000	[0,...]	low
reconnect.backoff.max.ms	The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.	long	1000	[0,...]	low
reconnect.backoff.ms	The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker.	long	50	[0,...]	low
retries	The maximum number of times to retry a call before failing it.	int	5	[0,...]	low
retry.backoff.ms	The amount of time to wait before attempting to retry a failed request. This avoids repeatedly sending requests in a tight loop under some failure scenarios.	long	100	[0,...]	low
sasl.kerberos.kinit.cmd	Kerberos kinit命令路徑。	串	在/ usr / bin中/ kinit命令		低
sasl.kerberos.min.time.before.relogin	登錄線程在刷新嘗試之間的休眠時間	長	60000		低
sasl.kerberos.ticket.renew.jitter	隨機抖動增加到更新時間的百分比。	雙	0.05		低
sasl.kerberos.ticket.renew.window.factor	登錄線程將休眠，直到已經到達從上次刷新到票證到期的指定窗口時間因子，屆時它將嘗試更新票證。	雙	0.8		低
ssl.cipher.suites	密碼套件列表。這是用於使用TLS或SSL網絡協議來協商網絡連接的安全設置的認證，加密，MAC和密鑰交換算法的命名組合。默認情況下，所有可用的密碼套件都受支持。	名單	空值		低
ssl.endpoint.identification.algorithm	使用服務器證書驗證服務器主機名的端點識別算法。	串	空值		低
ssl.keymanager.algorithm	密鑰管理器工廠用於SSL連接的算法。信息範範範讀預辛辛	串	SunX509		低
ssl.secure.random.implementation	用於SSL加密操作的SecureRandom PRNG實現。	串	空值		低
ssl.trustmanager.algorithm	信任管理器工廠用於SSL連接的算法。默認值是爲Java虛擬機配置的信任管理器工廠算法。	串	PKIX		低

4.設計

4.1動機

我們設計的Kafka能夠作爲一個統一的平臺來處理大公司可能擁有的所有實時數據饋送。要做到這一點，我們必須考慮相當廣泛的用例。

它將不得不具有高吞吐量來支持高容量事件流，例如實時日誌聚合。

它將需要正常處理大量的數據積壓，以便能夠支持來自離線系統的週期性數據加載。

這也意味着系統將不得不處理低延遲傳遞來處理更傳統的消息傳遞用例。

我們希望支持對這些提要進行分區，分佈式，實時處理，以創建新的派生提要。這激發了我們的分區和消費者模式。

最後，在流被送入其他數據系統進行服務的情況下，我們知道系統必須能夠在出現機器故障時保證容錯。

支持這些用途導致我們設計了一些獨特的元素，更類似於數據庫日誌而不是傳統的消息傳遞系統。我們將在下面的章節中概述一些設計元素。

4.2持久性

不要害怕文件系統！

卡夫卡在很大程度上依賴文件系統來存儲和緩存消息。人們普遍認爲，“磁盤速度慢”使人們懷疑一個持久的結構可以提供有競爭力的表現。實際上，磁盤比人們所期望的要慢得多，速度也要快得多，這取決於它們的使用方式。一個設計合理的磁盤結構通常可以和網絡一樣快。

關於磁盤性能的關鍵事實是，硬盤的吞吐量與過去十年的磁盤搜索的延遲已經不同了。因此， 使用6個7200rpm SATA RAID-5陣列的JBOD配置上的線性寫入性能約爲600MB / sec，但隨機寫入的性能僅約爲100k / sec，相差6000多倍。這些線性讀取和寫入是所有使用模式中最可預測的，並且由操作系統進行了大量優化。現代操作系統提供預讀和後寫技術，以大塊爲單位預取數據，並將較小的邏輯寫入大型物理寫入。關於這個問題的進一步討論可以在這個ACM隊列文章中找到。他們真的找到了 順序磁盤訪問在某些情況下可能比隨機內存訪問更快！

爲了彌補這種性能差異，現代操作系統在使用主內存進行磁盤緩存方面變得越來越積極。現代操作系統將愉快地將所有空閒內存轉移到磁盤高速緩存，並在回收內存時性能降低。所有的磁盤讀寫操作都將通過這個統一的緩存。如果不使用直接I / O，此功能將無法輕鬆關閉，因此即使進程維護數據的進程內緩存，該數據也可能會在操作系統頁面緩存中複製，從而有效地存儲所有內容兩次。

而且，我們正在建立在JVM的基礎之上，任何花時間使用Java內存的人都知道兩件事情：

1. 對象的內存開銷很高，通常會使所存儲數據的大小加倍（或更糟糕）。
2. 隨着堆內數據的增加，Java垃圾收集變得越來越複雜和緩慢。

由於使用文件系統和依賴頁面緩存的這些因素優於維護內存緩存或其他結構，因此我們至少使可用緩存翻了一番，方法是自動訪問所有可用內存，並且可能再次通過存儲緊湊字節結構而不是單個對象。這樣做會導致在32GB的機器上高達28-30GB的緩存，而不受GC懲罰。此外，即使服務重新啓動，該緩存也會保持溫暖，而進程內緩存將需要在內存中重建（對於10GB的緩存可能需要10分鐘），否則將需要以完全冷的緩存開始（這可能意味着糟糕的初始表現）。這也大大簡化了代碼，因爲所有保持高速緩存和文件系統之間一致性的邏輯現在都在OS中，這往往比一次性的進行中的嘗試更有效和更正確地做到這一點。如果您的磁盤使用情況支持線性讀取，則預讀使用每個磁盤讀取的有用數據有效地預先填充此緩存。

這表明一個非常簡單的設計：當我們在空間不足的時候，不是儘可能地維護內存，而是把文件系統全部清理出來，我們反過來這樣做。所有數據立即寫入文件系統的持久日誌，而不必沖刷到磁盤。實際上，這只是意味着它被轉移到內核的頁面緩存中。

這種以頁面緩存爲中心的設計風格在這裏的一個關於Varnish設計的文章中描述（伴隨着一種健康的傲慢態度）。

時間不變

消息傳遞系統中使用的持久數據結構通常是具有關聯的BTree或其他通用隨機訪問數據結構的按消費者隊列來維護關於消息的元數據。BTrees是可用的最通用的數據結構，可以在消息傳遞系統中支持各種各樣的事務性和非事務性語義。但它們的成本相當高：Btree操作是O（logN）。通常O（log N）被認爲基本上等同於常量時間，但是對於磁盤操作來說這不是真的。磁盤尋道是在10毫秒的時間來進行的，每個磁盤一次只能做一個尋道，所以並行性是有限的。因此，即使是少數磁盤尋找導致非常高的開銷。由於存儲系統將非常快速的緩存操作與非常慢的物理磁盤操作混合，

直觀地說，持久隊列可以建立在簡單的讀取上，並附加到文件中，這與記錄解決方案的情況相同。這個結構的優點是所有的操作都是O（1），讀操作不會阻止寫操作或者彼此之間的操作。由於性能與數據大小完全分離，這具有明顯的性能優勢 - 現在一臺服務器可以充分利用大量廉價，低轉速的1 + TB SATA驅動器。雖然它們的搜尋性能很差，但這些驅動器在大型讀寫方面的性能還是可以接受的，達到了三分之一的價格和三倍的容量。

在沒有任何性能損失的情況下訪問幾乎無限制的磁盤空間意味着我們可以提供通常在消息傳遞系統中找不到的一些功能 例如，在Kafka中，我們可以保留相對較長的時間（比如說一個星期），而不是試圖在消費後馬上刪除消息。正如我們將要描述的，這給消費者帶來了很大的靈活性。

4.3效率

我們已經付出了很大的努力效率。我們的主要用例之一是處理網絡活動數據，這是非常高的數據量：每個頁面視圖可能會產生幾十個寫入。此外，我們假設發佈的每條消息都被至少一個消費者（通常是很多消費者）讀取，因此我們努力使消費盡可能便宜。

我們還發現，從建立和運行一系列類似系統的經驗來看，效率是實現多租戶有效運營的關鍵。如果下游基礎設施服務由於應用程序使用量小而容易成爲瓶頸，那麼這些小的改變往往會產生問題。通過非常快的速度，我們可以幫助確保應用程序在基礎架構之前在負載下翻車。當嘗試運行支持集中式羣集上數十個或數百個應用程序的集中式服務時，這一點尤爲重要，因爲使用模式的變化幾乎每天都在發生。

我們在上一節討論了磁盤效率。一旦消除了較差的磁盤訪問模式，在這種類型的系統中有兩個常見的低效率原因：太多的小I / O操作和過多的字節複製。

客戶端和服務器之間以及服務器自己的持久操作中都會發生小I / O問題。

爲了避免這種情況，我們的協議是建立在一個“消息集”抽象的基礎上，自然將消息分組在一起。這允許網絡請求將消息分組在一起，並分攤網絡往返的開銷，而不是一次發送單個消息。服務器依次將大塊消息附加到其日誌中，並且消費者一次獲取大的線性塊。

這個簡單的優化產生了數量級的加速。批量導致更大的網絡數據包，更大的順序磁盤操作，連續的內存塊等等，所有這些都允許Kafka將隨機消息寫入的突發流轉換爲流向消費者的線性寫入。

另一個低效率是在字節複製。在低信息率這不是一個問題，但在負載下的影響是顯着的。爲了避免這種情況，我們使用由生產者，代理和消費者共享的標準二進制消息格式（因此可以在它們之間不加修改地傳送數據塊）。

由代理維護的消息日誌本身就是一個文件目錄，每個文件都由一系列消息集合填充，這些消息集合已經以生產者和消費者使用的相同格式寫入磁盤。保持這種通用格式可以優化最重要的操作：持久日誌塊的網絡傳輸。現代的unix操作系統提供了一個高度優化的代碼路徑，用於將數據從頁面緩存轉移到套接字; 在Linux中，這是通過sendfile系統調用完成的。

要理解sendfile的影響，瞭解數據從文件傳輸到套接字的常見數據路徑非常重要：

1. 操作系統將數據從磁盤讀取到內核空間的pagecache中
2. 應用程序從內核空間讀取數據到用戶空間緩衝區
3. 應用程序將數據寫回內核空間到套接字緩衝區
4. 操作系統將數據從套接字緩衝區複製到通過網絡發送的NIC緩衝區

這顯然是低效的，有四個副本和兩個系統調用。使用sendfile，通過允許操作系統將數據從pagecache直接發送到網絡，可以避免重新複製。所以在這個優化的路徑中，只需要最終拷貝到NIC緩衝區。

我們期望一個共同的用例在一個主題上成爲多個消費者。使用上面的零拷貝優化，數據被複制到頁面緩存中一次，並在每次使用時被重用，而不是被存儲在內存中，並且每次被讀取時拷貝到用戶空間。這允許消息以接近網絡連接限制的速率消耗。

頁面緩存和發送文件的組合意味着，在消費者大多被抓住的卡夫卡羣集中，您將看不到磁盤上的讀取活動，因爲它們將完全從緩存中提供數據。

有關sendfile和Java中零拷貝支持的更多背景信息，請參閱本文。

端到端的批量壓縮

在某些情況下，瓶頸實際上不是CPU或磁盤，而是網絡帶寬。對於需要通過廣域網在數據中心之間發送消息的數據管道尤其如此。當然，用戶總是可以一次壓縮一個消息，而不需要Kafka的任何支持，但是這會導致非常差的壓縮率，因爲冗餘的多少是由於相同類型的消息之間的重複（例如， JSON或Web日誌中的用戶代理或公共字符串值）。有效的壓縮需要一起壓縮多個消息，而不是單獨壓縮每個消息。

Kafka以高效的批處理格式支持這一點。一批消息可以壓縮在一起並以這種形式發送到服務器。這批消息將以壓縮格式寫入，並將保持壓縮在日誌中，只會由消費者解壓縮。

Kafka支持GZIP，Snappy和LZ4壓縮協議。有關壓縮的更多細節可以在這裏找到。

4.4生產者

負載均衡

生產者將數據直接發送給作爲分區領導者的代理，而不需要任何中間路由層。爲了幫助生產者做到這一點，所有的Kafka節點都可以回答關於哪些服務器是活着的元數據的請求，以及主題的分區的領導在哪裏給定的時間以允許生產者適當地指示其請求。

客戶端控制它將消息發佈到哪個分區。這可以隨機完成，實現一種隨機負載平衡，也可以通過一些語義分區功能完成。我們通過允許用戶指定一個鍵進行分區，並使用它來散列到一個分區（如果需要的話，也可以選擇覆蓋分區函數），從而公開接口進行語義分區。例如，如果選擇的密鑰是用戶ID，則給定用戶的所有數據將被髮送到相同的分區。這反過來將允許消費者對他們的消費做出當地的假設。這種分區方式明確地設計爲允許在消費者中進行局部敏感的處理。

異步發送

批次是效率的重要推動力之一，爲了實現批量生產，卡夫卡生產商將試圖在內存中積累數據，並在一個請求中發送大批量的數據。批處理可以被配置爲累加不超過固定數量的消息並且不超過某個固定的延遲限制（比如64k或10ms）。這允許發送更多字節的累積，並且在服務器上幾個較大的I / O操作。這種緩衝是可配置的，並提供了一種機制來折中少量額外的延遲以獲得更好的吞吐量。

有關配置的詳細信息和生產者的api可以在文檔的其他地方找到。

4.5消費者

Kafka消費者通過向經銷商發出“獲取”請求來引導他們想要消費的分區。消費者用每個請求在日誌中指定它的偏移量，並從該位置接收一大塊日誌。因此，消費者對這個位置具有重要的控制，並且如果需要的話可以倒轉以重新消費數據。

推與拉

我們考慮的一個最初的問題是，消費者是否應該從經紀商或經紀商那裏獲取數據，以便將數據推送給消費者。在這方面，卡夫卡採用了一種更爲傳統的設計方式，由大多數消息系統共享，數據從生產者推送給經紀人，由消費者從經紀人那裏提取。一些以日誌爲中心的系統，如Scribe和 Apache Flume，遵循一個非常不同的推送路徑，數據被推送到下游。這兩種方法都有優點和缺點。然而，基於推送的系統難以處理不同的消費者，因爲經紀人控制數據傳輸的速度。目標通常是消費者能夠以最大可能的速度消費; 不幸的是，在推動系統中，這意味着當消費率低於生產率（本質上是拒絕服務攻擊）時，消費者傾向於被壓倒。基於拉動的系統具有更好的屬性，消費者只要落後就趕上。這可以通過消費者可以指示它被壓倒的某種退避協議來緩解，但讓轉移率充分利用（但從來沒有過度利用）的消費者似乎比棘手。以前以這種方式構建系統的嘗試使我們得以採用更傳統的拉式模型。

基於拉式系統的另一個優點是，它可以將數據發送給消費者，基於推送的系統必須選擇立即發送請求，或者累積更多的數據，然後在不知道下游消費者是否能夠立即處理的情況下發送。如果調整爲低延遲，則這將導致一次只發送單個消息，以便傳輸結束被緩衝，這是浪費的。基於拉式的設計修復了這個問題，因爲消費者總是將所有可用的消息拉到日誌中的當前位置（或達到某個可配置的最大大小）之後。所以人們可以獲得最佳的配料而不會引入不必要的延遲

一個天真的基於拉式的系統的缺點是，如果經紀人沒有數據，消費者可能會在一個緊密的循環中結束投票，有效地忙於等待數據到達。爲了避免這種情況，我們在我們的pull請求中有一些參數，它們允許消費者請求以“長輪詢”的方式進行阻塞，等待數據到達（並且可選地等待，直到給定數量的字節可用以確保大的傳輸大小）。

你可以想象其他可能的設計，只會拉，端到端。製片人會在當地寫一個當地的日誌，經紀人會從消費者那裏抽出來。經常提出一個類似的“存儲和轉發”生產者。這是有趣的，但我們覺得不是很適合我們有成千上萬的生產者的目標用例。我們在大規模運行持久數據系統的經驗使我們感到，在許多應用程序中涉及系統中數以千計的磁盤實際上不會使事情變得更加可靠，而且會成爲一個噩夢般的操作。在實踐中，我們發現我們可以大規模地運行一個擁有強大SLA的流水線，而不需要生產者持久性。

消費者地位

跟蹤已經消耗的東西，令人驚訝的是，消息系統的關鍵性能點之一。

大多數消息傳遞系統都保留關於代理消費的消息的元數據。也就是說，當消息被髮送給消費者時，經紀人要麼立即在本地記錄該事實，要麼等待消費者的確認。這是一個相當直觀的選擇，實際上對於單個機器服務器來說，不清楚這個狀態可以去哪裏。由於在許多消息傳遞系統中用於存儲的數據結構規模較小，因此這也是一個實用的選擇 - 由於代理知道消耗的是什麼，它可以立即刪除它，保持數據量小。

也許不明顯的是，讓經紀人和消費者就所消費的東西達成一致並不是一個小問題。如果代理記錄作爲消息消耗立即將其通過網絡交給了每一個時間，那麼如果消費者無法處理的消息（比如，因爲它崩潰或請求超時或其他）該消息將會丟失。爲了解決這個問題，許多消息傳遞系統增加了一個確認功能，這意味着消息只在被髮送時被標記爲發送而不被消費。代理等待來自消費者的特定確認以將消息記錄爲消費。這個策略解決了丟失信息的問題，但是卻產生了新的問題。首先，如果消費者在消息發送失敗之前處理消息，那麼消息將被消費兩次。第二個問題是性能問題，現在，代理必須保持每個消息的多個狀態（首先鎖定它，以便不會再次發出消息，然後將其標記爲永久消耗，以便將其刪除）。棘手的問題必須得到處理，比如如何處理被髮送但未被確認的消息。

卡夫卡處理這個不同。我們的主題被分成一組完全有序的分區，每個分區在任何給定的時間都被每個訂閱消費者組中的一個消費者消費。這意味着消費者在每個分區中的位置只是一個整數，即要消耗的下一個消息的偏移量。這使得所消耗的狀態非常小，每個分區只有一個數字。這個狀態可以定期檢查點。這使消息確認的等價物非常便宜。

這個決定有一個好處。消費者可以故意倒回到舊的偏移量並重新使用數據。這違反了隊列的共同合同，但是對於許多消費者來說卻是一個必不可少的特徵。例如，如果消費者代碼有一個錯誤，並且在一些消息被消費之後被發現，則消費者可以在錯誤修復後重新使用這些消息。

離線數據加載

可伸縮的持久性允許消費者僅僅週期性地消費的可能性，諸如批量數據加載，其週期性地將數據批量加載到諸如Hadoop或關係數據倉庫之類的離線系統中。

在Hadoop的情況下，我們通過在單個映射任務上分割負載來並行化數據負載，每個節點/主題/分區組合一個負載，在負載中允許完全並行化。Hadoop提供了任務管理功能，失敗的任務可以重新啓動，而沒有重複數據的危險，只需從原始位置重新啓動即可。

4.6消息傳遞語義

現在我們對生產者和消費者如何工作有一些瞭解，讓我們來討論一下Kafka在生產者和消費者之間提供的語義保證。顯然，可以提供多種可能的消息傳遞保證：

• 最多一次 -消息可能會丟失，但永遠不會重新發送。
• 至少一次 -消息永遠不會丟失，但可以重新傳遞。
• 恰恰一次 - 這就是人們真正想要的，每個信息只傳遞一次。

值得注意的是，這分成兩個問題：發佈消息的持久性保證以及消費消息時的保證。

許多系統聲稱提供“恰好一次”的交付語義，但重要的是要閱讀細則，這些聲明大多是誤導性的（即它們不轉化爲消費者或生產者可能失敗的情況，消費者進程，或寫入磁盤的數據可能丟失的情況）。

卡夫卡的語義是直截了當的。發佈消息時，我們將消息的概念“提交”到日誌中。一旦發佈的消息被提交，只要複製寫入該消息的分區的代理保持“活動”狀態，它就不會丟失。提交的消息的定義，活動分區以及我們試圖處理哪些類型的失敗的描述將在下一節中更詳細地描述。信息內的預讀亦作亦讀信息 如果生產者嘗試發佈消息並遇到網絡錯誤，則不能確定在提交消息之前或之後是否發生此錯誤。

在0.11.0.0之前，如果一個生產者沒有收到一個指示消息已經提交的響應，那麼除了重新發送消息之外別無選擇。這提供了至少一次的傳送語義，因爲如果原始請求實際上已經成功，則在重新發送期間可以再次將消息寫入日誌。自0.11.0.0開始，Kafka生產者也支持一個冪等遞送選項，保證重新發送不會在日誌中導致重複條目。爲了達到這個目的，代理人爲每個生產者分配一個ID，並使用生產者發送的序列號和每一個消息去重複消息。也從0.11.0.0開始，生產者支持使用事務類語義將消息發送到多個主題分區的能力：即，或者所有的消息都被成功寫入或者沒有消息。這個主要用例恰好在卡夫卡話題之間進行一次處理（如下所述）。

並不是所有的用例都需要這樣的強力保證 對於對延遲敏感的用途，我們允許生產者指定它想要的耐久性級別。如果生產者指定它想要等待提交的消息，則可以採用10ms的量級。然而，製作者也可以指定它想要完全異步地執行發送，或者它只想等到領導者（但不一定是跟隨者）纔有消息。

現在讓我們從消費者的角度來描述語義。所有副本都具有相同的日誌和相同的偏移量。消費者控制在這個日誌中的位置。如果消費者沒有崩潰，它可以將這個位置存儲在內存中，但是如果消費者失敗了，我們希望這個主題分區被另一個進程接管，那麼新進程需要選擇一個合適的位置來開始處理。假設消費者讀取一些消息 - 它具有處理消息和更新其位置的多個選項。

1. 它可以讀取消息，然後將其位置保存在日誌中，最後處理消息。在這種情況下，消費者進程在保存其位置之後但在保存其消息處理的輸出之前可能會崩潰。在這種情況下，接管處理的過程將從保存的位置開始，即使在該位置之前的一些消息還沒有被處理。這對應於“最多一次”的語義，如在消費者失敗的情況下可能不會被處理。
2. 它可以讀取消息，處理消息，並最終保存它的位置。在這種情況下，處理消息之後但在保存其位置之前，消費者進程可能會崩潰。在這種情況下，當新進程接管它收到的前幾個消息時，已經被處理了。在消費者失敗的情況下，這對應於“至少一次”的語義。在許多情況下，消息都有一個主鍵，所以更新是冪等的（接收相同的消息兩次，只是用另一個副本覆蓋一條記錄）。

那麼究竟是一次語義（即你真正想要的東西）呢？當從一個卡夫卡話題消費，併產生到另一個話題（如卡夫卡流 應用程序），我們可以利用上面提到的0.11.0.0中的新事務生成器功能。消費者的位置作爲消息存儲在主題中，所以我們可以在與接收處理的數據的輸出主題相同的事務中向Kafka寫入偏移量。如果交易被中止，則消費者的位置將恢復到其舊值，並且根據其“隔離級別”，輸出主題上產生的數據對其他消費者不可見。在默認的“read_uncommitted”隔離級別中，消費者即使是中止事務的一部分，所有消息都是可見的，但是在“read_committed”中，消費者只會從已提交的事務（以及任何不是的交易）。

寫入外部系統時，限制在於需要將消費者的位置與實際存儲爲輸出的位置進行協調。實現這一目標的經典方法是在消費者位置的存儲和消費者輸出的存儲之間引入兩階段提交。但是，這可以更簡單地處理，並且通常通過讓消費者將其偏移存儲在與其輸出相同的位置來進行。這樣做更好，因爲消費者可能想要寫入的許多輸出系統不支持兩階段提交。作爲一個例子，考慮一個 Kafka連接連接器，它在HDFS中填充數據以及讀取數據的偏移量，以確保數據和偏移量都被更新，或者兩者都不是。對於許多其他需要這些更強的語義的數據系統，我們也遵循類似的模式，並且對於這些數據系統，消息沒有允許重複數據刪除的主鍵。

因此，有效地，Kafka支持在Kafka Streams中一次交付，並且在Kafka主題之間傳輸和處理數據時，事務性生產者/消費者通常可用於提供準確一次的交付。其他目的地系統的一次交付通常需要與這些系統合作，但是Kafka提供了實現這種可行的補償（參見Kafka Connect）。否則，Kafka默認保證至少一次交付，並允許用戶在處理一批消息之前，通過禁止生產者重試和在消費者中提交補償來實施至多一次交付。

4.7複製

Kafka通過可配置數量的服務器複製每個主題分區的日誌（您可以在逐個主題的基礎上設置此複製因子）。這樣，當羣集中的服務器出現故障時，可以自動故障轉移到這些副本，以便在發生故障時保持可用狀態。

其他消息傳遞系統提供了一些與複製有關的功能，但在我們（完全有偏見的）看來，這似乎是一個不太常用的東西，而且有很大的缺點：從屬處於非活動狀態，吞吐量受到嚴重影響，繁瑣的手動配置等等。Kafka默認使用複製，實際上我們將未複製的主題實現爲複製因子爲1的複製主題。

複製單位是主題分區。在非失敗條件下，卡夫卡的每個分區都有一個單獨的領導者和零個或更多的追隨者。包括領導者的副本總數構成複製因素。所有的讀寫操作都轉到分區的領導。通常情況下，中間商比中間商多得多，而且領導者在經紀商之間平均分配。追隨者的日誌與領導者的日誌相同 - 都有相同順序的消息和消息（當然，在任何給定的時間，領導者可能在其日誌結尾處有幾條尚未複製的消息）。

追隨者像正常的卡夫卡消費者一樣消費領導者的消息，並將他們應用到他們自己的日誌中。讓追隨者從領導者身上取得好成績，可以讓追隨者自然地把日誌條目分配到日誌中。

與大多數分佈式系統一樣，自動處理故障需要精確定義節點“活躍”意味着什麼。對於卡夫卡節點的生存有兩個條件

1. 節點必須能夠維護與ZooKeeper的會話（通過ZooKeeper的心跳機制）
2. 如果它是一個奴隸，它必須複製發生在領導者上的寫作，而不是落後於“太遠”

我們將滿足這兩個條件的節點稱爲“同步”，以避免“活着”或“失敗”的模糊性。領導跟蹤“同步”節點的集合。如果追隨者死亡，被卡住或落後，領導將從同步副本列表中刪除它。停滯和滯後複製品的確定由replica.lag.time.max.ms配置控制。

在分佈式系統術語中，我們只嘗試處理節點突然停止工作，然後恢復（可能不知道已經死亡）的失敗/恢復模式。Kafka不處理所謂的“拜占庭式”的故障，其中節點產生任意或惡意的反應（可能是由於錯誤或犯規）。

現在我們可以更準確地定義，當該分區的所有同步副本將其應用於其日誌時，將認爲該消息已被提交。只有承諾的消息纔會被髮送給消費者。這意味着消費者不必擔心如果領導者失敗，可能會看到可能丟失的消息。另一方面，生產者可以選擇是否等待消息被執行，這取決於他們在等待時間和耐久性之間的權衡。這個首選項由生產者使用的acks設置控制。請注意，主題有一個“最小數量”的同步副本的設置，當生產者請求確認消息已寫入全套同步副本時，將檢查這些副本。

卡夫卡提供的保證是，只要至少有一個同步副本在任何時間存在，就不會丟失承諾的消息。

在短暫的故障切換期後，卡夫卡將保持可用狀態，但在出現網絡分區的情況下可能無法保持可用狀態。

複製日誌：法定人數，ISR和狀態機（哦，我的！）

卡夫卡分區的核心是一個複製日誌。複製日誌是分佈式數據系統中最基本的原語之一，實現它的方法很多。其他系統可以使用複製的日誌作爲實現其他分佈式系統狀態的原語。

一個複製日誌按照一系列值的順序（通常是對日誌條目編號0,1,2，...）進行建模。有很多方法可以實現這一點，但最簡單和最快的方法是選擇提供給它的值的排序的領導者。只要領導者還活着，所有的追隨者只需要複製價值和領導者選擇的命令。

當然，如果領導不失敗，我們就不需要追隨者！當領導者死亡時，我們需要從追隨者中選擇一個新的領導者。但追隨者本身可能落後或崩潰，所以我們必須確保我們選擇一個最新的追隨者。日誌複製算法必須提供的基本保證是，如果我們告訴客戶一個消息被提交，並且領導失敗，我們選擇的新領導也必須有這個消​​息。這產生了一個折衷：如果領導者在宣佈承諾之前等待更多的追隨者承認消息，那麼將會有更多潛在的可選領導者。

如果您選擇所需的確認數量以及必須比較的日誌數量來選擇一個領導者，以確保重疊，則稱爲定額。

這種權衡的一個常見方法是在投票決定和領導者選舉中使用多數票。這不是卡夫卡所做的，但是我們仍然可以通過探索來了解這個權衡。假設我們有2個f +1副本。如果f +1副本必須在領導者聲明提交之前接收到消息，並且如果我們通過從至少f +1個副本中選擇具有最完整日誌的跟隨者來選擇新的領導者 ，則不超過f失敗，領導者保證有所有承諾的信息。這是因爲在任何f+1副本，必須至少有一個副本包含所有已提交的郵件。這個副本的日誌將是最完整的，因此將被選爲新的領導者。每個算法都必須處理許多其他細節（例如，精確定義什麼使得日誌更加完整，確保領導者失敗期間的日誌一致性或更改副本集中的服務器集），但是現在我們將忽略這些細節。

這種多數表決方法有一個非常好的屬性：延遲是依賴於只有最快的服務器。也就是說，如果複製因子是3，則等待時間由更快的從屬者而不是較慢的從屬者確定。

這個系列有很多種算法，包括ZooKeeper的 Zab， Raft和Viewstamped Replication。我們知道Kafka的實際實現最類似的學術出版物是 來自Microsoft的PacificA。

The downside of majority vote is that it doesn't take many failures to leave you with no electable leaders. To tolerate one failure requires three copies of the data, and to tolerate two failures requires five copies of the data. In our experience having only enough redundancy to tolerate a single failure is not enough for a practical system, but doing every write five times, with 5x the disk space requirements and 1/5th the throughput, is not very practical for large volume data problems. This is likely why quorum algorithms more commonly appear for shared cluster configuration such as ZooKeeper but are less common for primary data storage. For example in HDFS the namenode's high-availability feature is built on a majority-vote-based journal, but this more expensive approach is not used for the data itself.

卡夫卡採取了一種稍微不同的方法來選擇法定人數。卡夫卡不是多數投票，而是動態地維護一組被引導到領導者的同步複製品（ISR）。只有這一組的成員纔有資格當選領導人。寫入Kafka分區不會被視爲提交，直到所有的同步副本收到寫入。這個ISR集合在ZooKeeper發生變化時會被持久化。正因爲如此，ISR中的任何複製品都有資格當選領導者。這是卡夫卡使用模式的一個重要因素，其中有很多分區，確保領導力平衡是重要的。有了這個ISR模型和f + 1副本，一個Kafka主題可以容忍f故障，而不會丟失承諾的消息。

對於我們希望處理的大多數用例，我們認爲這種權衡是合理的。在實踐中，爲了容忍f失敗，大多數投票和ISR方法都將等待相同數量的副本在提交消息之前確認（例如，在一次失敗後仍然存在，大多數法定人數需要三個副本和一個確認，ISR方法需要兩個副本和一個確認）。在沒有最慢服務器的情況下提交的能力是大多數投票方法的一個優點。但是，我們認爲通過允許客戶端選擇是否阻塞消息提交來改善，並且由於所需的複製因子較低而產生的額外的吞吐量和磁盤空間是值得的。

另一個重要的設計區別是，Kafka不要求崩潰的節點恢復所有的數據。在這個空間中的複製算法依賴於存在“穩定存儲”的情況並不少見，這種“穩定存儲”在沒有潛在的一致性違反的情況下在任何故障恢復情況下都不會丟失。這個假設有兩個主要的問題。首先，磁盤錯誤是我們在永久性數據系統的實際操作中觀察到的最常見的問題，並且它們通常不會使數據保持原樣。其次，即使這不是問題，我們也不希望在每次寫入時都要求使用fsync來保證一致性，因爲這會使性能降低兩到三個數量級。我們允許副本重新加入ISR的協議確保了在重新加入之前，

不潔的領導人選：如果他們都死了呢？

請注意，Kafka關於數據丟失的保證取決於至少有一個副本保持同步。如果複製分區的所有節點都死亡，則此保證不再成立。

然而，一個實際的系統需要做一些合理的事情，當所有的副本死亡。如果你不幸發生這種情況，重要的是要考慮會發生什麼。有兩種行爲可以實現：

1. 等待ISR的副本重新回到生活中，並選擇這個副本作爲領導者（希望它仍然擁有所有的數據）。
2. 選擇第一個複製品（不一定在ISR中）作爲領導者復活。

這是可用性和一致性之間的簡單折衷。如果我們在ISR中等待副本，那麼只要這些副本停機，我們將保持不可用狀態。如果這樣的複製品被毀壞或者他們的數據丟失了，那麼我們永遠是失敗的。另一方面，如果一個不同步的複製品恢復生機，並且我們允許它成爲領導者，那麼它的日誌就成爲真相的來源，即使它不能保證每一個提交的信息都是如此。默認情況下，Kafka選擇第二種策略，並且當ISR中的所有副本都已經死掉時，選擇可能不一致的副本。可以使用配置屬性unclean.leader.election.enable來禁用此行爲，以支持停機時間優於不一致的用例。

這種困境並不是卡夫卡所特有的。它存在於任何法定人數的計劃中。例如，在大多數投票計劃中，如果大多數服務器遭受永久性故障，那麼您必須選擇丟失100％的數據，或者通過將現有服務器上剩下的內容作爲新的事實來源來破壞一致性。

可用性和耐久性保證

寫給Kafka時，製作者可以選擇是否等待消息被0,1或全部（-1）複製品確認。請注意，“所有副本確認”並不保證已分配副本的全套已收到消息。默認情況下，當acks = all時，只要所有當前的同步副本收到消息，確認就會發生。例如，如果一個主題配置了只有兩個副本，一個失敗（即只有一個同步副本保留），那麼指定acks = all的寫入將會成功。但是，如果剩餘副本也失敗，這些寫入可能會丟失。儘管這確保了分區的最大可用性，但是對於偏好耐久性而不是可用性的一些用戶，這種行爲可能是不希望的。因此，

1. 禁用不乾淨的領導者選舉 - 如果所有副本都不可用，那麼分區將保持不可用，直到最近的領導者再次可用。這有效地避免了消息丟失的風險。請參閱上一節有關不潔領導人選舉的澄清。
2. 指定最小的ISR大小 - 如果ISR的大小超過某個最小值，分區將只接受寫入操作，以防止僅寫入單個副本的消息丟失，而後者將不可用。這個設置只有在生產者使用acks = all的情況下才會生效，並且保證這個消息至少被許多in-sync副本確認。此設置提供了一致性和可用性之間的折中。對於最小ISR大小的更高設置保證了更好的一致性，因爲信息被保證寫入更多的副本，這減少了丟失的可能性。但是，這會降低可用性，因爲如果同步副本的數量低於最小閾值，則分區將無法寫入。

副本管理

以上關於複製日誌的討論確實只涵蓋了單個日誌，即一個主題分區。然而，一個Kafka集羣將管理數百或數千個這樣的分區。我們嘗試以循環方式平衡集羣內的分區，以避免在少量節點上集中高容量主題的所有分區。同樣，我們試圖平衡領導力，使每個節點成爲其分區比例份額的領導者。

優化領導層選舉過程也是重要的，因爲這是不可用的關鍵窗口。領導者選舉的一個天真的實現將最終運行每個分區的選舉爲該節點失敗時託管節點的所有分區運行。相反，我們選擇其中一個經紀人作爲“控制者”。該控制器檢測代理級別的故障，並負責更改故障代理中所有受影響的分區的負責人。結果是，我們可以將許多所需的領導層變更通知批量化，這使得選舉過程對於大量分區而言要便宜得多並且速度更快。如果控制者失敗，其中一個倖存的經紀人將成爲新的控制者。

4.8日誌壓縮

日誌壓縮可確保Kafka始終至少爲單個主題分區的數據日誌中的每個消息密鑰保留最後一個已知值。它解決了用例和場景，例如在應用程序崩潰或系統故障之後恢復狀態，或者在運行維護期間重新啓動應用程序之後重新加載緩存。讓我們更詳細地介紹這些用例，然後描述壓縮是如何工作的。

到目前爲止，我們只描述了更簡單的數據保留方法，在一段固定的時間之後丟棄舊的日誌數據，或者日誌達到某個預定的大小。這適用於時間事件數據，例如記錄每個記錄獨立的地方。然而，重要的一類數據流是對鍵控，可變數據（例如對數據庫表的更改）的更改日誌。

我們來討論一個這樣的流的具體例子。假設我們有一個包含用戶郵箱地址的主題，每當用戶更新他們的電子郵件地址時，我們都會使用他們的用戶ID作爲主鍵向此主題發送消息。現在說我們在一段時間內爲id爲123的用戶發送以下消息，每個消息對應於電子郵件地址的改變（其他id的消息被省略）：

1 2 3 4 五 6 7 8 9

123 => [email protected]         .         .         . 123 => [email protected]         .         .         . 123 => [email protected]

日誌壓縮爲我們提供了一個更細粒度的保留機制，以便我們保證至少保留每個主鍵（例如[email protected]）的最後更新。通過這樣做，我們保證日誌包含每個密鑰的最終值的完整快照，而不僅僅是最近更改的密鑰。這意味着下游消費者可以從這個主題中恢復自己的狀態，而不必保留所有更改的完整日誌。

我們先看幾個有用的用例，然後看看它是如何使用的。

1. 數據庫更改訂閱。通常需要在多個數據系統中擁有一個數據集，而且這些系統中的一個往往是某種數據庫（RDBMS或可能是一個新開發的鍵值存儲）。例如，您可能有一個數據庫，一個緩存，一個搜索集羣和一個Hadoop集羣。每次對數據庫的更改都需要反映在緩存，搜索羣集中，最終在Hadoop中。在只處理實時更新的情況下，您只需要最近的日誌。但是，如果您希望能夠重新加載緩存或恢復失敗的搜索節點，則可能需要完整的數據集。
2. 事件採購。這是一種應用程序設計風格，它將查詢處理與應用程序設計協同定位，並使用變更日誌作爲應用程序的主要存儲。
3. 日誌記錄高可用性。執行本地計算的進程可以通過註銷對其本地狀態所做的更改來實現容錯，以便另一個進程可以重新加載這些更改並在出現故障時繼續執行。一個具體的例子是在流查詢系統中處理計數，聚合和其他“按類”處理。Samza是一個實時的流處理框架， 正是爲了這個目的而使用這個特性。

在這些情況下，主要需要處理變化的實時饋送，但是偶爾當機器崩潰或需要重新加載或重新處理數據時，需要滿載。日誌壓縮允許將這兩個用例從相同的支持主題中提取出來。本博客文章更詳細地介紹了這種日誌的使用方式。

總的想法很簡單。如果我們有無限的日誌保留，並且記錄了上述情況下的每一個變化，那麼我們就會從第一次開始時就捕獲到系統的狀態。使用這個完整的日誌，我們可以通過重放日誌中的前N個記錄來恢復到任何時間點。這個假設的完整日誌對於更新單個記錄多次的系統來說並不是很實用，因爲即使對於穩定的數據集，日誌也將不受限制地增長。其扔掉舊的更新簡單的日誌保留機制約束的空間，但該日誌已不再恢復方式的當前狀態，現在可以從日誌的開頭不再恢復再現舊更新可能不會在所有拍攝的當前狀態。

日誌壓縮是提供更細粒度的每記錄保留的機制，而不是更粗粒度的基於時間的保留。這個想法是有選擇地刪除我們有一個更新的更新與相同的主鍵的記錄。這樣，日誌保證至少有每個密鑰的最後一個狀態。

此保留策略可以按每個主題進行設置，因此單個羣集可以有一些主題，其中的保留是按大小或時間強制執行的，其他主題是通過壓縮保留保留的主題。

這種功能受到LinkedIn最古老，最成功的基礎架構之一 - 數據庫變更日誌緩存服務Databus的啓發。與大多數日誌結構存儲系統不同的是，Kafka是爲訂閱而建立的，它組織數據以實現快速的線性讀寫。與Databus不同的是，Kafka充當真實來源商店，所以即使在上游數據源不可重播的情況下也是如此。

日誌壓縮基礎

這是一個高級圖片，顯示每個消息的偏移量的Kafka日誌的邏輯結構。

 

日誌的頭部與傳統的Kafka日誌相同。它具有密集的連續偏移並保留所有消息。日誌壓縮添加了一個處理日誌尾部的選項。上面的圖片顯示了一個壓縮尾巴的日誌。請注意，日誌尾部的消息保留了第一次寫入時分配的原始偏移量 - 這些消息從不改變。還要注意的是，即使具有該偏移量的消息已被壓縮，所有偏移仍然保留在日誌中的有效位置; 在這種情況下，這個位置與日誌中出現的下一個最高偏移無法區分。例如，在上面的圖片中，偏移量36,37和38都是等同的位置，並且從這些偏移量的任何一個開始的讀取將返回從38開始的消息集合。

壓縮也允許刪除。具有密鑰和空有效負載的消息將被視爲從日誌中刪除。這個刪除標記會導致任何先前的消息被刪除（如同任何帶有該密鑰的新消息一樣），但是刪除標記是特殊的，因爲在一段時間之後它們自己將被清除出日誌以釋放空間。刪除不再保留的時間點被標記爲上圖中的“刪除保留點”。

壓縮是通過定期重新複製日誌段在後臺完成的。清洗不會阻塞讀取，並且可以被限制使用不超過可配置數量的I / O吞吐量，以避免影響生產者和消費者。壓縮日誌段的實際過程如下所示：

 

日誌壓縮提供了什麼保證？

日誌壓縮保證以下內容：

1. 任何一個處於日誌頭部的消費者都會看到每個被寫入的消息; 這些消息將有連續的偏移量。min.compaction.lag.ms可以使用主題來保證寫入消息之前必須經過的最短時間長度，然後才能被壓縮。即它提供了每個消息將保留在（未壓縮的）頭部多長時間的下限。
2. 消息的排序始終保持不變。壓縮永遠不會重新排序消息，只是刪除一些。
3. 消息的偏移不會改變。它是日誌中位置的永久標識符。
4. 從日誌開始的任何消費者將至少看到他們寫入的所有記錄的最終狀態。此外，只要用戶在小於主題delete.retention.ms設置的時間（默認值是24小時）到達日誌頭部，所有刪除標記都將被顯示。換句話說：因爲刪除標記的刪除與讀取同時發生，所以消費者可能錯過刪除標記，如果它滯後的話delete.retention.ms。

日誌壓縮細節

日誌壓縮是由日誌清理器處理的，日誌清理器是後臺線程池，用於重新記錄日誌段文件，刪除其日誌頭部出現的記錄。每個壓縮機線程的工作原理如下：

1. 它選擇日誌頭與日誌尾比率最高的日誌
2. 它爲日誌頭部中的每個鍵創建最後偏移的簡明摘要
3. 它從頭到尾複製日誌中的日誌，刪除日誌中稍後出現的日誌。新的，乾淨的段被立即交換到日誌中，所需的額外磁盤空間只是一個額外的日誌段（不是日誌的完整副本）。
4. 日誌頭的總結實質上只是一個空間緊湊的散列表。它每個條目使用正好24個字節。因此，使用8GB清理緩衝區時，一次清理迭代就可以清理大約366GB的日誌頭（假設有1K條消息）。

配置日誌清理器

日誌清理器默認是啓用的。這將啓動更乾淨的線程池。要在特定主題上啓用日誌清理，可以添加特定於日誌的屬性

1	log.cleanup.policy=compact

這可以在主題創建時或使用alter topic命令完成。

日誌清理器可以配置爲保留日誌的未壓縮“頭”的最小量。這是通過設置壓縮時間滯後來實現的。

1	log.cleaner.min.compaction.lag.ms

這可以用來防止比最小消息時間更新的消息被壓縮。如果沒有設置，除了最後一個段（即當前正在寫入的段）之外，所有日誌段都可以壓縮。即使所有消息都比最小壓縮時間滯後更早，活動段也不會被壓縮。

這裏 描述了更清潔的配置。

4.9配額

Kafka羣集有能力對請求執行配額以控制客戶端使用的代理資源。卡夫卡經紀人可以爲每組共享配額的客戶端實施兩種類型的客戶配額：

1. 網絡帶寬配額定義了字節率閾值（從0.9開始）
2. 請求速率配額將CPU利用率閾值定義爲網絡和I / O線程的百分比（自0.11開始）

爲什麼配額是必要的？

生產者和消費者有可能以非常高的速度生產/消費非常大量的數據或產生請求，從而壟斷經紀人資源，導致網絡飽和，並且通常會阻礙其他客戶和經紀人本身。擁有配額可以防範這些問題，而在大型多租戶羣集中，一小部分表現不佳的客戶端可能會降低用戶體驗良好的用戶體驗，這一點尤爲重要。事實上，當運行Kafka作爲一項服務時，甚至可以根據約定的合同強制執行A​​PI限制。

客戶羣

Kafka客戶端的身份是代表安全集羣中經過身份驗證的用戶的用戶主體。在支持未經身份驗證的客戶端的集羣中，用戶主體是由代理使用可配置選擇的未經身份驗證的用戶的分組PrincipalBuilder。Client-id是由客戶端應用程序選擇的具有有意義名稱的客戶端的邏輯分組。元組（user，client-id）定義了共享用戶主體和客戶機id的安全邏輯組的客戶機。

配額可以應用於（用戶，客戶端ID），用戶或客戶端組。對於給定的連接，將應用與連接匹配的最具體的配額。配額組的所有連接共享爲組配置的配額。例如，如果（user =“test-user”，client-id =“test-client”）的產品配額爲10MB / sec，則在用戶“test-user”的所有生產者實例中與客戶端 - ID“測試客戶端”。

配額配置

可以爲（用戶，客戶端ID），用戶和客戶端組定義配額配置。可以在任何需要更高（或更低）配額的配額級別上覆蓋默認配額。該機制類似於每個主題日誌配置覆蓋。用戶和（用戶，客戶端ID）配額覆蓋寫入/ config / users下的ZooKeeper ，客戶端配額覆蓋寫在/ config / clients下。這些覆蓋被所有經紀人讀取，並立即生效。這使我們可以更改配額，而無需執行整個羣集的滾動重新啓動。詳情請看這裏。每個組的默認配額也可以使用相同的機制動態更新。

配額配置的優先順序是：

1. /配置/用戶/ <用戶> /客戶端/ <客戶端ID>
2. /配置/用戶/ <用戶> /客戶端/ <默認>
3. /配置/用戶/ <用戶>
4. /配置/用戶/ <默認> /客戶端/ <客戶端ID>
5. /配置/用戶/ <默認> /客戶端/ <默認>
6. /配置/用戶/ <默認>
7. /配置/客戶端/ <客戶端ID>
8. /配置/客戶端/ <默認>

代理屬性（quota.producer.default，quota.consumer.default）也可用於爲客戶端組設置網絡帶寬配額的默認值。這些屬性已被棄用，將在以後的版本中刪除。客戶端ID的默認配額可以在Zookeeper中設置，類似於其他配額覆蓋和默認設置。

網絡帶寬配額

網絡帶寬配額定義爲每組共享配額的客戶端的字節速率閾值。默認情況下，每個唯一的客戶端組都會收到由羣集配置的固定配額（以字節/秒爲單位）。此配額是以每個經紀人爲基礎定義的。客戶端被限制之前，每個客戶端組可以發佈/獲取每個代理的最大X字節/秒。

請求率配額

請求率限額定義爲客戶端可以在請求處理程序的I / O線程和配額窗口內每個代理的網絡線程上使用的時間百分比。n％的配額代表 一個線程的n％，所以配額超出了（（num.io.threads + num.network.threads）* 100）％的總容量。每組客戶可以使用總共百分比高達n％在被限制之前在配額窗口中跨越所有I / O和網絡線程。由於爲I / O和網絡線程分配的線程數通常基於代理主機上可用的內核數，因此請求速率限額表示可由共享配額的每組客戶端使用的CPU的總百分比。

強制

默認情況下，每個唯一的客戶端組都會收到由羣集配置的固定配額。此配額是以每個經紀人爲基礎定義的。每個客戶可以在每個經紀人受到限制之前利用這個配額。我們認爲，爲每個代理定義這些配額比每個客戶端具有固定的羣集帶寬要好得多，因爲這需要一種機制來共享所有代理中的客戶端配額使用。這可能比配額實施本身更難得到！

經紀人在檢測到違反配額時會如何反應？在我們的解決方案中，代理不會返回錯誤，而是嘗試減慢超出配額的客戶端。它計算將有罪客戶限制在其配額之下所需的延遲時間，並延遲當時的迴應。這種方法使配額違反對客戶端透明（客戶端指標以外）。這也使他們不必執行任何特殊的退避和重試行爲，這可能會變得棘手。事實上，糟糕的客戶行爲（無退避的重試）可能會加劇配額試圖解決的問題。

字節率和線程利用率是在多個小窗口（例如每個窗口爲1秒的30個窗口）上測量的，以便快速檢測和糾正配額違規。通常，具有大的測量窗口（例如，每個30秒的10個窗口）導致大的突發流量，隨後的長時間延遲，在用戶體驗方面不太好。