Kafka Streams 在監控場景的應用與實踐

作者：Pang Haiyun 2024-12-19 09:45:24

介紹 Kafka Streams 的原理架構，常見配置以及在監控場景的應用。

一、背景

在當今大數據時代，實時數據處理變得越來越重要，而監控數據的實時性和可靠性是監控能力建設最重要的一環。隨著監控業務需求的變化和技術的發展，需要能夠實時處理和分析龐大的數據流。作為一種流式處理平臺，Kafka Streams 為處理實時數據提供了強大的支持。本文將重點介紹如何利用 Kafka Streams 進行實時數據處理，包括其基本原理、功能和實際應用。通過本文的學習，讀者將能夠深入了解 Kafka Streams 的優勢、在監控場景的應用及實踐。

二、Kafka Streams 的基本概念

Kafka Streams 是一個開源的流式處理框架，基于 Kafka 消息隊列構建，能夠處理無限量的數據流。與傳統的批處理不同，Kafka Streams 允許用戶以流式處理的方式實時處理數據，而且處理延遲僅為毫秒級。

通過 Kafka Streams ，用戶可以進行數據的實時轉換、聚合、過濾等操作，同時能夠與 Kafka Connect 和 Kafka Producer/Consumer 無縫集成。Kafka Streams 也是一個客戶端程序庫，用于處理和分析存儲在 Kafka 中的數據，并將得到的數據寫回 Kafka 或發送到外部系統。

Kafka、Storm、Flink 和 Spark 是大數據領域常用的工具和框架。

1、區別

Kafka 是一個分布式消息系統，主要用于構建實時數據管道和事件驅動的應用程序。它提供了高吞吐量、持久性、可伸縮性和容錯性，主要用于數據的發布和訂閱。
Storm 是一個分布式實時計算系統，用于處理實時數據流。它提供了低延遲、高吞吐量的實時計算能力，適用于實時數據處理和流式計算。
Flink 是一個流處理引擎，提供了精確一次的狀態處理和事件時間處理等特性。它支持流處理和批處理，并提供了統一的 API 和運行時環境。
Spark 是一個通用的大數據處理框架，提供了批處理和流處理的功能。Spark 提供了豐富的數據處理和計算功能，包括 SQL 查詢、機器學習、圖處理等。

2、Kafka 的優勢

持久性和可靠性：Kafka 提供了數據持久化的功能，能夠確保數據不丟失，并且支持數據的持久存儲和重放。
可伸縮性：Kafka 集群可以很容易地進行水平擴展，支持大規模數據處理和高并發訪問。
靈活性：Kafka 可以與各種不同的數據處理框架集成，作為數據源或數據目的地，使其在實時數據處理的場景中具有廣泛的適用性。

總的來說，Kafka 的優勢在于其高吞吐量、持久性和可靠性，以及靈活的集成能力，使其成為構建實時數據管道和事件驅動應用程序的理想選擇。

2.1 Stream 處理拓撲

2.1.1 流

流是 Kafka Streams 提出的最重要的抽象概念：它表示一個無限的，不斷更新的數據集。流是一個有序的，可重放（反復的使用），不可變的容錯序列，數據記錄的格式是鍵值對（key-value）。這里的 key 主要記錄的是 value 的索引，決定了 Kafka 和 Kafka Streams 中數據的分區，即數據如何路由到 Topic 的特定分區。value 是主要后續處理器要處理的數據。

2.1.2 處理器拓撲

處理器拓撲是一個由流（邊緣）連接的流處理（節點）的圖。通過 Kafka Streams ，我們可以編寫一個或多個的計算邏輯的處理器拓撲，用于對數據進行多步驟的處理。

2.1.3 流處理器

流處理器是處理器拓撲中的一個節點；它表示一個處理的步驟，用來轉換流中的數據（從拓撲中的上游處理器一次接受一個輸入消息，并且隨后產生一個或多個輸出消息到其下游處理器中）。

在拓撲中有兩個特別的處理器：

源處理器（Source Processor）：源處理器是一個沒有任何上游處理器的特殊類型的流處理器。它從一個或多個 Kafka 主題生成輸入流。通過消費這些主題的消息并將它們轉發到下游處理器。
sink 處理器（Sink Processor）：sink 處理器是一個沒有下游流處理器的特殊類型的流處理器。它接收上游流處理器的消息發送到一個指定的 Kafka 主題。

