亚洲欧美中文日韩在线,亚洲综合视频在线,性欧美18-19性猛交

Kafka簡介

Kafka是一種分布式的，基于發布/訂閱的消息系統。主要設計目標如下：

以時間復雜度為O(1)的方式提供消息持久化能力，即使對TB級以上數據也能保證常數時間的訪問性能

高吞吐率。即使在非常廉價的商用機器上也能做到單機支持每秒100K條消息的傳輸

支持Kafka Server間的消息分區，及分布式消費，同時保證每個partition內的消息順序傳輸

同時支持離線數據處理和實時數據處理

為什么要用消息系統

解耦
在項目啟動之初來預測將來項目會碰到什么需求，是極其困難的。消息隊列在處理過程中間插入了一個隱含的、基于數據的接口層，兩邊的處理過程都要實現這一接口。這允許你獨立的擴展或修改兩邊的處理過程，只要確保它們遵守同樣的接口約束

冗余
有些情況下，處理數據的過程會失敗。除非數據被持久化，否則將造成丟失。消息隊列把數據進行持久化直到它們已經被完全處理，通過這一方式規避了數據丟失風險。在被許多消息隊列所采用的”插入-獲取-刪除”范式中，在把一個消息從隊列中刪除之前，需要你的處理過程明確的指出該消息已經被處理完畢，確保你的數據被安全的保存直到你使用完畢。

擴展性
因為消息隊列解耦了你的處理過程，所以增大消息入隊和處理的頻率是很容易的；只要另外增加處理過程即可。不需要改變代碼、不需要調節參數。擴展就像調大電力按鈕一樣簡單。

靈活性 & 峰值處理能力
在訪問量劇增的情況下，應用仍然需要繼續發揮作用，但是這樣的突發流量并不常見；如果為以能處理這類峰值訪問為標準來投入資源隨時待命無疑是巨大的浪費。使用消息隊列能夠使關鍵組件頂住突發的訪問壓力，而不會因為突發的超負荷的請求而完全崩潰。

可恢復性
當體系的一部分組件失效，不會影響到整個系統。消息隊列降低了進程間的耦合度，所以即使一個處理消息的進程掛掉，加入隊列中的消息仍然可以在系統恢復后被處理。而這種允許重試或者延后處理請求的能力通常是造就一個略感不便的用戶和一個沮喪透頂的用戶之間的區別。

送達保證
消息隊列提供的冗余機制保證了消息能被實際的處理，只要一個進程讀取了該隊列即可。在此基礎上，IronMQ提供了一個”只送達一次”保證。無論有多少進程在從隊列中領取數據，每一個消息只能被處理一次。這之所以成為可能，是因為獲取一個消息只是”預定”了這個消息，暫時把它移出了隊列。除非客戶端明確的表示已經處理完了這個消息，否則這個消息會被放回隊列中去，在一段可配置的時間之后可再次被處理。

順序保證
在大多使用場景下，數據處理的順序都很重要。消息隊列本來就是排序的，并且能保證數據會按照特定的順序來處理。IronMO保證消息通過FIFO（先進先出）的順序來處理，因此消息在隊列中的位置就是從隊列中檢索他們的位置。

緩沖
在任何重要的系統中，都會有需要不同的處理時間的元素。例如,加載一張圖片比應用過濾器花費更少的時間。消息隊列通過一個緩沖層來幫助任務最高效率的執行—寫入隊列的處理會盡可能的快速，而不受從隊列讀的預備處理的約束。該緩沖有助于控制和優化數據流經過系統的速度。

理解數據流
在一個分布式系統里，要得到一個關于用戶操作會用多長時間及其原因的總體印象，是個巨大的挑戰。消息隊列通過消息被處理的頻率，來方便的輔助確定那些表現不佳的處理過程或領域，這些地方的數據流都不夠優化。

異步通信
很多時候，你不想也不需要立即處理消息。消息隊列提供了異步處理機制，允許你把一個消息放入隊列，但并不立即處理它。你想向隊列中放入多少消息就放多少，然后在你樂意的時候再去處理它們。

常用Message Queue對比

