ปลดปล่อยพลังการประมวลผลสตรีม: เจาะลึก Apache Kafka Streams

ในโลกดิจิทัลที่เปลี่ยนแปลงอย่างรวดเร็วในปัจจุบัน ธุรกิจต่างๆ จำเป็นต้องตอบสนองต่อเหตุการณ์ที่เกิดขึ้นแบบทันทีทันใด วิธีการประมวลผลแบบแบตช์ (batch processing) แบบดั้งเดิมไม่เพียงพออีกต่อไปสำหรับการจัดการกับกระแสข้อมูลที่ต่อเนื่องซึ่งสร้างขึ้นโดยแอปพลิเคชันสมัยใหม่ นี่คือจุดที่ การประมวลผลสตรีม (stream processing) เข้ามามีบทบาท การประมวลผลสตรีมช่วยให้คุณสามารถวิเคราะห์และแปลงข้อมูลได้แบบเรียลไทม์ ทำให้คุณสามารถตัดสินใจและดำเนินการได้อย่างทันท่วงที

ท่ามกลางเฟรมเวิร์กการประมวลผลสตรีมที่มีอยู่มากมาย Apache Kafka Streams โดดเด่นในฐานะไลบรารีที่ทรงพลังและมีขนาดเล็ก ซึ่งสร้างขึ้นบน Apache Kafka โดยตรง คู่มือนี้จะให้ภาพรวมที่ครอบคลุมของ Kafka Streams โดยครอบคลุมแนวคิดหลัก สถาปัตยกรรม กรณีศึกษา และแนวทางปฏิบัติที่ดีที่สุด

Apache Kafka Streams คืออะไร?

Apache Kafka Streams คือไลบรารีฝั่งไคลเอ็นต์สำหรับการสร้างแอปพลิเคชันแบบเรียลไทม์และไมโครเซอร์วิส โดยที่ข้อมูลอินพุตและ/หรือเอาต์พุตถูกจัดเก็บไว้ในคลัสเตอร์ของ Apache Kafka มันช่วยลดความซับซ้อนในการพัฒนาแอปพลิเคชันประมวลผลสตรีมโดยมี DSL (Domain Specific Language) ระดับสูงและ Processor API ระดับต่ำ คุณสมบัติหลัก ได้แก่:

• สร้างบน Kafka: ใช้ประโยชน์จากความสามารถในการขยายขนาด (scalability), การทนทานต่อความผิดพลาด (fault tolerance) และความคงทน (durability) ของ Kafka
• น้ำหนักเบา: เป็นไลบรารีที่เรียบง่าย ง่ายต่อการรวมเข้ากับแอปพลิเคชันที่มีอยู่
• ขยายขนาดได้: สามารถจัดการกับข้อมูลปริมาณมากด้วยการขยายขนาดในแนวนอน (horizontal scalability)
• ทนทานต่อความผิดพลาด: ออกแบบมาเพื่อความพร้อมใช้งานสูงพร้อมกลไกการทนทานต่อความผิดพลาด
• Exactly-Once Semantics: รับประกันว่าแต่ละระเบียนจะถูกประมวลผลเพียงครั้งเดียว แม้ในกรณีที่เกิดความล้มเหลว
• การประมวลผลแบบมีสถานะ (Stateful Processing): รองรับการดำเนินการแบบมีสถานะ เช่น การรวม (aggregations), การแบ่งหน้าต่าง (windowing) และการเชื่อมข้อมูล (joins)
• API ที่ยืดหยุ่น: มีทั้ง DSL ระดับสูงและ Processor API ระดับต่ำเพื่อระดับการควบคุมที่แตกต่างกัน

สถาปัตยกรรมของ Kafka Streams

การทำความเข้าใจสถาปัตยกรรมของ Kafka Streams เป็นสิ่งสำคัญสำหรับการสร้างแอปพลิเคชันที่แข็งแกร่งและขยายขนาดได้ นี่คือรายละเอียดขององค์ประกอบหลัก:

คลัสเตอร์ Kafka (Kafka Cluster)

Kafka Streams อาศัยคลัสเตอร์ Kafka ในการจัดเก็บและจัดการข้อมูล Kafka ทำหน้าที่เป็นศูนย์กลางของแอปพลิเคชันประมวลผลสตรีมของคุณ โดยให้พื้นที่จัดเก็บที่ทนทาน การทนทานต่อความผิดพลาด และความสามารถในการขยายขนาด