(圖片來源: Kafka 官網)

Kafka Streams 提供2種方式來定義流處理器拓撲：Kafka Streams DSL 提供了更常用的數據轉換操作，如 map 和 filter；低級別 Processor API 允許開發者定義和連接自定義的處理器，以及和狀態倉庫交互。處理器拓撲僅僅是流處理代碼的邏輯抽象。

2.2 時間

在流處理方面有一些重要的時間概念，它們是建模和集成一些操作的重要元素，例如定義窗口的時間界限。

時間在流中的常見概念如下：

事件時間 - 當一個事件或數據記錄發生的時間點，就是最初創建的“源頭”。
處理時間 - 事件或數據消息發生在流處理應用程序處理的時間點。即，記錄已被消費。處理時間可能是毫秒，小時，或天等。比原始事件時間要晚。
攝取時間 - 事件或數據記錄是 Kafka broker 存儲在 topic 分區的時間點。與事件時間的差異是，當記錄由 Kafka broker 追加到目標 topic 時，生成的攝取時間戳，而不是消息創建時間（“源頭”）。與處理時間的差異是處理時間是流處理應用處理記錄時的時間。比如，如果一個記錄從未被處理，那么就沒有處理時間，但仍然有攝取時間。

Kafka Streams 通過 TimestampExtractor 接口為每個數據記錄分配一個時間戳。該接口的具體實現了基于數據記錄的實際內容檢索或計算獲得時間戳，例如嵌入時間戳字段提供的事件時間語義，或使用其他的方法，比如在處理時返回當前的 wall-clock（墻鐘）時間，從而產生了流應用程序的處理時間語義。因此開發者可以根據自己的業務需要選擇執行不同的時間。例如，每條記錄時間戳描述了流的時間增長（盡管記錄在 stream 中是無序的）并利用時間依賴性來操作，如 join。

最后，當一個 Kafka Streams 應用程序寫入記錄到 Kafka 時，它將分配時間戳到新的消息。時間戳分配的方式取決于上下文：

當通過處理一些輸入記錄（例如，在 process()函數調用中觸發的 context.forward()）生成新的輸出記錄時，輸出記錄時間戳直接從輸入記錄時間戳繼承。
當通過周期性函數（如 punctuate()）生成新的輸出記錄時。輸出記錄時間戳被定義為流任務的當前內部時間（通過 context.timestamp() 獲取）。
對于聚合，生成的聚合更新的記錄時間戳將被最新到達的輸入記錄觸發更新。

本部分簡要介紹了 Kafka Streams 的基本概念，下一部分將介紹 Kafka Streams 的在監控場景的應用實踐。

三、Kafka Streams 在監控場景的應用

3.1 鏈路分布示意圖

3.2 示例：使用 Kafka Streams 來處理實時數據

流式處理引擎（如 Kafka Streams）與監控數據 ETL 可以為業務運維帶來諸多好處，例如實時數據分析、實時監控、事件驅動的架構等。在本部分，我們將重點介紹 Kafka Streams 與監控數據 ETL 的集成，以及如何在監控數據 ETL 中利用 Kafka Streams 進行實時數據處理。

在監控數據ETL架構中，Kafka Streams 扮演著舉足輕重的角色。它可以作為一個獨立的數據處理服務來處理實時的數據流，并將處理結果輸出到其他存儲組件（例如，ES、VM等）中。同時，它也可以作為多個數據源之間的數據交換和通信的橋梁，扮演著數據總線的角色。Kafka Streams 的高可用性、高吞吐量和流式處理能力使得它成為監控數據ETL架構中的重要組件之一。

下面給出一個示例，演示了如何將 Kafka Streams 作為監控數據 ETL 來處理實時的數據。假設我們有一個監控數據流 TopicA，我們希望對這些數據進行實時的分析，并將分析結果輸出到另一個 TopicB。我們可以創建一個 Kafka Streams 來處理這個需求：

//創建配置類
Properties props = new Properties();
//設置訂閱者
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "stream-processing-service");
//設置servers地址
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-broker1:9092");
 
StreamsBuilder builder = new StreamsBuilder();
//構建流
KStream<String, String> userActions = builder.stream("TopicA");
//對流進行處理
KTable<String, Long> userClickCounts = userActions
 
    .filter((key, value) -> value.contains("click"))
 
    .groupBy((key, value) -> value.split(":")[0])
 
    .count();