RabbitMQ
RabbitMQ是使用Erlang編寫的一個開源的消息隊列，本身支持很多的協議：AMQP，XMPP, SMTP, STOMP，也正因如此，它非常重量級，更適合于企業級的開發。同時實現了Broker構架，這意味著消息在發送給客戶端時先在中心隊列排隊。對路由，負載均衡或者數據持久化都有很好的支持。

Redis
Redis是一個基于Key-Value對的NoSQL數據庫，開發維護很活躍。雖然它是一個Key-Value數據庫存儲系統，但它本身支持MQ功能，所以完全可以當做一個輕量級的隊列服務來使用。對于RabbitMQ和Redis的入隊和出隊操作，各執行100萬次，每10萬次記錄一次執行時間。測試數據分為128Bytes、512Bytes、1K和10K四個不同大小的數據。實驗表明：入隊時，當數據比較小時Redis的性能要高于RabbitMQ，而如果數據大小超過了10K，Redis則慢的無法忍受；出隊時，無論數據大小，Redis都表現出非常好的性能，而RabbitMQ的出隊性能則遠低于Redis。

ZeroMQ
ZeroMQ號稱最快的消息隊列系統，尤其針對大吞吐量的需求場景。ZMQ能夠實現RabbitMQ不擅長的高級/復雜的隊列，但是開發人員需要自己組合多種技術框架，技術上的復雜度是對這MQ能夠應用成功的挑戰。ZeroMQ具有一個獨特的非中間件的模式，你不需要安裝和運行一個消息服務器或中間件，因為你的應用程序將扮演了這個服務角色。你只需要簡單的引用ZeroMQ程序庫，可以使用NuGet安裝，然后你就可以愉快的在應用程序之間發送消息了。但是ZeroMQ僅提供非持久性的隊列，也就是說如果宕機，數據將會丟失。其中，Twitter的Storm 0.9.0以前的版本中默認使用ZeroMQ作為數據流的傳輸（Storm從0.9版本開始同時支持ZeroMQ和Netty作為傳輸模塊）。

ActiveMQ
ActiveMQ是Apache下的一個子項目。類似于ZeroMQ，它能夠以代理人和點對點的技術實現隊列。同時類似于RabbitMQ，它少量代碼就可以高效地實現高級應用場景。

Kafka/Jafka
Kafka是Apache下的一個子項目，是一個高性能跨語言分布式發布/訂閱消息隊列系統，而Jafka是在Kafka之上孵化而來的，即Kafka的一個升級版。具有以下特性：快速持久化，可以在O(1)的系統開銷下進行消息持久化；高吞吐，在一臺普通的服務器上既可以達到10W/s的吞吐速率；完全的分布式系統，Broker、Producer、Consumer都原生自動支持分布式，自動實現負載均衡；支持Hadoop數據并行加載，對于像Hadoop的一樣的日志數據和離線分析系統，但又要求實時處理的限制，這是一個可行的解決方案。Kafka通過Hadoop的并行加載機制來統一了在線和離線的消息處理。Apache Kafka相對于ActiveMQ是一個非常輕量級的消息系統，除了性能非常好之外，還是一個工作良好的分布式系統。

Kafka解析

Terminology

Broker
Kafka集群包含一個或多個服務器，這種服務器被稱為broker

Topic
每條發布到Kafka集群的消息都有一個類別，這個類別被稱為topic。（物理上不同topic的消息分開存儲，邏輯上一個topic的消息雖然保存于一個或多個broker上但用戶只需指定消息的topic即可生產或消費數據而不必關心數據存于何處）

Partition
parition是物理上的概念，每個topic包含一個或多個partition，創建topic時可指定parition數量。每個partition對應于一個文件夾，該文件夾下存儲該partition的數據和索引文件

Producer
負責發布消息到Kafka broker

Consumer
消費消息。每個consumer屬于一個特定的consumer group（可為每個consumer指定group name，若不指定group name則屬于默認的group）。使用consumer high level API時，同一topic的一條消息只能被同一個consumer group內的一個consumer消費，但多個consumer group可同時消費這一消息。

Kafka架構

如上圖所示，一個典型的kafka集群中包含若干producer（可以是web前端產生的page view，或者是服務器日志，系統CPU、memory等），若干broker（Kafka支持水平擴展，一般broker數量越多，集群吞吐率越高），若干consumer group，以及一個Zookeeper集群。Kafka通過Zookeeper管理集群配置，選舉leader，以及在consumer group發生變化時進行rebalance。producer使用push模式將消息發布到broker，consumer使用pull模式從broker訂閱并消費消息。

