Distributed Log Internals: เจาะลึก Partition, Offset, Replication และ Fault Tolerance


1. Distributed Log คืออะไร?

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

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

ตัวอย่างเทคโนโลยีที่ใช้แนวคิดนี้ ได้แก่ Apache Kafka และ Apache Pulsar

แนวคิดหลักของ Distributed Log ประกอบด้วย 4 ส่วนสำคัญ

  1. Partitioning: แบ่งข้อมูลออกเป็นส่วนย่อย
  2. Offset: ระบุตำแหน่งของข้อมูลในแต่ละ Partition
  3. Replication: ทำสำเนาข้อมูลไปยังโหนดอื่น
  4. Fault Tolerance: ออกแบบให้ระบบยังดำเนินงานหรือกู้คืนได้เมื่อเกิดความล้มเหลว

การทำความเข้าใจองค์ประกอบเหล่านี้เป็นพื้นฐานของการออกแบบ Event Streaming Platform และระบบ Data Engineering ขนาดใหญ่

2. โครงสร้างของ Distributed Log

สมมติว่าระบบอีคอมเมิร์ซต้องจัดการเหตุการณ์คำสั่งซื้อหลายล้านรายการต่อวัน

หากเก็บทุกเหตุการณ์ใน Log เดียวบนเครื่องเดียว ระบบอาจมีข้อจำกัดด้าน Throughput, Storage Capacity และความพร้อมใช้งาน

Distributed Log จึงแบ่งข้อมูลออกเป็นหลาย Partition

ตัวอย่าง:

                Event Producers

                       |

                       v

                Topic: orders

                       |

          +------------+------------+

          |            |            |

          v            v            v

     Partition 0  Partition 1  Partition 2

          |            |            |

          v            v            v

       Broker A     Broker B     Broker C

          |            |            |

          +------------+------------+

                       |

                       v

                Event Consumers

ภาพนี้แสดงแนวคิดการแบ่งข้อมูลเพื่อกระจายโหลดเท่านั้น ในระบบจริง Partition และ Replica อาจกระจายอยู่บน Broker หลายเครื่องตามการตั้งค่าและกลยุทธ์การจัดวางข้อมูล

ข้อสำคัญคือ Partition เป็นหน่วยแบ่งข้อมูลและลำดับของ Log ส่วน Broker เป็นโหนดที่ให้บริการจัดเก็บและรับส่งข้อมูล

สองสิ่งนี้มีหน้าที่แตกต่างกัน

3. Partition: กลไกแบ่งข้อมูลเพื่อรองรับการขยายระบบ

Partition คือส่วนย่อยของ Log ที่เก็บ Record ตามลำดับของตัวเอง

สมมติว่ามี Topic ชื่อ orders และแบ่งออกเป็น 3 Partition

Topic: orders


Partition 0

Offset 0 -> Order A

Offset 1 -> Order D

Offset 2 -> Order G


Partition 1

Offset 0 -> Order B

Offset 1 -> Order E

Offset 2 -> Order H


Partition 2

Offset 0 -> Order C

Offset 1 -> Order F

Offset 2 -> Order I

แต่ละ Partition มีลำดับ Offset ของตัวเอง จึงไม่จำเป็นต้องมีหมายเลข Offset ที่ไม่ซ้ำกันทั่วทั้ง Topic

3.1 Partition ช่วยเพิ่มประสิทธิภาพอย่างไร?

Partition ช่วยให้ระบบสามารถกระจายข้อมูลและประมวลผลหลายส่วนพร้อมกันได้

ตัวอย่างเช่น หากมี 3 Partition ระบบสามารถจัดสรรให้ Consumer หลายตัวอ่านข้อมูลจาก Partition ต่างกันพร้อมกันได้

อย่างไรก็ตาม จำนวน Partition ที่เพิ่มขึ้นไม่ได้ทำให้ Throughput เพิ่มขึ้นเป็นสัดส่วนเดียวกันเสมอไป เพราะยังมีข้อจำกัดจาก CPU, Disk, Network, จำนวน Consumer และรูปแบบการกระจายข้อมูล

3.2 Partition Key

ระบบมักใช้ Key เพื่อกำหนดว่า Record ควรถูกส่งไปยัง Partition ใด

ตัวอย่าง:

{

  "order_id": "ORD-1001",

  "customer_id": "CUS-001",

  "event_type": "OrderCreated"

}

