ดูอย่างรวดเร็วที่ Spark Structured Streaming + Kafka

การเรียนรู้พื้นฐานวิธีใช้ Duo อันทรงพลังนี้สำหรับงานประมวลผลสตรีม

เมื่อเร็วๆ นี้ ฉันเริ่มศึกษามากมายเกี่ยวกับ Apache Kafka และ Apache Spark สองเทคโนโลยีชั้นนำในโลกวิศวกรรมข้อมูล

ฉันได้ทำหลายโครงการโดยใช้พวกเขาในช่วงไม่กี่เดือนที่ผ่านมา -การสตรีมการเรียนรู้ของเครื่องด้วย Kafka, Debezium และ BentoML” เป็นตัวอย่าง เป้าหมายของฉันคือการเรียนรู้วิธีสร้างไปป์ไลน์ข้อมูลที่มีประสิทธิภาพด้วยเครื่องมือสมัยใหม่ที่มีชื่อเสียงเหล่านี้ และทำความเข้าใจถึงข้อดีและข้อเสียของมัน

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

เป้าหมายของเราคือการเรียนรู้แนวคิดทั่วไปเบื้องหลังการสร้างแอปพลิเคชันสตรีมมิ่งด้วย Spark+Kafka และดูแนวคิดหลักอย่างรวดเร็วโดยใช้ข้อมูลจริง

แนวคิดนี้เรียบง่าย — Apache Kafka เป็นเครื่องมือสตรีมข้อความ โดยที่ผู้ผลิตจะเขียนข้อความที่ปลายด้านหนึ่งของคิว (เรียกว่า หัวข้อ) เพื่อให้ผู้บริโภคอ่านในอีกทางหนึ่ง

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

Apache Spark คือกลไกการแปลงข้อมูลบนหน่วยความจำแบบกระจาย

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

ส่วนที่ยอดเยี่ยมเกี่ยวกับเรื่องนี้ก็คือ ในตอนท้ายของวัน โค้ดเป็นเพียงการสืบค้น SQL ปกติของคุณหรือ (เกือบ) สคริปต์ Python+pandas ของคุณ โดยที่เวทมนตร์ทั้งหมดถูกสรุปไว้ภายใต้ API ระดับสูงที่ใช้งานง่าย

เข้าร่วมเทคโนโลยีทั้งสองนี้และเรามีคู่ที่สมบูรณ์แบบในการสร้างไปป์ไลน์ ETL แบบสตรีมมิ่ง

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

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

ในสถานการณ์นี้ สามารถใช้ Apache Kafka เป็นเลเยอร์นามธรรมระหว่างเซ็นเซอร์และแอปพลิเคชันที่ใช้ข้อมูลได้

ด้วยโครงสร้างพื้นฐานประเภทนี้ จึงเป็นไปได้ที่จะสร้างทุกประเภท (ที่เรียกว่า) ระบบขับเคลื่อนเหตุการณ์แบบเรียลไทม์เช่นโปรแกรมตรวจจับและแจ้งเตือนการจราจรติดขัดเมื่อจำนวนรถเพิ่มขึ้นอย่างกะทันหันตามความเร็วเฉลี่ยที่ลดลง

และนั่นคือสิ่งที่ Apache Spark เข้ามามีบทบาท

มีโมดูลดั้งเดิมสำหรับการประมวลผลสตรีมที่เรียกว่า Spark สตรีมมิ่งแบบมีโครงสร้างที่สามารถเชื่อมต่อกับ Kafka และประมวลผลข้อความได้

การสร้างสิ่งแวดล้อม

สิ่งที่คุณต้องมีคือนักเทียบท่าและนักเทียบท่าเขียน

เราจะใช้การกำหนดค่าไฟล์นักเทียบท่าเขียนตามที่เก็บต่อไปนี้: ลิงค์สปาร์ค, ลิงค์คาฟคา.