Push vs. Pull

作為一個messaging system，Kafka遵循了傳統的方式，選擇由producer向broker push消息并由consumer從broker pull消息。一些logging-centric system，比如Facebook的Scribe和Cloudera的Flume,采用非常不同的push模式。事實上，push模式和pull模式各有優劣。
push模式很難適應消費速率不同的消費者，因為消息發送速率是由broker決定的。push模式的目標是盡可能以最快速度傳遞消息，但是這樣很容易造成consumer來不及處理消息，典型的表現就是拒絕服務以及網絡擁塞。而pull模式則可以根據consumer的消費能力以適當的速率消費消息。

Topic & Partition

Topic在邏輯上可以被認為是一個queue。每條消費都必須指定它的topic，可以簡單理解為必須指明把這條消息放進哪個queue里。為了使得Kafka的吞吐率可以水平擴展，物理上把topic分成一個或多個partition，每個partition在物理上對應一個文件夾，該文件夾下存儲這個partition的所有消息和索引文件。

每個日志文件都是“log entries”序列，每一個log entry包含一個4字節整型數（值為N），其后跟N個字節的消息體。每條消息都有一個當前partition下唯一的64字節的offset，它指明了這條消息的起始位置。磁盤上存儲的消息格式如下：
message length ： 4 bytes (value: 1+4+n)
“magic” value ： 1 byte
crc ： 4 bytes
payload ： n bytes
這個“log entries”并非由一個文件構成，而是分成多個segment，每個segment名為該segment第一條消息的offset和“.kafka”組成。另外會有一個索引文件，它標明了每個segment下包含的log entry的offset范圍，如下圖所示。

因為每條消息都被append到該partition中，是順序寫磁盤，因此效率非常高（經驗證，順序寫磁盤效率比隨機寫內存還要高，這是Kafka高吞吐率的一個很重要的保證）。

每一條消息被發送到broker時，會根據paritition規則選擇被存儲到哪一個partition。如果partition規則設置的合理，所有消息可以均勻分布到不同的partition里，這樣就實現了水平擴展。（如果一個topic對應一個文件，那這個文件所在的機器I/O將會成為這個topic的性能瓶頸，而partition解決了這個問題）。在創建topic時可以在$KAFKA_HOME/config/server.properties中指定這個partition的數量(如下所示)，當然也可以在topic創建之后去修改parition數量。

# The default number of log partitions per topic. More partitions allow greater
# parallelism for consumption, but this will also result in more files across
# the brokers.
num.partitions=3

在發送一條消息時，可以指定這條消息的key，producer根據這個key和partition機制來判斷將這條消息發送到哪個parition。paritition機制可以通過指定producer的paritition. class這一參數來指定，該class必須實現kafka.producer.Partitioner接口。本例中如果key可以被解析為整數則將對應的整數與partition總數取余，該消息會被發送到該數對應的partition。（每個parition都會有個序號）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

importkafka.producer.Partitioner;
importkafka.utils.VerifiableProperties;
publicclassJasonPartitionerimplementsPartitioner {
publicJasonPartitioner(VerifiableProperties verifiableProperties) {}
@Override
publicintpartition(Object key,intnumPartitions) {
try{
intpartitionNum = Integer.parseInt((String) key);
returnMath.abs(Integer.parseInt((String) key) % numPartitions);
}catch(Exception e) {
returnMath.abs(key.hashCode() % numPartitions);
}
}
}

并通過如下代碼發送20條消息（key分別為0，1，2，3）至topic2（包含4個partition）。

1
2
3
4
5
6
7
8
9
10

publicvoidsendMessage()throwsInterruptedException{
for(inti =1; i <=?5; i++){
List messageList =newArrayList>();
for(intj =0; j messageList.add(newKeyedMessage("topic2", j+"","The "+ i +" message for key "+ j));
}
producer.send(messageList);
}
producer.close();
}

則key相同的消息會被發送并存儲到同一個partition里，而且key的序號正好和partition序號相同。（partition序號從0開始，本例中的key也正好從0開始）。如下圖所示。