แอปพลิเคชัน Kafka Streams (Kafka Streams Application)

แอปพลิเคชัน Kafka Streams เป็นตรรกะหลักที่ประมวลผลสตรีมข้อมูล ประกอบด้วยโทโพโลยี (topology) ที่กำหนดการไหลของข้อมูลและการแปลงที่จะนำไปใช้ โดยทั่วไปแอปพลิเคชันจะถูกบรรจุเป็นไฟล์ JAR และปรับใช้กับโหนดประมวลผลหนึ่งโหนดขึ้นไป

โทโพโลยี (Topology)

โทโพโลยีคือ กราฟมีทิศทางที่ไม่มีวงจร (Directed Acyclic Graph - DAG) ที่แสดงการไหลของข้อมูลภายในแอปพลิเคชัน Kafka Streams ประกอบด้วยโหนดที่แสดงถึงขั้นตอนการประมวลผล เช่น การอ่านข้อมูลจาก Kafka topic การแปลงข้อมูล หรือการเขียนข้อมูลไปยัง Kafka topic อื่น โทโพโลยีถูกกำหนดโดยใช้ DSL หรือ Processor API

โพรเซสเซอร์ (Processors)

โพรเซสเซอร์เป็นส่วนประกอบพื้นฐานของโทโพโลยีใน Kafka Streams ทำหน้าที่ดำเนินการประมวลผลข้อมูลจริง มีโพรเซสเซอร์สองประเภท:

• Source Processors: อ่านข้อมูลจาก Kafka topics
• Sink Processors: เขียนข้อมูลไปยัง Kafka topics
• Processor Nodes: แปลงข้อมูลตามตรรกะที่กำหนด

ที่จัดเก็บสถานะ (State Stores)

ที่จัดเก็บสถานะใช้เพื่อเก็บผลลัพธ์ระหว่างการประมวลผลหรือข้อมูลที่ถูกรวม (aggregated data) โดยทั่วไปจะถูกนำมาใช้เป็น key-value store แบบฝังตัวภายในแอปพลิเคชัน Kafka Streams ที่จัดเก็บสถานะมีความสำคัญอย่างยิ่งต่อการดำเนินการแบบมีสถานะ เช่น การรวมข้อมูลและการแบ่งหน้าต่าง

เธรดและทาสก์ (Threads and Tasks)

แอปพลิเคชัน Kafka Streams ทำงานในเธรดหนึ่งเธรดขึ้นไป แต่ละเธรดรับผิดชอบการดำเนินการส่วนหนึ่งของโทโพโลยี แต่ละเธรดจะถูกแบ่งย่อยออกเป็นทาสก์ ซึ่งจะถูกกำหนดให้กับพาร์ติชันเฉพาะของ Kafka topic ที่เป็นอินพุต การทำงานแบบขนานนี้ช่วยให้ Kafka Streams สามารถขยายขนาดในแนวนอนได้

แนวคิดหลักใน Kafka Streams

เพื่อให้สามารถใช้ Kafka Streams ได้อย่างมีประสิทธิภาพ คุณต้องเข้าใจแนวคิดหลักบางประการ:

สตรีมและตาราง (Streams and Tables)

Kafka Streams แยกความแตกต่างระหว่างสตรีมและตาราง:

• สตรีม (Stream): แทนลำดับของระเบียนข้อมูลที่ไม่มีที่สิ้นสุดและไม่สามารถเปลี่ยนแปลงได้ (unbounded, immutable) แต่ละระเบียนแทนเหตุการณ์ที่เกิดขึ้น ณ จุดเวลาใดเวลาหนึ่ง
• ตาราง (Table): แทนมุมมองที่เป็นรูปธรรม (materialized view) ของสตรีม เป็นชุดของคู่คีย์-ค่า (key-value pairs) โดยที่คีย์แทนตัวระบุที่ไม่ซ้ำกัน และค่าแทนสถานะปัจจุบันของเอนทิตีที่เกี่ยวข้องกับคีย์นั้น

คุณสามารถแปลงสตรีมเป็นตารางได้โดยใช้การดำเนินการเช่น `KTable` หรือโดยการรวมข้อมูล