พื้นที่ ./src ปริมาณคือที่ที่เราจะใส่สคริปต์ของเรา

หากต้องการเริ่มต้นสภาพแวดล้อม เพียงแค่เรียกใช้

นักเทียบท่าเขียนขึ้น

รหัสทั้งหมดมีอยู่ในนี้ พื้นที่เก็บข้อมูล GitHub.

สิ่งหนึ่งที่ฉันชอบมากที่สุดเมื่อเริ่มศึกษา Spark คือความคล้ายคลึงกันระหว่างโค้ดที่เขียนไว้กับสคริปต์ python+pandas ปกติของฉัน มันง่ายมากที่จะโยกย้าย

ด้วยตรรกะเดียวกัน โมดูลการสตรีมของ Spark จึงคล้ายกับโค้ด Spark ปกติมาก ทำให้ง่ายต่อการโยกย้ายจากแอปพลิเคชันแบบแบตช์ไปยังแอปพลิเคชันสตรีม

จากที่กล่าวไปแล้ว ในส่วนต่อไปนี้ เราจะมุ่งเน้นไปที่การเรียนรู้ลักษณะเฉพาะของการสตรีมแบบมีโครงสร้าง Spark กล่าวคือ มีฟีเจอร์ใหม่ใดบ้าง

งานแรกของเรา

เรามาเริ่มกันแบบช้าๆ และสร้างตัวอย่างของเล่นกัน

สิ่งแรกที่ต้องทำคือสร้างหัวข้อ Kafka โดยที่งาน Spark ของเราจะใช้ข้อความ

สิ่งนี้ทำได้โดย เข้าถึงเทอร์มินัลคอนเทนเนอร์ Kafka และดำเนินการ:

kafka-topics.sh -- สร้าง --bootstrap-เซิร์ฟเวอร์ localhost:9092 --topic test_topic

ในการจำลองผู้ผลิตเขียนข้อความในหัวข้อนี้ ลองใช้ kafka-console-โปรดิวเซอร์ นอกจากนี้ภายในคอนเทนเนอร์:

kafka-console-producer.sh --bootstrap-server localhost:9092 --topic test_topic --property "parse.key=true" --property "key.separator=:"

จากนี้ไป ทุกบรรทัดที่พิมพ์ใน Terminal จะถูกส่งเป็นข้อความไปยังหัวข้อทดสอบ อักขระ “:” ใช้เพื่อแยกคีย์และค่าของข้อความ (คีย์:ค่า)

มาสร้างงาน Spark เพื่อใช้งานหัวข้อนี้กันดีกว่า

ต้องใส่โค้ดเข้าไปข้างใน /src/สตรีมมิ่ง โฟลเดอร์ (ไม่มีอะไรพิเศษ มีแต่โฟลเดอร์ที่ฉันเลือก)

สิ่งสำคัญที่ควรทราบคือเราใช้แอตทริบิวต์ อ่านสตรีม และ เขียนสตรีม, แทนการอ่านและเขียนตามปกติ นี่คือประเด็นหลักที่ทำให้ Spark ปฏิบัติต่องานของเราในฐานะแอปพลิเคชันสตรีมมิ่ง

หากต้องการเชื่อมต่อกับ Kafka จำเป็นต้องระบุเซิร์ฟเวอร์และหัวข้อ ทางเลือก การเริ่มต้นออฟเซ็ต =“เร็วที่สุด” บอกให้ Spark อ่านหัวข้อตั้งแต่ต้น นอกจากนี้ เนื่องจากคาฟคาเก็บข้อความไว้ด้วย ไบนารี จะต้องถอดรหัสให้ได้ เชือก.

ตัวเลือกอื่น ๆ จะได้รับการสำรวจเพิ่มเติม

ตอนนี้ เรามาเข้าถึงคอนเทนเนอร์ Spark และรันงานกันดีกว่า

spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/สตรีมมิ่ง/read_test_stream.py