對于傳統的message queue而言，一般會刪除已經被消費的消息，而Kafka集群會保留所有的消息，無論其被消費與否。當然，因為磁盤限制，不可能永久保留所有數據（實際上也沒必要），因此Kafka提供兩種策略去刪除舊數據。一是基于時間，二是基于partition文件大小。例如可以通過配置$KAFKA_HOME/config/server.properties，讓Kafka刪除一周前的數據，也可通過配置讓Kafka在partition文件超過1GB時刪除舊數據，如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

############################# Log Retention Policy #############################
# The following configurations control the disposal of log segments. The policy can
# be set to delete segments after a period of time, or after a given size has accumulated.
# A segment will be deleted whenever *either* of these criteria are met. Deletion always happens
# from the end of the log.
# The minimum age of a log file to be eligiblefordeletion
log.retention.hours=168
# A size-based retention policyforlogs. Segments are pruned from the log aslongas the remaining
# segments don't drop below log.retention.bytes.
#log.retention.bytes=1073741824
# The maximum size of a log segment file. Whenthissize is reached anewlog segment will be created.
log.segment.bytes=1073741824
# The interval at which log segments are checked to seeifthey can be deleted according
# to the retention policies
log.retention.check.interval.ms=300000
# Bydefaultthe log cleaner is disabled and the log retention policy willdefaultto
#just delete segments after their retention expires.
# If log.cleaner.enable=trueis set the cleaner will be enabled and individual logs
#can then be markedforlog compaction.
log.cleaner.enable=false

這里要注意，因為Kafka讀取特定消息的時間復雜度為O(1)，即與文件大小無關，所以這里刪除文件與Kafka性能無關，選擇怎樣的刪除策略只與磁盤以及具體的需求有關。另外，Kafka會為每一個consumer group保留一些metadata信息—當前消費的消息的position，也即offset。這個offset由consumer控制。正常情況下consumer會在消費完一條消息后線性增加這個offset。當然，consumer也可將offset設成一個較小的值，重新消費一些消息。因為offet由consumer控制，所以Kafka broker是無狀態的，它不需要標記哪些消息被哪些consumer過，不需要通過broker去保證同一個consumer group只有一個consumer能消費某一條消息，因此也就不需要鎖機制，這也為Kafka的高吞吐率提供了有力保障。

Replication & Leader election

Kafka從0.8開始提供partition級別的replication，replication的數量可在$KAFKA_HOME/config/server.properties中配置。

1	default.replication.factor =1

該 Replication與leader election配合提供了自動的failover機制。replication對Kafka的吞吐率是有一定影響的，但極大的增強了可用性。默認情況下，Kafka的replication數量為1。每個partition都有一個唯一的leader，所有的讀寫操作都在leader上完成，leader批量從leader上pull數據。一般情況下partition的數量大于等于broker的數量，并且所有partition的leader均勻分布在broker上。follower上的日志和其leader上的完全一樣。和大部分分布式系統一樣，Kakfa處理失敗需要明確定義一個broker是否alive。對于Kafka而言，Kafka存活包含兩個條件，一是它必須維護與Zookeeper的session(這個通過Zookeeper的heartbeat機制來實現)。二是follower必須能夠及時將leader的writing復制過來，不能“落后太多”。
leader會track“in sync”的node list。如果一個follower宕機，或者落后太多，leader將把它從”in sync” list中移除。這里所描述的“落后太多”指follower復制的消息落后于leader后的條數超過預定值，該值可在$KAFKA_HOME/config/server.properties中配置

1
2
3
4
5

#If a replica falls more thanthismany messages behind the leader, the leader will remove the follower from ISR and treat it as dead
replica.lag.max.messages=4000
#If a follower hasn't sent any fetch requestsforthiswindow of time, the leader will remove the follower from ISR (in-sync replicas) and treat it as dead
replica.lag.time.max.ms=10000