หน้าต่างเวลา (Time Windows)

หน้าต่างเวลาใช้เพื่อจัดกลุ่มระเบียนข้อมูลตามเวลา มีความสำคัญอย่างยิ่งสำหรับการดำเนินการรวมข้อมูลและการดำเนินการแบบมีสถานะอื่นๆ ในช่วงเวลาที่กำหนด Kafka Streams รองรับหน้าต่างเวลาประเภทต่างๆ รวมถึง:

• Tumbling Windows: หน้าต่างขนาดคงที่และไม่ทับซ้อนกัน
• Hopping Windows: หน้าต่างขนาดคงที่และทับซ้อนกัน
• Sliding Windows: หน้าต่างที่เลื่อนไปตามเวลาตามช่วงเวลาที่กำหนด
• Session Windows: หน้าต่างแบบไดนามิกที่กำหนดตามกิจกรรมของผู้ใช้หรือเอนทิตี

การเชื่อมข้อมูล (Joins)

Kafka Streams รองรับการเชื่อมข้อมูลหลายประเภทเพื่อรวมข้อมูลจากสตรีมหรือตารางต่างๆ:

• Stream-Stream Join: เชื่อมสองสตรีมเข้าด้วยกันโดยใช้คีย์ร่วมและหน้าต่างที่กำหนด
• Stream-Table Join: เชื่อมสตรีมกับตารางโดยใช้คีย์ร่วม
• Table-Table Join: เชื่อมสองตารางเข้าด้วยกันโดยใช้คีย์ร่วม

Exactly-Once Semantics

การรับประกันว่าแต่ละระเบียนจะถูกประมวลผลเพียงครั้งเดียวเป็นสิ่งสำคัญสำหรับแอปพลิเคชันประมวลผลสตรีมจำนวนมาก Kafka Streams ให้ Exactly-Once Semantics โดยใช้ประโยชน์จากความสามารถในการทำธุรกรรม (transactional capabilities) ของ Kafka สิ่งนี้รับประกันได้ว่าแม้ในกรณีที่เกิดความล้มเหลว ข้อมูลจะไม่สูญหายหรือซ้ำซ้อน

กรณีศึกษาการใช้งานสำหรับ Apache Kafka Streams

Kafka Streams เหมาะสำหรับการใช้งานที่หลากหลายในอุตสาหกรรมต่างๆ:

การตรวจสอบและการแจ้งเตือนแบบเรียลไทม์

ตรวจสอบเมตริกของระบบ, ล็อกของแอปพลิเคชัน และกิจกรรมของผู้ใช้แบบเรียลไทม์เพื่อตรวจจับความผิดปกติและส่งการแจ้งเตือน ตัวอย่างเช่น สถาบันการเงินสามารถตรวจสอบข้อมูลธุรกรรมเพื่อหากิจกรรมที่น่าสงสัยและบล็อกธุรกรรมที่น่าสงสัยได้ทันที

การตรวจจับการฉ้อโกง

วิเคราะห์ข้อมูลธุรกรรมแบบเรียลไทม์เพื่อระบุรูปแบบการฉ้อโกงและป้องกันความสูญเสียทางการเงิน ด้วยการรวม Kafka Streams เข้ากับโมเดลการเรียนรู้ของเครื่อง คุณสามารถสร้างระบบตรวจจับการฉ้อโกงที่ซับซ้อนได้

การปรับแต่งเฉพาะบุคคลและระบบแนะนำ

สร้างระบบแนะนำแบบเรียลไทม์ที่ปรับแต่งประสบการณ์ผู้ใช้ตามประวัติการเข้าชม, ประวัติการซื้อ และข้อมูลพฤติกรรมอื่นๆ แพลตฟอร์มอีคอมเมิร์ซสามารถใช้สิ่งนี้เพื่อแนะนำผลิตภัณฑ์หรือบริการที่เกี่ยวข้องกับลูกค้า

การประมวลผลข้อมูล Internet of Things (IoT)

ประมวลผลสตรีมข้อมูลจากอุปกรณ์ IoT แบบเรียลไทม์เพื่อตรวจสอบประสิทธิภาพของอุปกรณ์, เพิ่มประสิทธิภาพการใช้พลังงาน และคาดการณ์ความต้องการในการบำรุงรักษา ตัวอย่างเช่น โรงงานผลิตสามารถใช้ Kafka Streams เพื่อวิเคราะห์ข้อมูลเซ็นเซอร์จากเครื่องจักรเพื่อตรวจจับความล้มเหลวที่อาจเกิดขึ้นและกำหนดเวลาการบำรุงรักษาเชิงป้องกัน