หลังจากกำหนดค่าไม่กี่วินาที ระบบจะเริ่มใช้งานหัวข้อ

Spark Streaming ใช้งานได้ ไมโครแบทช์ โหมด และนั่นคือสาเหตุที่เราเห็นข้อมูล "แบทช์" เมื่อใช้งานข้อความ

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

ฉันไม่ใช่คนพิมพ์เร็ว ดังนั้น Spark จึงประมวลผลข้อความก่อนจึงจะสามารถรวมข้อความใหม่ลงในชุดปัจจุบันได้

และนั่นคืองานสตรีมมิ่งงานแรกของเรา!

ฉันหวังว่าคุณจะเข้าใจ: การเขียนโค้ดงานประมวลผลสตรีมไม่ใช่เรื่องยาก แต่ก็มีข้อบกพร่องอยู่บ้าง

การเขียนข้อมูลไปยังสตรีมคาฟคา

ตอนนี้ได้เวลาเริ่มเล่นกับข้อมูลเซ็นเซอร์แล้ว

คุณสามารถดาวน์โหลด ไปรษณีย์ ตั้งแต่เดือนสิงหาคม 2022 และแตกไฟล์ลงในไฟล์ /ข้อมูล ปริมาณ. ข้อมูลเดิมอยู่ใน JSON และใช้พื้นที่ประมาณ 23Gb สิ่งแรกที่ต้องทำคือแปลงเป็นไม้ปาร์เก้เพื่อปรับพื้นที่ดิสก์และเวลาในการอ่านให้เหมาะสม

งาน Spark ที่ต้องทำนี้มีรายละเอียดอยู่ในที่เก็บ GitHub สิ่งที่คุณต้องทำคือดำเนินการงานเหล่านั้น:

จุดประกายส่ง /src/transform_json_to_parquet.pyจุดประกายส่ง /src/join_parquet_files.py

การดำเนินการอาจใช้เวลาสักครู่ ทั้งนี้ขึ้นอยู่กับเครื่องของคุณ แต่ได้ผลดี ขนาดไฟล์ปาร์เก้สุดท้ายคือ ~1Gb (เล็กกว่า 20 เท่า) และอ่านได้เร็วกว่ามาก

เรายังจำเป็นต้องสร้างหัวข้อคาฟคาเพื่อรับข้อความของเรา:

kafka-topics.sh -- สร้าง --replication-factor 1 --bootstrap-server localhost:9092 --topic Traffic_sensor

อีกทางเลือกหนึ่ง หากคุณต้องการแสดงข้อความที่มาถึง คุณสามารถตั้งค่าคอนโซลคอนซูเมอร์ได้

kafka-console-consumer.sh -- หัวข้อ Traffic_sensor --bootstrap-server localhost: 9092

การเขียนข้อมูลในหัวข้อคาฟคาเป็นเรื่องง่าย แต่มีรายละเอียดอยู่บ้าง

ในการสตรีมแบบมีโครงสร้าง พฤติกรรมเริ่มต้นคือการไม่พยายามอนุมานสคีมาข้อมูล (คอลัมน์และประเภท) ดังนั้นเราจึงต้องผ่านอย่างใดอย่างหนึ่ง

ข้อความคาฟคาเป็นเพียงคู่สตริงไบนารีของคีย์-ค่า ดังนั้นเราจึงจำเป็นต้องแสดงข้อมูลของเราในรูปแบบนี้ ซึ่งสามารถทำได้ง่ายๆ โดยการแปลงแถวทั้งหมดเป็นสตริง JSON เข้ารหัสเป็นไบนารี่ และจัดเก็บผลลัพธ์ไว้ในคอลัมน์ "ค่า"

ปุ่มข้อความมีความสำคัญมากใน Kafka แต่จะไม่มีประโยชน์ในการทดสอบของเรา ดังนั้นข้อความทั้งหมดจะเหมือนกัน