หากใช้ customer_id เป็น Partition Key เหตุการณ์ของลูกค้าคนเดียวกันอาจถูกส่งไปยัง Partition เดียวกันตามกลยุทธ์การเลือก Partition

ข้อดีคือช่วยรักษาลำดับของเหตุการณ์ภายในขอบเขตที่กำหนด แต่การเพิ่มหรือลด Partition อาจเปลี่ยนการกระจาย Key ได้ และระบบไม่สามารถรับประกัน Global Ordering ข้ามทุก Partition โดยอัตโนมัติ

แนวทางเลือก Key: ควรเลือกข้อมูลที่ช่วยรักษาลำดับตามความต้องการของธุรกิจ และกระจายโหลดได้ดีโดยไม่ทำให้ Partition ใด Partition หนึ่งรับภาระมากเกินไป

4. Offset: ตำแหน่งของข้อมูลใน Log

Offset เป็นตัวระบุตำแหน่งของ Record ภายใน Partition

ตัวอย่าง:

Partition 0


Offset 0 -> OrderCreated

Offset 1 -> PaymentRequested

Offset 2 -> PaymentCompleted

Offset 3 -> OrderShipped

Offset 4 -> OrderDelivered

Consumer สามารถใช้ Offset เพื่อติดตามตำแหน่งที่อ่านข้อมูลถึง และกำหนดตำแหน่งที่จะอ่านต่อ

4.1 Consumer Offset

สมมติว่า Consumer อ่านข้อมูลถึง Offset 2 แล้วหยุดทำงาน

เมื่อกลับมาทำงานใหม่ ระบบสามารถใช้ตำแหน่งที่บันทึกไว้เพื่ออ่านข้อมูลต่อได้

แต่มีประเด็นสำคัญคือ Consumer Offset ไม่จำเป็นต้องหมายความว่าการประมวลผลธุรกิจของทุก Record ก่อนหน้านั้นสำเร็จแล้ว

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

ดังนั้น การจัดการ Offset ต้องสัมพันธ์กับขั้นตอนการประมวลผลและการบันทึกผลลัพธ์อย่างถูกต้อง

4.2 At-Least-Once และ At-Most-Once

รูปแบบการประมวลผลที่พบได้บ่อย ได้แก่

รูปแบบ

ความหมาย

ความเสี่ยง

At-most-once

ประมวลผลไม่เกินหนึ่งครั้งตามกลไกที่ออกแบบ

อาจสูญเสียการประมวลผลบางรายการ

At-least-once

พยายามให้ประมวลผลสำเร็จอย่างน้อยหนึ่งครั้ง

อาจประมวลผลซ้ำ

Exactly-once

ควบคุมผลลัพธ์ให้มีผลเพียงครั้งเดียวภายในขอบเขตที่กำหนด

ต้องใช้กลไกเพิ่มเติมและมีข้อจำกัดตามระบบ

การใช้ Offset เพียงอย่างเดียวไม่สามารถรับประกัน Exactly-once Processing ในทุกระบบได้

หาก Consumer ต้องเขียนข้อมูลลงฐานข้อมูลภายนอก ควรพิจารณา Idempotency, Transaction และการประสานสถานะการประมวลผลอย่างรอบคอบ

5. Replication: การทำสำเนาข้อมูล

Replication คือการเก็บสำเนาข้อมูลไว้บนหลายโหนด เพื่อลดความเสี่ยงจากการที่เครื่องใดเครื่องหนึ่งล้มเหลว

สมมติว่า Partition หนึ่งมี Replica จำนวน 3 ชุด

Partition 0


Broker A: Leader

Broker B: Follower

Broker C: Follower

ในรูปแบบที่ใช้ Leader-Follower เช่น Kafka Leader จะเป็นผู้รับผิดชอบการดำเนินงานอ่านและเขียนตามกลไกของระบบ ส่วน Follower จะติดตามข้อมูลจาก Leader

หาก Leader ล้มเหลว ระบบอาจเลือก Replica ที่เหมาะสมขึ้นมาทำหน้าที่แทนตามเงื่อนไขการเลือกตั้งและสถานะของ Replica

5.1 Replication Factor

Replication Factor คือจำนวนสำเนาของข้อมูลที่กำหนดให้จัดเก็บ

Replication Factor

จำนวนสำเนา

ผลโดยทั่วไป

1

1

