Kafka在0.10.0.0版本以前的定位是分散式，分割槽化的，帶備份機制的日誌提交服務。而kafka在這之前也沒有提供資料處理的顧服務。大家的流處理計算主要是還是依賴於Storm，Spark Streaming，Flink等流式處理框架。

Storm，Spark Streaming，Flink流處理的三駕馬車各有各的優勢.

Storm低延遲，並且在市場中佔有一定的地位，目前很多公司仍在使用。

Spark Streaming藉助Spark的體系優勢，活躍的社群，也佔有一定的份額。

而Flink在設計上更貼近流處理，並且有便捷的API，未來一定很有發展。

但是他們都離不開Kafka的訊息中轉，所以Kafka於0.10.0.0版本推出了自己的流處理框架，Kafka Streams。Kafka的定位也正式成為Apache Kafka® is a distributed streaming platform，

分散式流處理平臺。

實時流式計算

近幾年來實時流式計算髮展迅速，主要原因是實時資料的價值和對於資料處理架構體系的影響。實時流式計算包含了 無界資料 近實時 一致性 可重複結果 等等特徵。a type of data processing engine that is designed with infinite data sets in mind 一種考慮了無線資料集的資料處理引擎。

1、無限資料：一種不斷增長的，基本上無限的資料集。這些通常被稱為“流式資料”。無限的流式資料集可以稱為無界資料，相對而言有限的批量資料就是有界資料。

2、無界資料處理：一種持續的資料處理模式，應用於上面的無界資料。批量處理資料（離線計算）也可以重複執行來處理資料，但是會有效能的瓶頸。

3、低延遲，近實時的結果：相對於離線計算而言，離線計算並沒有考慮延遲的問題。

解決了兩個問題，流處理可以提代批處理系統：

1、正確性：有了這個，就和批量計算等價了。

Streaming需要能隨著時間的推移依然能計算一定時間視窗的資料。Spark Streaming通過微批的思想解決了這個問題，實時與離線系統進行了一致性的儲存，這一點在未來的實時計算系統中都應該滿足。

2、推理時間的工具：這可以讓我們超越批量計算。

好的時間推理工具對於處理不同事件的無界無序資料至關重要。

而時間又分為事件時間和處理時間。

還有很多實時流式計算的相關概念，這裡不做贅述。

Kafka Streams簡介

Kafka Streams被認為是開發實時應用程式的最簡單方法。它是一個Kafka的客戶端API庫，編寫簡單的java和scala程式碼就可以實現流式處理。

優勢：

• 彈性，高度可擴充套件，容錯

• 部署到容器，VM，裸機，雲

• 同樣適用於小型，中型和大型用例

• 與Kafka安全性完全整合
• 編寫標準Java和Scala應用程式

• 在Mac，Linux，Windows上開發

• Exactly-once 語義

用例：

紐約時報使用Apache Kafka和Kafka Streams將釋出的內容實時儲存和分發到各種應用程式和系統，以供讀者使用。

Pinterest大規模使用Apache Kafka和Kafka Streams來支援其廣告基礎架構的實時預測預算系統。使用Kafka Streams，預測比以往更準確。

作為歐洲領先的線上時尚零售商，Zalando使用Kafka作為ESB（企業服務匯流排），幫助我們從單一服務架構轉變為微服務架構。使用Kafka處理 事件流使我們的技術團隊能夠實現近乎實時的商業智慧。

荷蘭合作銀行是荷蘭三大銀行之一。它的數字神經系統Business Event Bus由Apache Kafka提供支援。它被越來越多的財務流程和服務所使用，其中之一就是Rabo Alerts。此服務會在財務事件時實時向客戶發出警報，並使用Kafka Streams構建。

LINE使用Apache Kafka作為我們服務的中央資料庫，以便彼此通訊。每天產生數億億條訊息，用於執行各種業務邏輯，威脅檢測，搜尋索引和資料分析。LINE利用Kafka Streams可靠地轉換和過濾主題，使消費者可以有效消費的子主題，同時由於其複雜而簡單的程式碼庫，保持易於維護性。