การรวบรวมและวิเคราะห์ล็อก

รวบรวมและวิเคราะห์ข้อมูลล็อกจาำกแหล่งต่างๆ แบบเรียลไทม์เพื่อระบุปัญหาคอขวดด้านประสิทธิภาพ, ภัยคุกคามความปลอดภัย และปัญหาการดำเนินงานอื่นๆ สิ่งนี้สามารถช่วยปรับปรุงความเสถียรและความปลอดภัยของระบบได้

การวิเคราะห์คลิกสตรีม (Clickstream Analysis)

วิเคราะห์ข้อมูลคลิกสตรีมของผู้ใช้เพื่อทำความเข้าใจพฤติกรรมผู้ใช้, เพิ่มประสิทธิภาพเว็บไซต์ และปรับแต่งแคมเปญการตลาด ผู้ค้าปลีกออนไลน์สามารถใช้สิ่งนี้เพื่อติดตามการนำทางของผู้ใช้และระบุส่วนที่ต้องปรับปรุงบนเว็บไซต์ของตน

ตัวอย่างสถานการณ์: การประมวลผลคำสั่งซื้อแบบเรียลไทม์

ลองพิจารณาแพลตฟอร์มอีคอมเมิร์ซที่ต้องประมวลผลคำสั่งซื้อแบบเรียลไทม์ เมื่อใช้ Kafka Streams คุณสามารถสร้างแอปพลิเคชันประมวลผลสตรีมที่:

1. รับข้อมูลเหตุการณ์คำสั่งซื้อจาก Kafka topic
2. เพิ่มข้อมูลคำสั่งซื้อด้วยข้อมูลลูกค้าจากฐานข้อมูล
3. คำนวณยอดรวมของคำสั่งซื้อและใช้ส่วนลด
4. อัปเดตระดับสินค้าคงคลัง
5. ส่งอีเมลยืนยันคำสั่งซื้อไปยังลูกค้า
6. เผยแพร่เหตุการณ์คำสั่งซื้อไปยัง Kafka topics อื่นๆ เพื่อการประมวลผลต่อไป (เช่น การจัดส่ง, การเรียกเก็บเงิน)

แอปพลิเคชันนี้สามารถประมวลผลคำสั่งซื้อหลายพันรายการต่อวินาที ทำให้มั่นใจได้ว่าคำสั่งซื้อจะถูกประมวลผลอย่างรวดเร็วและมีประสิทธิภาพ

การเริ่มต้นใช้งาน Apache Kafka Streams

นี่คือคำแนะนำทีละขั้นตอนในการเริ่มต้นใช้งาน Kafka Streams:

1. ตั้งค่าคลัสเตอร์ Kafka

คุณต้องมีคลัสเตอร์ Kafka ที่ทำงานอยู่เพื่อใช้ Kafka Streams คุณสามารถตั้งค่าคลัสเตอร์ Kafka ในเครื่องโดยใช้เครื่องมือเช่น Docker หรือใช้บริการ Kafka ที่มีการจัดการเช่น Confluent Cloud หรือ Amazon MSK

2. เพิ่ม Dependency ของ Kafka Streams ในโปรเจกต์ของคุณ

เพิ่ม dependency ของ Kafka Streams ไปยังไฟล์ build ของโปรเจกต์ของคุณ (เช่น `pom.xml` สำหรับ Maven หรือ `build.gradle` สำหรับ Gradle)

Maven:

            <dependency>
 <groupId>org.apache.kafka</groupId>
 <artifactId>kafka-streams</artifactId>
 <version>[YOUR_KAFKA_VERSION]</version>
</dependency>
            

              
                Copy
              
            
          

Gradle:

            dependencies {
 implementation "org.apache.kafka:kafka-streams:[YOUR_KAFKA_VERSION]"
}
            

              
                Copy
              
            
          

3. เขียนแอปพลิเคชัน Kafka Streams ของคุณ