需要說明的是，Kafka只解決”fail/recover”，不處理“Byzantine”（“拜占庭”）問題。
一條消息只有被“in sync” list里的所有follower都從leader復制過去才會被認為已提交。這樣就避免了部分數據被寫進了leader，還沒來得及被任何follower復制就宕機了，而造成數據丟失（consumer無法消費這些數據）。而對于producer而言，它可以選擇是否等待消息commit，這可以通過request.required.acks來設置。這種機制確保了只要“in sync” list有一個或以上的flollower，一條被commit的消息就不會丟失。
這里的復制機制即不是同步復制，也不是單純的異步復制。事實上，同步復制要求“活著的”follower都復制完，這條消息才會被認為commit，這種復制方式極大的影響了吞吐率（高吞吐率是Kafka非常重要的一個特性）。而異步復制方式下，follower異步的從leader復制數據，數據只要被leader寫入log就被認為已經commit，這種情況下如果follwer都落后于leader，而leader突然宕機，則會丟失數據。而Kafka的這種使用“in sync” list的方式則很好的均衡了確保數據不丟失以及吞吐率。follower可以批量的從leader復制數據，這樣極大的提高復制性能（批量寫磁盤），極大減少了follower與leader的差距（前文有說到，只要follower落后leader不太遠，則被認為在“in sync” list里）。

上文說明了Kafka是如何做replication的，另外一個很重要的問題是當leader宕機了，怎樣在follower中選舉出新的leader。因為follower可能落后許多或者crash了，所以必須確保選擇“最新”的follower作為新的leader。一個基本的原則就是，如果leader不在了，新的leader必須擁有原來的leader commit的所有消息。這就需要作一個折衷，如果leader在標明一條消息被commit前等待更多的follower確認，那在它die之后就有更多的follower可以作為新的leader，但這也會造成吞吐率的下降。
一種非常常用的選舉leader的方式是“majority vote”（“少數服從多數”），但Kafka并未采用這種方式。這種模式下，如果我們有2f+1個replica（包含leader和follower），那在commit之前必須保證有f+1個replica復制完消息，為了保證正確選出新的leader，fail的replica不能超過f個。因為在剩下的任意f+1個replica里，至少有一個replica包含有最新的所有消息。這種方式有個很大的優勢，系統的latency只取決于最快的幾臺server，也就是說，如果replication factor是3，那latency就取決于最快的那個follower而非最慢那個。majority vote也有一些劣勢，為了保證leader election的正常進行，它所能容忍的fail的follower個數比較少。如果要容忍1個follower掛掉，必須要有3個以上的replica，如果要容忍2個follower掛掉，必須要有5個以上的replica。也就是說，在生產環境下為了保證較高的容錯程度，必須要有大量的replica，而大量的replica又會在大數據量下導致性能的急劇下降。這就是這種算法更多用在Zookeeper這種共享集群配置的系統中而很少在需要存儲大量數據的系統中使用的原因。例如HDFS的HA feature是基于majority-vote-based journal，但是它的數據存儲并沒有使用這種expensive的方式。
實際上，leader election算法非常多，比如Zookeper的Zab,Raft和Viewstamped Replication。而Kafka所使用的leader election算法更像微軟的PacificA算法。
Kafka在Zookeeper中動態維護了一個ISR（in-sync replicas） set，這個set里的所有replica都跟上了leader，只有ISR里的成員才有被選為leader的可能。在這種模式下，對于f+1個replica，一個Kafka topic能在保證不丟失已經ommit的消息的前提下容忍f個replica的失敗。在大多數使用場景中，這種模式是非常有利的。事實上，為了容忍f個replica的失敗，majority vote和ISR在commit前需要等待的replica數量是一樣的，但是ISR需要的總的replica的個數幾乎是majority vote的一半。
雖然majority vote與ISR相比有不需等待最慢的server這一優勢，但是Kafka作者認為Kafka可以通過producer選擇是否被commit阻塞來改善這一問題，并且節省下來的replica和磁盤使得ISR模式仍然值得。

上文提到，在ISR中至少有一個follower時，Kafka可以確保已經commit的數據不丟失，但如果某一個partition的所有replica都掛了，就無法保證數據不丟失了。這種情況下有兩種可行的方案：

等待ISR中的任一個replica“活”過來，并且選它作為leader

選擇第一個“活”過來的replica（不一定是ISR中的）作為leader