//流寫回Kafka
userClickCounts.toStream().to("TopicB", Produced.with(Serdes.String(), Serdes.Long()));
 
KafkaStreams streams = new KafkaStreams(builder.build(), props);
 
streams.start();

在這個示例中，我們創建了一個 Kafka Streams 監控數據 ETL，用于處理實時的監控數據流。它對數據進行了過濾、分組和統計分析，并將結果輸出到 TopicB。通過這個 ETL，我們可以很容易地實現實時的數據處理功能，并且能夠與其他數據源和數據存儲組件進行無縫的集成。

3.3 監控 ETL 的流處理示意圖

本部分介紹了 Kafka Streams 的在監控場景的應用實踐，下一部分將深入探討 Kafka Streams 的運作原理及實時數據處理的常見操作，并闡述 Kafka Streams 如何實現這些操作。

四、監控數據 ETL 中 Kafka Streams 的運作原理

4.1 架構

Kafka Streams 通過生產者和消費者，并利用 Kafka 自有的能力來提供數據平行性，分布式協調性，故障容錯和操作簡單性，從而簡化了應用程序的開發，在本節中，我們將描述 Kafka Streams 是如何工作的。

下圖展示了 Kafka Streams 應用程序的解剖圖，讓我們來看一下。

圖片來源: Kafka 官網

Kafka 消費者通過消費1個或多個 Topic 拿到數據，形成輸入 Kafka 流，經過處理器拓撲對數據進行統一處理形成輸出 Kafka 流，將數據寫入1個或多個出流 Topic，這是 kafka 流整體的運行流程。

4.1.1 Stream 分區和任務

Kafka 分區數據的消息層用于存儲和傳輸，Kafka Streams 分區數據用于處理，在這兩種情況下，這種分區規劃和設計使數據具有彈性，可擴展，高性能和高容錯的能力。Kafka Streams 使用了分區和任務的概念，基于 Kafka 主題分區的并行性模型。在并發環境里，Kafka Streams 和 Kafka 之間有著緊密的聯系：

每個流分區是完全有序的數據記錄隊列，并映射到 Kafka 主題的分區。
流的數據消息與主題的消息映射。
數據記錄中的 keys 決定了 Kafka 和 Kafka Streams 中數據的分區，即，如何將數據路由到指定的分區。

應用程序的處理器拓撲通過將其分成多個任務來進行擴展，更具體點說，Kafka Streams 根據輸入流分區創建固定數量的任務，其中每個任務分配一個輸入流的分區列表（即，Kafka 主題）。分區對任務的分配不會改變，因此每個任務是應用程序并行性的固定單位。然后，任務可以基于分配的分區實現自己的處理器拓撲；他們還可以為每個分配的分區維護一個緩沖，并從這些記錄緩沖一次一個地處理消息。作為結果，流任務可以獨立和并行的處理而無需手動干預。

重要的是要理解 Kafka Streams 不是資源管理器，而是可在任何地方都能“運行”的流處理應用程序庫。多個實例的應用程序在同一臺機器上執行，或分布多個機器上，并且任務可以通過該庫自動的分發到這些運行的實例上。分區對任務的分配永遠不會改變；如果一個應用程式實例失敗，則這些被分配的任務將自動地在其他的實例重新創建，并從相同的流分區繼續消費。

下面展示了2個分區，每個任務分配了輸出流的1個分區。

(圖片來源: Kafka 官網)

4.1.2 線程模型

Kafka Streams 允許用戶配置線程數，可用于平衡處理應用程序的實例。每個線程的處理器拓撲獨立的執行一個或多個任務。例如，下面展示了一個流線程運行2個流任務。

(圖片來源: Kafka 官網)

啟動更多的流線程或更多應用程序實例，只需復制拓撲邏輯（即復制代碼到不同的機器上運行），達到并行處理處理不同的 Kafka 分區子集的目的。要注意的是，這些線程之間不共享狀態。因此無需協調內部的線程。這使它非常簡單在應用實例和線程之間并行拓撲。Kafka 主題分區的分配是通過 Kafka Streams 利用 Kafka 的協調功能在多個流線程之間透明處理。