Topology

Kafka Streams通過一個或多個拓撲定義其計算邏輯，其中拓撲是通過流（邊緣）和流處理器（節點）構成的圖。

拓撲中有兩種特殊的處理器

• 源處理器：源處理器是一種特殊型別的流處理器，沒有任何上游處理器。它通過使用來自這些主題的記錄並將它們轉發到其下游處理器，從一個或多個Kafka主題為其拓撲生成輸入流。
• 接收器處理器：接收器處理器是一種特殊型別的流處理器，沒有下游處理器。它將從其上游處理器接收的任何記錄傳送到指定的Kafka主題。

在正常處理器節點中，還可以把資料發給遠端系統。因此，處理後的結果可以流式傳輸回Kafka或寫入外部系統。

Kafka在這當中提供了最常用的資料轉換操作，例如map，filter，join和aggregations等，簡單易用。

當然還有一些關於時間，視窗，聚合，亂序處理等。未來再一一做詳細介紹，下面我們進行簡單的入門案例開發。

快速入門

首先提供WordCount的java版和scala版本。

java8+：

import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.common.utils.Bytes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.KTable;
import org.apache.kafka.streams.kstream.Materialized;
import org.apache.kafka.streams.kstream.Produced;
import org.apache.kafka.streams.state.KeyValueStore;
 
import java.util.Arrays;
import java.util.Properties;
 
public class WordCountApplication {
 
    public static void main(final String[] args) throws Exception {
        Properties props = new Properties();
        props.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application");
        props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-broker1:9092");
        props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
 
        StreamsBuilder builder = new StreamsBuilder();
        KStream<String, String> textLines = builder.stream("TextLinesTopic");
        KTable<String, Long> wordCounts = textLines
            .flatMapValues(textLine -> Arrays.asList(textLine.toLowerCase().split("\\W+")))
            .groupBy((key, word) -> word)
            .count(Materialized.<String, Long, KeyValueStore<Bytes, byte[]>>as("counts-store"));
        wordCounts.toStream().to("WordsWithCountsTopic", Produced.with(Serdes.String(), Serdes.Long()));
 
        KafkaStreams streams = new KafkaStreams(builder.build(), props);
        streams.start();
    }
 
}

scala：

import java.util.Properties
import java.util.concurrent.TimeUnit
 
import org.apache.kafka.streams.kstream.Materialized
import org.apache.kafka.streams.scala.ImplicitConversions._
import org.apache.kafka.streams.scala._
import org.apache.kafka.streams.scala.kstream._
import org.apache.kafka.streams.{KafkaStreams, StreamsConfig}
 
object WordCountApplication extends App {
  import Serdes._
 
  val props: Properties = {
    val p = new Properties()
    p.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application")
    p.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-broker1:9092")
    p
  }
 
  val builder: StreamsBuilder = new StreamsBuilder
  val textLines: KStream[String, String] = builder.stream[String, String]("TextLinesTopic")
  val wordCounts: KTable[String, Long] = textLines
    .flatMapValues(textLine => textLine.toLowerCase.split("\\W+"))
    .groupBy((_, word) => word)
    .count()(Materialized.as("counts-store"))
  wordCounts.toStream.to("WordsWithCountsTopic")
 
  val streams: KafkaStreams = new KafkaStreams(builder.build(), props)
  streams.start()
 
  sys.ShutdownHookThread {
     streams.close(10, TimeUnit.SECONDS)
  }
}

如果kafka已經啟動了，可以跳過前兩步。

1、下載

下載 2.3.0版本並解壓縮它。請注意，有多個可下載的Scala版本，我們選擇使用推薦的版本（2.12）：

> tar -xzf kafka_2.12-2.3.0.tgz
> cd kafka_2.12-2.3.0

2、啟動