ไม่มีสำเนาเพิ่มเติม

2

2

มีสำเนาเพิ่มเติม 1 ชุด

3

3

มีสำเนาเพิ่มเติม 2 ชุด

การเพิ่ม Replication Factor ช่วยเพิ่มความทนทานได้ แต่ต้องแลกกับพื้นที่จัดเก็บและต้นทุนการรับส่งข้อมูล

การมี Replica 3 ชุดไม่ได้หมายความว่าจะทนต่อความล้มเหลวได้ทุกกรณี เพราะผลลัพธ์ขึ้นอยู่กับการกระจาย Replica ไปยังเครื่องหรือ Availability Zone ที่แยกจากกัน ตลอดจนเงื่อนไขการยืนยันการเขียนข้อมูล

6. Fault Tolerance: การรับมือกับความล้มเหลว

Distributed System ต้องคาดการณ์ว่าความล้มเหลวสามารถเกิดขึ้นได้ตลอดเวลา เช่น

  • Broker หยุดทำงาน
  • Network ขาดการเชื่อมต่อ
  • Disk เสียหาย
  • Consumer หยุดทำงานระหว่างประมวลผล
  • ระบบปลายทางไม่สามารถบันทึกข้อมูลได้

การออกแบบ Fault Tolerance จึงต้องครอบคลุมทั้งการจัดเก็บ การรับส่ง และการประมวลผล

6.1 ตัวอย่างการกู้คืน

สมมติว่า Broker A เป็น Leader และ Broker B เป็น Follower

ก่อนเกิดความล้มเหลว


Broker A: Leader

Broker B: Follower

Broker C: Follower


          |

          v

Broker A fails


          |

          v


ระบบตรวจสอบสถานะ Replica

          |

          v

เลือก Leader ใหม่

          |

          v

Producer และ Consumer

กลับมาทำงานตามสถานะที่ระบบรองรับ

ขั้นตอนจริงขึ้นอยู่กับระบบที่ใช้และเงื่อนไขการเลือก Leader

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

7. Durability: ทำอย่างไรให้ข้อมูลไม่สูญหาย?

Durability คือคุณสมบัติที่ช่วยให้ข้อมูลที่ได้รับการยืนยันแล้วคงอยู่ได้ แม้เกิดความล้มเหลวตามขอบเขตที่ระบบออกแบบไว้

ปัจจัยสำคัญ ได้แก่

  1. การยืนยันการเขียนข้อมูล
  2. การทำ Replication
  3. การกำหนดจำนวน Replica ที่ต้องพร้อมก่อนยืนยันการเขียน
  4. การจัดการ Disk และ Filesystem
  5. การกู้คืนข้อมูลหลังความล้มเหลว

ใน Apache Kafka การตั้งค่า Producer Acknowledgment และเงื่อนไขของ In-Sync Replicas มีผลต่อความทนทานของข้อมูล

ตัวอย่างเช่น acks=all ทำให้ Producer รอการยืนยันจาก Replica ที่เกี่ยวข้องตามเงื่อนไขของ Kafka แต่ระดับความทนทานยังขึ้นอยู่กับการตั้งค่าอื่น เช่น min.insync.replicas และการจัดวาง Replica

จึงควรออกแบบการตั้งค่าร่วมกัน แทนการพึ่งพาค่าตัวเลือกใดตัวเลือกหนึ่ง

8. Consumer Group: การอ่านข้อมูลแบบขนาน

Consumer Group เป็นกลไกที่ช่วยให้ Consumer หลายตัวแบ่งกันอ่าน Partition ของ Topic เดียวกัน

ตัวอย่าง:

Topic: orders

   |

   +-- Partition 0 ---> Consumer A

   |

   +-- Partition 1 ---> Consumer B

   |

   +-- Partition 2 ---> Consumer C

ใน Consumer Group เดียวกัน แต่ละ Partition จะถูกกำหนดให้ Consumer ได้ไม่เกินหนึ่งตัวในช่วงเวลาที่ Assignment นั้นมีผล

หาก Topic มี 3 Partition การเพิ่ม Consumer เป็น 5 ตัวไม่ได้หมายความว่าจะมี Consumer ทั้ง 5 ตัวอ่านข้อมูลจาก Partition เดียวกันแบบขนานภายใน Group นั้นได้

จำนวน Partition จึงเป็นหนึ่งในปัจจัยที่กำหนดระดับการประมวลผลแบบขนานของ Consumer Group