如上所述，Kafka Streams 擴展流處理應用程序是很容易的：你只需要運行你的應用程序實例，Kafka Streams 負責在實例中運行的任務之間分配分區。你可以啟動多個應用程序線程處理多個輸入的 Kafka 主題分區。這樣，所有運行中的應用實例，每個線程（即運行的任務）至少有一個輸入分區可以處理。

4.1.3 故障容錯

Kafka Streams 基于 Kafka 分區的高可用和副本故障容錯能力。因此，當流數據持久到 Kafka，即使應用程序故障，如果需要重新處理它，它也是可用的。Kafka Streams 中的任務利用 Kafka 消費者客戶端提供的故障容錯的能力來處理故障。如果任務故障，Kafka Streams 將自動的在剩余運行中的應用實例重新啟動該任務。

此外，Kafka Streams 還確保了本地狀態倉庫對故障的穩定性。對于每個狀態倉庫都維持一個追蹤所有的狀態更新的變更日志主題。這些變更日志主題也分區，因此，每個本地狀態存儲實例，在任務訪問倉里，都有自己的專用的變更日志分區。變更主題日志也啟用了日志壓縮，以便可以安全的清除舊數據，以防止主題無限制的增長。如果任務失敗并在其他的機器上重新運行，則 Kafka Streams 在恢復新啟動的任務進行處理之前，重放相應的變更日志主題，保障在故障之前將其關聯的狀態存儲恢復。故障處理對于終端用戶是完全透明的。

請注意，任務（重新）初始化的成本通常主要取決于通過重放狀態倉庫變更日志主題來恢復狀態的時間。為了減少恢復時間，用戶可以配置他們的應用程序增加本地狀態的備用副本（即完全的復制狀態）。當一個任務遷移發生時，Kafka Streams 嘗試去分配任務給應用實例，提前配置了備用副本的應用實例就可以減少任務（重新）初始化的成本。

4.2 創建流

記錄流（KStreams）或變更日志流（KTable或GlobalkTable）可以從一個或多個 Kafka 主題創建源流，（而 KTable 和 GlobalKTable，只能從單個主題創建源流）。

KStreamBuilder builder = new KStreamBuilder();
 
KStream<String, GenericRecord> source1 = builder.stream("topic1", "topic2");
KTable<String, GenericRecord> source2 = builder.table("topic3", "stateStoreName");
GlobalKTable<String, GenericRecord> source2 = builder.globalTable("topic4", "globalStoreName");

左右滑動查看完整代碼

4.3 流回寫 Kafka

在處理結束后，開發者可以通過 KStream.to 和 KTable.to 將最終的結果流（連續不斷的）寫回 Kafka 主題。

joined.to("topic4");

如果已經通過上面的to方法寫入到一個主題中，但是如果你還需要繼續讀取和處理這些消息，可以從輸出主題構建一個新流，Kafka Streams 提供了便利的方法，through:

// equivalent to
//
// joined.to("topic4");
// materialized = builder.stream("topic4");
KStream materialized = joined.through("topic4");

左右滑動查看完整代碼

4.4 流程序的配置與啟執行

除了定義的 topology，開發者還需要在運行它之前在 StreamsConfig 配置他們的應用程序，Kafka Streams 配置的完整列表可以在這里找到。

Kafka Streams 中指定配置和生產者、消費者客戶端類似，通常，你創建一個 java.util.Properties，設置必要的參數，并通過 Properties 實例構建一個 StreamsConfig 實例。

import java.util.Properties;
import org.apache.kafka.streams.StreamsConfig;
Properties settings = new Properties();
// Set a few key parameters
settings.put(StreamsConfig.APPLICATION_ID_CONFIG, "my-first-streams-application");
settings.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-broker1:9092");
settings.put(StreamsConfig.ZOOKEEPER_CONNECT_CONFIG, "zookeeper1:2181");
 
// Any further settings
settings.put(... , ...);
 
// Create an instance of StreamsConfig from the Properties instance
StreamsConfig config = new StreamsConfig(settings);

除了 Kafka Streams 自己配置參數，你也可以為 Kafka 內部的消費者和生產者指定參數。根據你應用的需要。類似于 Streams 設置，你可以通過 StreamsConfig 設置任何消費者和/或生產者配置。請注意，一些消費者和生產者配置參數使用相同的參數名。例如，用于配置 TCP 緩沖的 send.buffer.bytes 或 receive.buffer.bytes。用于控制客戶端請求重試的 request.timeout.ms 和 retry.backoff.ms。如果需要為消費者和生產者設置不同的值，可以使用 consumer. 或 producer. 作為參數名稱的前綴。