ตามที่กล่าวไว้ก่อนหน้านี้ ชุดข้อมูลนี้มีขนาดใหญ่มาก ดังนั้นฉันจึงจำกัดจำนวนข้อความที่แทรกไว้ที่ 500,000 ข้อความ

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

การดำเนินงาน:

spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/สตรีมมิ่ง/insert_traffic_topic.py

ทางด้านซ้ายงาน Spark จะอ่านไฟล์ ทางด้านขวาคือ a kafka-console-ผู้บริโภค แสดงข้อความที่มาถึง

หัวข้อการรับส่งข้อมูลของเรามีประชากรและเกือบจะพร้อมที่จะดำเนินการแล้ว

สิ่งสำคัญคือต้องจำไว้ว่าเราใช้งาน Spark เพื่อเติมหัวข้อของเราเพื่อการเรียนรู้เท่านั้น ในสถานการณ์จริง ตัวเซนเซอร์จะส่งค่าที่อ่านไปยังคาฟคาโดยตรง

เพื่อจำลองพฤติกรรมแบบไดนามิกนี้ สคริปต์ด้านล่างจะเขียน 1 แถวในหัวข้อทุกๆ 2.5 วินาที

โหมดเอาต์พุต — การนับจำนวนยานพาหนะตามประเภท

ต่อไปเรามาสร้างงานนับจำนวนรถตามประเภทกันดีกว่า

คอลัมน์ “Classificação” (การจัดประเภท) ประกอบด้วยประเภทยานพาหนะที่ตรวจพบ

ขณะที่เรากำลังอ่านจากหัวข้อนี้ เราจำเป็นต้องแปลงสตริงไบนารี่ของ JSON กลับเป็นรูปแบบคอลัมน์

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

ถึงเวลาที่จะกล่าวถึง โหมดเอาท์พุต() ตัวเลือก.

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

สามารถถือว่าค่าที่แตกต่างกันสามค่า:

• ผนวก: เพิ่มเฉพาะบันทึกใหม่ลงในเอาต์พุต
• สมบูรณ์: คำนวณผลลัพธ์ทั้งหมดใหม่สำหรับบันทึกใหม่แต่ละรายการ
• บันทึก: อัพเดตบันทึกที่เปลี่ยนแปลง

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

มาดำเนินงานในโหมด "สมบูรณ์" และดูผลลัพธ์

spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/สตรีมมิ่ง/group_by_vehicle_type.py

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

อย่างไรก็ตาม วิธีการนี้อาจไม่เหมาะสมหากจำนวนกลุ่มมากเกินไปหรือการเปลี่ยนแปลงแต่ละรายการไม่ส่งผลกระทบต่อผลลัพธ์โดยรวม

ดังนั้นอีกทางเลือกหนึ่งคือการใช้โหมดเอาต์พุต "อัปเดต" ซึ่งจะสร้างข้อความใหม่สำหรับกลุ่มที่มีการเปลี่ยนแปลงเท่านั้น ดูด้านล่าง:

โหมด "ผนวก" ไม่สามารถใช้ได้กับการค้นหาด้วยการจัดกลุ่ม ดังนั้นฉันจึงไม่สามารถแสดงโดยใช้งานเดียวกันได้ แต่ผมคิดว่ามันเป็นโหมดที่ง่ายที่สุดเลย เสมอ เพิ่มบันทึกใหม่ให้กับเอาต์พุต

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

กรอบเวลาไม้ลอย — การรวมโดยใช้ช่วงเวลา

ในระบบสตรีมมิ่ง ข้อความจะมีการประทับเวลาที่แตกต่างกันสองแบบที่เกี่ยวข้องกัน: เวลาเหตุการณ์ — เวลาที่ข้อความถูกสร้างขึ้น ในกรณีของเราคือเวลาในการอ่านของเซ็นเซอร์ และเวลาประมวลผล — เมื่อตัวแทนประมวลผลอ่านข้อความ ในกรณีของเราเมื่อ มันไปถึงสปาร์ค

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