เขียนแอปพลิเคชัน Kafka Streams ของคุณโดยใช้ DSL หรือ Processor API นี่คือตัวอย่างง่ายๆ โดยใช้ DSL:

            import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.Topology;
import org.apache.kafka.streams.kstream.KStream;

import java.util.Properties;

public class WordCount {

 public static void main(String[] args) {
 Properties props = new Properties();
 props.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application");
 props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
 props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, org.apache.kafka.common.serialization.Serdes.String().getClass());
 props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, org.apache.kafka.common.serialization.Serdes.String().getClass());

 StreamsBuilder builder = new StreamsBuilder();
 KStream<String, String> textLines = builder.stream("input-topic");
 KStream<String, String> wordCounts = textLines
 .flatMapValues(textLine -> Arrays.asList(textLine.toLowerCase().split("\\W+")));

 wordCounts.to("output-topic");

 Topology topology = builder.build();
 KafkaStreams streams = new KafkaStreams(topology, props);
 streams.start();
 }
}
            

              
                Copy
              
            
          

ตัวอย่างนี้อ่านบรรทัดข้อความจาก `input-topic` แยกแต่ละบรรทัดออกเป็นคำ แปลงคำเป็นตัวพิมพ์เล็ก และเขียนคำไปยัง `output-topic`

4. กำหนดค่าแอปพลิเคชันของคุณ

กำหนดค่าแอปพลิเคชัน Kafka Streams ของคุณโดยใช้คลาส `StreamsConfig` คุณต้องระบุคุณสมบัติอย่างน้อยดังต่อไปนี้:

• `application.id`: ตัวระบุที่ไม่ซ้ำกันสำหรับแอปพลิเคชันของคุณ
• `bootstrap.servers`: รายชื่อของ Kafka brokers ที่จะเชื่อมต่อ
• `default.key.serde`: serializer/deserializer เริ่มต้นสำหรับคีย์
• `default.value.serde`: serializer/deserializer เริ่มต้นสำหรับค่า

5. รันแอปพลิเคชันของคุณ

รันแอปพลิเคชัน Kafka Streams ของคุณเป็นแอปพลิเคชัน Java แบบสแตนด์อโลน ตรวจสอบให้แน่ใจว่า Kafka กำลังทำงานและ topics ถูกสร้างขึ้นก่อนที่จะรันแอปพลิเคชัน

แนวทางปฏิบัติที่ดีที่สุดสำหรับ Apache Kafka Streams

นี่คือแนวทางปฏิบัติที่ดีที่สุดบางประการสำหรับการสร้างแอปพลิเคชัน Kafka Streams ที่แข็งแกร่งและขยายขนาดได้:

เลือก API ที่เหมาะสม

ตัดสินใจว่าจะใช้ DSL ระดับสูงหรือ Processor API ระดับต่ำตามความต้องการของแอปพลิเคชันของคุณ DSL ใช้งานง่ายกว่าสำหรับการแปลงข้อมูลที่ไม่ซับซ้อน ในขณะที่ Processor API ให้การควบคุมและความยืดหยุ่นที่มากกว่าสำหรับสถานการณ์ที่ซับซ้อน

ปรับแต่งการกำหนดค่า State Store ให้เหมาะสม

กำหนดค่า state stores อย่างเหมาะสมเพื่อเพิ่มประสิทธิภาพ ควรพิจารณาปัจจัยต่างๆ เช่น การจัดสรรหน่วยความจำ, การแคช และความคงทน สำหรับ state stores ที่มีขนาดใหญ่มาก ควรพิจารณาใช้ RocksDB เป็นเอ็นจิ้นการจัดเก็บข้อมูลพื้นฐาน

จัดการกับข้อผิดพลาดและข้อยกเว้น

นำกลไกการจัดการข้อผิดพลาดและข้อยกเว้นที่เหมาะสมมาใช้เพื่อให้แน่ใจว่าแอปพลิเคชันของคุณสามารถกู้คืนจากความล้มเหลวได้อย่างราบรื่น ใช้คุณสมบัติการทนทานต่อความผิดพลาดที่มีในตัวของ Kafka Streams เพื่อลดการสูญเสียข้อมูล

ตรวจสอบแอปพลิเคชันของคุณ