Properties settings = new Properties();
 
// Example of a "normal" setting for Kafka Streams
settings.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-broker-01:9092");
// Customize the Kafka consumer settings
streamsSettings.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 60000);
// Customize a common client setting for both consumer and producer
settings.put(CommonClientConfigs.RETRY_BACKOFF_MS_CONFIG, 100L);
// Customize different values for consumer and producer
settings.put("consumer." + ConsumerConfig.RECEIVE_BUFFER_CONFIG, 1024 * 1024);
settings.put("producer." + ProducerConfig.RECEIVE_BUFFER_CONFIG, 64 * 1024);
 
// Alternatively, you can use
settings.put(StreamsConfig.consumerPrefix(ConsumerConfig.RECEIVE_BUFFER_CONFIG), 1024 * 1024);
settings.put(StremasConfig.producerConfig(ProducerConfig.RECEIVE_BUFFER_CONFIG), 64 * 1024);

你可以在應用程序代碼中的任何地方使用 Kafka Streams ，常見的是在應用程序的 main() 方法中使用。

首先，先創建一個 KafkaStreams 實例，其中構造函數的第一個參數用于定義一個

topology builder（Streams DSL的KStreamBuilder，或 Processor API 的 TopologyBuilder）。

第二個參數是上面提到的 StreamsConfig 的實例。

import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStreamBuilder;
import org.apache.kafka.streams.processor.TopologyBuilder;
// Use the builders to define the actual processing topology, e.g. to specify
// from which input topics to read, which stream operations (filter, map, etc.)
// should be called, and so on.
KStreamBuilder builder = ...;  // when using the Kafka Streams DSL
//
// OR
//
TopologyBuilder builder = ...; // when using the Processor API
// Use the configuration to tell your application where the Kafka cluster is,
// which serializers/deserializers to use by default, to specify security settings,
// and so on.
StreamsConfig config = ...;
KafkaStreams streams = new KafkaStreams(builder, config);

在這點上，內部結果已經初始化，但是處理還沒有開始。你必須通過調用 start() 方法啟動 Kafka Streams 線程：

// Start the Kafka Streams instance
streams.start();

捕獲任何意外的異常，設置 java.lang.Thread.UncaughtExceptionHandler。

每當流線程由于意外終止時，將調用此處理程序。

streams.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
    public uncaughtException(Thread t, throwable e) {
        // here you should examine the exception and perform an appropriate action!
    }
);

close() 方法結束程序。

// Stop the Kafka Streams instance
streams.close();

現在，運行你的應用程序，像其他的 Java 應用程序一樣（Kafka Sterams 沒有任何特殊的要求）。同樣，你也可以打包成 jar，通過以下方式運行：

# Start the application in class com.example.MyStreamsApp
# from the fat jar named path-to-app-fatjar.jar.
$ java -cp path-to-app-fatjar.jar com.example.MyStreamsApp

當應用程序實例開始運行時，定義的處理器拓撲將被初始化成1個或多個流任務，可以由實例內的流線程并行的執行。如果處理器拓撲定義了狀態倉庫，則這些狀態倉庫在初始化流任務期間（重新）構建。這一點要理解，當如上所訴的啟動你的應用程序時，實際上 Kafka Streams 認為你發布了一個實例。現實場景中，更常見的是你的應用程序有多個實例并行運行（如，其他的 JVM 中或別的機器上）。在這種情況下，Kafka Streams 會將任務從現有的實例中分配給剛剛啟動的新實例。

五、監控數據 ETL 中 Kafka Streams 參數及其調優

5.1 必配參數

bootstrap.servers：這是 Kafka 集群的地址列表，Kafka Streams 使用它來初始化與 Kafka 的連接。
key.deserializer 和 value.deserializer：這些配置定義了流中鍵和值的序列化和反序列化器。
auto.offset.reset：當沒有初始偏移量或偏移量無效時，這個配置定義了 Kafka Streams 如何處理。
group.id：這對于使用 Kafka Streams 的消費者組來說很重要，它定義了消費者組的ID。

5.2 基礎參數