ตัวอย่างเช่น นับทุกๆ 5 นาที จำนวนยานพาหนะที่ตรวจพบในช่วง 5 นาทีที่ผ่านมา

รหัสด้านล่างแสดงให้เห็นถึงสิ่งนี้:

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

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

กรอบเวลายังสามารถใช้ร่วมกับคอลัมน์อื่นๆ ใน กลุ่มโดย()- ตัวอย่างด้านล่างนับจำนวนยานพาหนะตามประเภทในช่วงเวลา 5 นาที

หน้าต่างเลื่อนเวลา — ความยืดหยุ่นตามช่วงเวลา

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

ตัวอย่างเช่น ทุกๆ 5 นาที ให้นับจำนวนยานพาหนะที่ตรวจพบในช่วง 30 นาทีที่ผ่านมา

ด้วยเหตุนี้ เหตุการณ์จึงสามารถอยู่ในหลายช่วงเวลาและสามารถนับได้หลายครั้งตามต้องการ

หากต้องการกำหนดหน้าต่างแบบเลื่อน เพียงผ่านช่วงเวลาการอัปเดตไปที่ หน้าต่าง() การทำงาน.

มาดูผลลัพธ์กันดีกว่า

ดังที่เราเห็น เรามีการสร้างหน้าต่าง 30 นาทีทุกๆ 5 นาที

ความยืดหยุ่นนี้ค่อนข้างมีประโยชน์ในการกำหนดกฎทางธุรกิจที่เฉพาะเจาะจงมากขึ้นและทริกเกอร์ที่ซับซ้อนมากขึ้น ตัวอย่างเช่น เครื่องตรวจจับรถติดของเราสามารถส่งคำตอบทุกๆ 5 วินาทีในช่วง 10 นาทีที่ผ่านมา และสร้างการแจ้งเตือนเมื่อความเร็วรถเฉลี่ยลดลงต่ำกว่า 20 กม./ชม.

นี่เป็นการสรุปแนวคิดหลักของ Spark Structured Streaming และวิธีการนำไปใช้กับ Kafka

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

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

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

นี่เป็นเพียงการดูคร่าวๆ อีกครั้ง และฉันจะทิ้งข้อมูลอ้างอิงไว้ด้านล่างหากคุณต้องการสำรวจให้ลึกยิ่งขึ้น

หวังว่าฉันจะช่วยได้ ขอบคุณที่อ่าน!

รหัสทั้งหมดมีอยู่ในนี้ พื้นที่เก็บข้อมูล GitHub.
ข้อมูลที่ใช้ — Contagens Volumétricas de Radares, เปิดข้อมูล, ผู้ว่าการรัฐบราซิล

[1] เจาะลึกฟีเจอร์: การใส่ลายน้ำในการสตรีมแบบมีโครงสร้าง Apache Spark - แม็กซ์ ฟิชเชอร์ บนบล็อก Databricks
[2] Chambers, B. , & Zaharia, M. (2018) Spark: คำแนะนำขั้นสุดท้าย: การประมวลผลข้อมูลขนาดใหญ่ทำได้ง่าย “โอไรลีย์ มีเดีย อิงค์”
[3] โลจิสติกส์ การจัดส่ง และการขนส่งแบบเรียลไทม์ด้วย Apache Kafka— ไค แวห์เนอร์
[4] นำเสนอ Apache Kafka ใน Netflix Studio และ Finance World - บล็อกที่ไหลมารวมกัน
(5) Spark สตรีมมิ่งและคาฟคา — https://sparkbyexamples.com/

ดูอย่างรวดเร็วของ Spark Structured Streaming + Kafka เผยแพร่ซ้ำจากแหล่งที่มา https://towardsdatascience.com/a-fast-look-at-spark-structured-streaming-kafka-f0ff64107325?source=rss—-7f60cf5620c9—4 ผ่าน https:/ /towardsdatascience.com/feed

<!–

->