อย่างไรก็ตาม สามารถมี Consumer Group หลายกลุ่มอ่าน Topic เดียวกันได้ แต่ละกลุ่มมี Offset และความคืบหน้าในการอ่านของตัวเอง

9. ตัวอย่างการออกแบบระบบจริง

สมมติว่าแพลตฟอร์มอีคอมเมิร์ซมีปริมาณคำสั่งซื้อสูง และต้องส่งข้อมูลไปยังระบบชำระเงิน ระบบคลังสินค้า และระบบวิเคราะห์ยอดขาย

สถาปัตยกรรมตัวอย่าง:

                E-Commerce Application

                          |

                          v

                    Order Service

                          |

                          v

                   Apache Kafka

                          |

              +-----------+-----------+

              |           |           |

              v           v           v

           Payment    Inventory    Analytics

           Service     Service      Service

              |           |           |

              v           v           v

          Payment DB   Stock DB    Data Platform

แนวทางออกแบบเบื้องต้น:

  • แบ่ง Topic ตามขอบเขตของข้อมูลหรือเหตุการณ์
  • เลือก Partition Key ให้สอดคล้องกับลำดับที่ต้องรักษา
  • กำหนด Replication Factor และนโยบายยืนยันการเขียนข้อมูล
  • ติดตาม Consumer Lag และอัตราการประมวลผล
  • ออกแบบการประมวลผลซ้ำให้ปลอดภัย
  • ใช้ Schema Management เพื่อควบคุมรูปแบบข้อมูล
  • ทดสอบกรณี Broker และระบบปลายทางล้มเหลว

สำหรับระบบที่ต้องบันทึกคำสั่งซื้อในฐานข้อมูลและเผยแพร่ Event ไปยัง Kafka ควรพิจารณา Transactional Outbox Pattern เพื่อลดปัญหาที่ข้อมูลในฐานข้อมูลสำเร็จ แต่การเผยแพร่ Event ล้มเหลว หรือกลับกัน

10. Metrics ที่ควรใช้ติดตามระบบ

การประเมิน Distributed Log ควรพิจารณาหลายมิติร่วมกัน

Metric

ความหมาย

Throughput

ปริมาณข้อมูลที่ระบบรับหรือประมวลผลได้ต่อหน่วยเวลา

Latency

เวลาที่ใช้ในการส่งหรือประมวลผลข้อมูล

Consumer Lag

ความล่าช้าของ Consumer เมื่อเทียบกับข้อมูลที่มีอยู่

Replication Lag

ความล่าช้าในการติดตามข้อมูลระหว่าง Replica

Disk Utilization

ปริมาณพื้นที่จัดเก็บที่ใช้งาน

Network Throughput

ปริมาณข้อมูลที่รับส่งผ่านเครือข่าย

Error Rate

อัตราความผิดพลาดในการทำงาน

ไม่ควรใช้ Throughput เพียงตัวเดียวตัดสินว่าระบบมีประสิทธิภาพดี เพราะระบบอาจมี Throughput สูงแต่ Latency สูง หรือมี Consumer Lag เพิ่มขึ้นต่อเนื่องได้

การทดสอบควรใช้ Workload ที่ใกล้เคียงกับการใช้งานจริง ทั้งขนาด Record จำนวน Partition และจำนวน Consumer

11. สรุป

Distributed Log เป็นองค์ประกอบสำคัญของระบบข้อมูลสมัยใหม่ โดยใช้ Partition เพื่อแบ่งข้อมูล ใช้ Offset เพื่อติดตามตำแหน่ง ใช้ Replication เพื่อเพิ่มความทนทาน และใช้ Consumer Group เพื่อกระจายการประมวลผล

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

ความคิดเห็น

โพสต์ยอดนิยมจากบล็อกนี้

อะไรคือ NPU (Neural Processing Unit) มีความสำคัญอย่างไร แนวคิดมาจากไหน

Micro SaaS "ขนาดพอดีคำ" สร้างธุรกิจเริ่มต้นอย่างง่ายด่าย จากไอเดียสู่สร้างรายได้ โดยใช้ AI Agent ตอบสนองความต้องการซอฟต์แวร์ที่เล็ก ง่าย และทรงพลัง

TomCat สำหรับติดตั้ง แก้ไข คอนฟิก ใช้งาน JSP