ตรวจสอบแอปพลิเคชัน Kafka Streams ของคุณโดยใช้เมตริกที่มีในตัวของ Kafka หรือเครื่องมือตรวจสอบภายนอก ติดตามเมตริกหลัก เช่น เวลาแฝงในการประมวลผล (processing latency), ปริมาณงาน (throughput) และอัตราข้อผิดพลาด (error rates) พิจารณาใช้เครื่องมือเช่น Prometheus และ Grafana สำหรับการตรวจสอบ

ปรับแต่งการกำหนดค่า Kafka

ปรับแต่งพารามิเตอร์การกำหนดค่าของ Kafka เพื่อเพิ่มประสิทธิภาพตามปริมาณงานของแอปพลิเคชันของคุณ ให้ความสนใจกับการตั้งค่าเช่น `num.partitions`, `replication.factor` และ `compression.type`

พิจารณาการทำ Serialization ข้อมูล

เลือกรูปแบบการทำ serialization ข้อมูลที่มีประสิทธิภาพเช่น Avro หรือ Protobuf เพื่อลดขนาดข้อมูลและปรับปรุงประสิทธิภาพ ตรวจสอบให้แน่ใจว่า serializers และ deserializers ของคุณเข้ากันได้กับแอปพลิเคชันเวอร์ชันต่างๆ

หัวข้อขั้นสูง

การสืบค้นแบบโต้ตอบ (Interactive Queries)

Kafka Streams มี Interactive Queries ซึ่งช่วยให้คุณสามารถสืบค้นสถานะของแอปพลิเคชันของคุณได้แบบเรียลไทม์ สิ่งนี้มีประโยชน์สำหรับการสร้างแดชบอร์ดและให้ข้อมูลเชิงลึกแก่ผู้ใช้

Exactly-Once vs. At-Least-Once Semantics

แม้ว่า Kafka Streams จะรองรับ Exactly-Once Semantics แต่สิ่งสำคัญคือต้องเข้าใจข้อดีข้อเสียระหว่าง Exactly-Once และ At-Least-Once Semantics Exactly-Once Semantics อาจทำให้เกิดค่าใช้จ่ายด้านประสิทธิภาพเพิ่มขึ้น ดังนั้นคุณจึงต้องเลือกระดับความสอดคล้องที่เหมาะสมตามความต้องการของแอปพลิเคชันของคุณ

การผสานรวมกับระบบอื่นๆ

Kafka Streams สามารถผสานรวมกับระบบอื่นๆ ได้อย่างง่ายดาย เช่น ฐานข้อมูล, คิวข้อความ และแพลตฟอร์มการเรียนรู้ของเครื่อง สิ่งนี้ช่วยให้คุณสามารถสร้างไปป์ไลน์ข้อมูลที่ซับซ้อนซึ่งครอบคลุมหลายระบบได้

สรุป

Apache Kafka Streams เป็นเฟรมเวิร์กที่ทรงพลังและหลากหลายสำหรับการสร้างแอปพลิเคชันประมวลผลสตรีมแบบเรียลไทม์ ความเรียบง่าย, ความสามารถในการขยายขนาด และการทนทานต่อความผิดพลาดทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับกรณีการใช้งานที่หลากหลาย ด้วยการทำความเข้าใจแนวคิดหลัก, สถาปัตยกรรม และแนวทางปฏิบัติที่ดีที่สุดที่ระบุไว้ในคู่มือนี้ คุณสามารถใช้ประโยชน์จาก Kafka Streams เพื่อสร้างแอปพลิเคชันที่แข็งแกร่งและขยายขนาดได้ซึ่งตอบสนองความต้องการของโลกดิจิทัลที่เปลี่ยนแปลงอย่างรวดเร็วในปัจจุบัน

เมื่อคุณเจาะลึกลงไปในการประมวลผลสตรีมด้วย Kafka Streams คุณจะค้นพบศักยภาพมหาศาลในการเปลี่ยนข้อมูลดิบให้เป็นข้อมูลเชิงลึกที่นำไปปฏิบัติได้แบบเรียลไทม์ โอบรับพลังของการสตรีมและปลดล็อกความเป็นไปได้ใหม่ๆ สำหรับธุรกิจของคุณ

แหล่งเรียนรู้เพิ่มเติม

• เอกสารประกอบ Apache Kafka Streams
• บทแนะนำ Confluent Kafka Streams
• หลักสูตรสำหรับนักพัฒนา Confluent