Kafka使用ZooKeeper，因此如果您還沒有ZooKeeper伺服器，則需要先啟動它。

> bin/zookeeper-server-start.sh config/zookeeper.properties
[2013-04-22 15:01:37,495] INFO Reading configuration from: config/zookeeper.properties (org.apache.zookeeper.server.quorum.QuorumPeerConfig)
...

啟動Kafka伺服器：

> bin/kafka-server-start.sh config/server.properties
[2013-04-22 15:01:47,028] INFO Verifying properties (kafka.utils.VerifiableProperties)
[2013-04-22 15:01:47,051] INFO Property socket.send.buffer.bytes is overridden to 1048576 (kafka.utils.VerifiableProperties)
...

3、建立topic 啟動生產者

我們建立名為streams-plaintext-input的輸入主題和名為streams-wordcount-output的輸出主題：

> bin/kafka-topics.sh --create \
    --bootstrap-server localhost:9092 \
    --replication-factor 1 \
    --partitions 1 \
    --topic streams-plaintext-input
Created topic "streams-plaintext-input".


> bin/kafka-topics.sh --create \
    --bootstrap-server localhost:9092 \
    --replication-factor 1 \
    --partitions 1 \
    --topic streams-wordcount-output \
    --config cleanup.policy=compact
Created topic "streams-wordcount-output".

檢視：

> bin/kafka-topics.sh --bootstrap-server localhost:9092 --describe
 
Topic:streams-plaintext-input   PartitionCount:1    ReplicationFactor:1 Configs:
    Topic: streams-plaintext-input  Partition: 0    Leader: 0   Replicas: 0 Isr: 0
Topic:streams-wordcount-output  PartitionCount:1    ReplicationFactor:1 Configs:cleanup.policy=compact
    Topic: streams-wordcount-output Partition: 0    Leader: 0   Replicas: 0 Isr: 0

4、啟動WordCount

以下命令啟動WordCount演示應用程式：

> bin/kafka-run-class.sh org.apache.kafka.streams.examples.wordcount.WordCountDemo

演示應用程式將從輸入主題stream-plaintext-input讀取，對每個讀取訊息執行WordCount演算法的計算，並連續將其當前結果寫入輸出主題streams-wordcount-output。因此，除了日誌條目之外不會有任何STDOUT輸出，因為結果會寫回Kafka。

現在我們可以在一個單獨的終端中啟動控制檯生成器，為這個主題寫一些輸入資料：

> bin/kafka-console-producer.sh --broker-list localhost:9092 --topic streams-plaintext-input

並通過在單獨的終端中使用控制檯使用者讀取其輸出主題來檢查WordCount演示應用程式的輸出：

> bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 \
    --topic streams-wordcount-output \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer

5、處理資料

我們在生產者端輸入一些資料。

> bin/kafka-console-producer.sh --broker-list localhost:9092 --topic streams-plaintext-input
all streams lead to kafka

輸出端：

> bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 \
    --topic streams-wordcount-output \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer
 
all     1
streams 1
lead    1
to      1
kafka   1

繼續輸入：

> bin/kafka-console-producer.sh --broker-list localhost:9092 --topic streams-plaintext-input
all streams lead to kafka
hello kafka streams

> bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 \
    --topic streams-wordcount-output \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer
 
all     1
streams 1
lead    1
to      1
kafka   1
hello   1
kafka   2
streams 2

我們看到隨著資料實時輸入，wordcount的結果實時的輸出了。

6、停止程式

您現在可以通過Ctrl-C按順序停止控制檯使用者，控制檯生產者，Wordcount應用程式，Kafka代理和ZooKeeper伺服器。

什麼是Kafka？
Kafka監控工具彙總
Kafka快速入門
Kafka核心之Consumer
Kafka核心之Producer

替代Flume——Kafka Connect簡介

更多實時計算,Flink,Kafka等相關技術博文，歡迎關注實時流式計算

相關推薦