num.stream.threads：定義 Kafka Streams 應用程序中的線程數，默認與處理器的邏輯核心數相等。
state.dir：定義 Kafka Streams 存儲狀態的本地目錄。
threading.max.instances：定義每個主題分區的最大線程實例數，默認與分區數相等。
threading.instances：定義每個主題分區的線程實例數，默認與分區數相等。

5.3 消費者參數

enable.auto.commit：自動提交偏移量，默認值為"true"，建議設置為"false"，以便更好地控制偏移量的提交。
commit.interval.ms：提交偏移量的頻率，默認值為5000ms，可以根據需要進行調整。
max.poll.records：一次拉取的消息數量，默認值為1000，可以根據網絡帶寬和處理能力進行調整。

5.4 生產者參數

batch.size：批量發送消息的大小，默認值通常是16384（字節），可以根據網絡帶寬和 Kafka 集群的性能進行調整。
linger.ms：消息在生產者緩沖區中的最小停留時間，默認值為100ms，可以根據需要進行調整。
compression.type：壓縮類型，可以提高網絡帶寬利用率，但會增加 CPU 開銷。默認值為"none"，可以根據需要設置為"gzip"、“snappy"或"lz4”。

對于 Kafka 的調優參數，可以根據實際的應用場景和性能需求進行調整，以達到最佳的性能和穩定性。

六、監控數據 ETL 中 Kafka Streams 的分區傾斜問題原因和解決方式

6.1 原因

分區傾斜是監控數據 ETL 的 Kafka Streams 在處理大規模數據流時遇到的常見問題。分區傾斜指的是在一個流處理應用程序中，某個分區的消息消費速度遠遠慢于其他分區，或某個分區的延遲積壓數據遠大于其他分區，導致 Kafka Streams 的實時性受到限制。

產生分區傾斜的原因可能包括：

數據分布不均勻：原始數據在 Kafka 主題的分區中分布不均勻，導致某些分區的消息量遠大于其他分區。
消費者實例數量不足：在 Kafka Streams 應用程序中，消費者的實例數量不足，無法充分處理所有分區的消息。
消費者負載不均衡：消費者的負載不均衡（包括但不限于某些消費者實例處理的分區數大于其他實例），導致某些消費者實例處理的消息量遠大于其他實例。
消費者實例負載不均衡：消費者實例性能不一致或性能被擠占，導致消費能力不均衡，消費速率異常小于平均消費速率

6.2 解決方案

數據均衡策略：在設計 Kafka 主題分區分配策略時，可以采用如輪詢（Round-robin）或范圍（Range）等均衡策略，使得數據在各個分區之間均勻分布。
增加消費者實例：根據應用程序的實際情況，適當增加消費者的實例數量，以提高整個系統的處理能力，例如擴容。
負載均衡策略：在消費者組內部實現負載均衡，如使用均勻分配消費者（Uniform Distribution Consumer）等策略，確保消費者實例之間的負載均衡，例如重啟或剔除傾斜分區實例使 Kafka Streams 的分區進行重新分配。
優化消費者處理邏輯：分析消費者處理消息的速度慢的原因，優化處理邏輯，提高消費者的處理能力。
調整批次大小和窗口函數：通過調整 Kafka Streams 的批次大小和窗口函數等參數，降低消費者的處理壓力。
使用側輸出：對于一些處理速度較慢的分區，可以考慮使用側輸出將部分消息引流至其他系統處理，減輕消費者負載。

七、總結

本文介紹了 Kafka Streams 在監控場景中的應用，闡述了 Kafka Streams 的基本概念，包括流、處理器拓撲、流處理器、時間概念等，舉例說明了 Kafka Streams 在監控實時數據ETL中的具體應用，并詳細解釋了 Kafka Streams 的運作原理，包括其架構、創建流、流回寫 Kafka、流程序配置與啟執行等內容。文章還介紹了 Kafka Streams 的參數及其調優方法，以及可能出現的分區傾斜問題及其解決方法。

本文意在讓讀者對于 Kafka 流在監控業務的實際應用有所認識，并且了解 Kafka 流的基本概念和原理，閱讀本文后對構建自己 Kafka 流應用程序有所幫助，能夠理解在監控數據 ETL 常見分區傾斜的原理和解決方式。

八、引用

Kafka 官網：https://kafka.apache.org/

責任編輯：龐桂玉來源： vivo互聯網技術

服務器大數據