這就需要在可用性和一致性當中作出一個簡單的平衡。如果一定要等待ISR中的replica“活”過來，那不可用的時間就可能會相對較長。而且如果ISR中的所有replica都無法“活”過來了，或者數據都丟失了，這個partition將永遠不可用。選擇第一個“活”過來的replica作為leader，而這個replica不是ISR中的replica，那即使它并不保證已經包含了所有已commit的消息，它也會成為leader而作為consumer的數據源（前文有說明，所有讀寫都由leader完成）。Kafka0.8.*使用了第二種方式。根據Kafka的文檔，在以后的版本中，Kafka支持用戶通過配置選擇這兩種方式中的一種，從而根據不同的使用場景選擇高可用性還是強一致性。

上文說明了一個parition的replication過程，然爾Kafka集群需要管理成百上千個partition，Kafka通過round-robin的方式來平衡partition從而避免大量partition集中在了少數幾個節點上。同時Kafka也需要平衡leader的分布，盡可能的讓所有partition的leader均勻分布在不同broker上。另一方面，優化leadership election的過程也是很重要的，畢竟這段時間相應的partition處于不可用狀態。一種簡單的實現是暫停宕機的broker上的所有partition，并為之選舉leader。實際上，Kafka選舉一個broker作為controller，這個controller通過watch Zookeeper檢測所有的broker failure，并負責為所有受影響的parition選舉leader，再將相應的leader調整命令發送至受影響的broker，過程如下圖所示。

這樣做的好處是，可以批量的通知leadership的變化，從而使得選舉過程成本更低，尤其對大量的partition而言。如果controller失敗了，幸存的所有broker都會嘗試在Zookeeper中創建/controller->{this broker id}，如果創建成功（只可能有一個創建成功），則該broker會成為controller，若創建不成功，則該broker會等待新controller的命令。

Consumer group

（本節所有描述都是基于consumer hight level API而非low level API）。
每一個consumer實例都屬于一個consumer group，每一條消息只會被同一個consumer group里的一個consumer實例消費。（不同consumer group可以同時消費同一條消息）

很多傳統的message queue都會在消息被消費完后將消息刪除，一方面避免重復消費，另一方面可以保證queue的長度比較少，提高效率。而如上文所將，Kafka并不刪除已消費的消息，為了實現傳統message queue消息只被消費一次的語義，Kafka保證保證同一個consumer group里只有一個consumer會消費一條消息。與傳統message queue不同的是，Kafka還允許不同consumer group同時消費同一條消息，這一特性可以為消息的多元化處理提供了支持。實際上，Kafka的設計理念之一就是同時提供離線處理和實時處理。根據這一特性，可以使用Storm這種實時流處理系統對消息進行實時在線處理，同時使用Hadoop這種批處理系統進行離線處理，還可以同時將數據實時備份到另一個數據中心，只需要保證這三個操作所使用的consumer在不同的consumer group即可。下圖展示了Kafka在Linkedin的一種簡化部署。

為了更清晰展示Kafka consumer group的特性，筆者作了一項測試。創建一個topic (名為topic1)，創建一個屬于group1的consumer實例，并創建三個屬于group2的consumer實例，然后通過producer向topic1發送key分別為1，2，3r的消息。結果發現屬于group1的consumer收到了所有的這三條消息，同時group2中的3個consumer分別收到了key為1，2，3的消息。如下圖所示。

Consumer Rebalance

（本節所講述內容均基于Kafka consumer high level API）
Kafka保證同一consumer group中只有一個consumer會消費某條消息，實際上，Kafka保證的是穩定狀態下每一個consumer實例只會消費某一個或多個特定partition的數據，而某個partition的數據只會被某一個特定的consumer實例所消費。這樣設計的劣勢是無法讓同一個consumer group里的consumer均勻消費數據，優勢是每個consumer不用都跟大量的broker通信，減少通信開銷，同時也降低了分配難度，實現也更簡單。另外，因為同一個partition里的數據是有序的，這種設計可以保證每個partition里的數據也是有序被消費。
如果某consumer group中consumer數量少于partition數量，則至少有一個consumer會消費多個partition的數據，如果consumer的數量與partition數量相同，則正好一個consumer消費一個partition的數據，而如果consumer的數量多于partition的數量時，會有部分consumer無法消費該topic下任何一條消息。
如下例所示，如果topic1有0，1，2共三個partition，當group1只有一個consumer(名為consumer1)時，該 consumer可消費這3個partition的所有數據。