บันทึก

Durable Objects มาช่วยอะไร ในเมื่อเรามี D1 อยู่แล้ว

💻 Development

Worker + D1 เป็นพื้นฐาน ส่วน Durable Object เป็นตัวช่วยจัดการ State และ Coordination เฉพาะจุดที่จำเป็น

ช่วงนี้ผมใช้เวลาศึกษา Durable Objects ของ Cloudflare อยู่พักหนึ่ง คำถามแรกที่ค้างในหัวตั้งแต่เริ่มคือ เรามี Worker แล้ว มี D1 เป็นฐานข้อมูลแล้ว Worker ก็เรียก D1 ได้ตามปกติ แล้วจะต้องมี Durable Objects (ต่อไปขอเรียกสั้น ๆ ว่า DO) เพิ่มเข้ามาทำไม

พอเข้าใจแล้วก็รู้สึกว่าคำตอบไม่ได้ซับซ้อนอย่างที่คิด เลยอยากเล่าไว้แบบคร่าว ๆ เผื่อใครกำลังสงสัยเรื่องเดียวกัน

Worker ไม่มีความทรงจำ

ต้องเริ่มจากธรรมชาติของ Worker ก่อน Worker เป็น Stateless คือรับ Request มา ทำงาน ตอบกลับ แล้วก็จบ Request ถัดไปอาจไปตกที่ Instance อื่น หรืออยู่คนละประเทศเลยก็ได้ ตัวแปรที่เก็บไว้ใน Memory จึงเชื่อถือไม่ได้ ถ้าอยากจำอะไรต้องเขียนลง Storage อย่าง D1, KV หรือ R2

สำหรับงานส่วนใหญ่ เช่น CRUD, Login, User Profile, Post, Comment หรือกดโหวต แบบนี้ทำงานได้ดีอยู่แล้ว ทุก Worker ไปอ่านเขียนที่ D1 ซึ่งเป็นฐานข้อมูลกลางที่ทุกคนเข้าถึงร่วมกัน

ปัญหาเริ่มเมื่อต้องมี “ตัวกลาง”

ลองนึกถึง Chat Room ผู้ใช้ 50 คนในห้องเดียวกันเปิด WebSocket ค้างไว้ แต่ละ Connection อาจไปเกาะอยู่กับ Worker คนละตัว เมื่อมีคนพิมพ์ข้อความ ใครจะเป็นคนส่งต่อข้อความนั้นให้อีก 49 คน Worker แต่ละตัวไม่รู้จักกัน และไม่รู้ว่าใครอยู่ในห้องบ้าง

เราอาจพยายามใช้ D1 แก้ เช่น เขียนข้อความลงตารางแล้วให้ทุก Client คอยถามซ้ำ ๆ ว่ามีอะไรใหม่ไหม มันพอทำงานได้ แต่ไม่ใช่ Realtime จริง และเปลือง Request มาก

ปัญหาแบบนี้เรียกว่า Coordination คือระบบต้องการ “ตัวกลาง” ที่เป็นเจ้าของ State ของสิ่งนั้น รู้ว่าใครเชื่อมต่ออยู่ และควบคุมลำดับการเปลี่ยนแปลงข้อมูล เกม Multiplayer, Live Poll, Collaborative Editing หรือระบบจองที่นั่งที่ห้ามขายเกิน ล้วนต้องการตัวกลางแบบนี้

DO คือตัวกลางนั้น

DO คือ Object ที่มี Identity ของตัวเอง เราเขียน Class ขึ้นมาหนึ่ง Class แล้วสร้าง Object จาก Class นั้นได้เป็นจำนวนมาก แต่ละตัวมีชื่อ (ID) ไม่ซ้ำกัน และที่สำคัญคือ ทั้งโลกจะมี Object ที่ชื่อนั้นอยู่เพียงตัวเดียว

ถ้าเราตั้งชื่อ Object ตามห้องแชท Worker ทุกตัวที่ต้องการคุยกับห้อง room-42 จะถูกส่งไปหา DO ตัวเดียวกันเสมอ ไม่ว่าจะเรียกมาจากที่ไหน

const id = env.CHAT_ROOM.idFromName("room-42");
const room = env.CHAT_ROOM.get(id);
return room.fetch(request);

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

จากตรงนี้ ข้อดีหลายอย่างตามมาเอง

  • รู้จักทุก Connection WebSocket ของทุกคนในห้องมาเกาะอยู่ที่ DO ตัวเดียว การ Broadcast จึงเป็นแค่การวนส่งข้อความหาทุก Socket
  • ทำงานทีละเรื่อง DO ประมวลผลแบบ Single-threaded ไม่มี Request สองตัวมาแก้ State ทับกันพร้อมกัน ปัญหา Race Condition จำพวกอ่านค่าแล้วเขียนกลับจึงหายไปเยอะ
  • มี Storage ของตัวเอง DO แต่ละตัวมี SQLite ส่วนตัว ข้อมูลอยู่ติดกับ Code ที่ใช้มัน อ่านเขียนได้เร็วมาก และยังอยู่แม้ Object จะถูกปิดไปแล้ว
  • หลับได้เมื่อว่าง เมื่อไม่มีใครเรียกใช้ DO จะถูกปลดออกจาก Memory ถ้าใช้ WebSocket Hibernation API ก็ยังถือ Connection ไว้ได้โดยไม่ต้องเสียค่า Compute ระหว่างรอ และมี Alarm ไว้ปลุกตัวเองตามเวลาที่ตั้ง เช่น ปิดโพลเมื่อครบ 5 นาที

แล้ว D1 กับ DO ต่างกันตรงไหน

ผมสรุปให้ตัวเองแบบนี้

D1 คือฐานข้อมูลกลาง ใช้เก็บข้อมูลที่ทั้งระบบต้องเห็นร่วมกันและต้อง Query ข้ามกันได้ เช่น ผู้ใช้ทั้งหมด รายการห้องทั้งหมด ประวัติการโหวตย้อนหลัง

SQLite ใน DO คือสมุดบันทึกส่วนตัวของ Object ตัวนั้น เก็บ State ของสิ่งนั้นสิ่งเดียว เช่น ข้อความล่าสุดในห้อง สถานะเกมในตานี้ ผลโหวตที่กำลังนับอยู่ เราไม่สามารถ Query ข้าม DO หลายตัวพร้อมกันได้แบบ D1

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

ข้อควรระวัง

การที่ DO หนึ่งตัวทำงานทีละเรื่องเป็นทั้งจุดแข็งและข้อจำกัด Object หนึ่งตัวรับโหลดได้เท่าที่ Thread เดียวจะไหว ถ้าเราออกแบบให้ทุกอย่างวิ่งเข้า DO ตัวเดียว เช่น ตัวนับยอดวิวของทั้งเว็บ มันจะกลายเป็น Hot Object และเป็นคอขวดทันที

หลักคิดคือแบ่ง Object ตามหน่วยที่ต้อง Coordinate กันจริง ๆ หนึ่งห้องหนึ่ง Object หนึ่งเกมหนึ่ง Object หนึ่งเอกสารหนึ่ง Object แล้วจำนวน Object จะ Scale ไปเองตามจำนวนห้อง

อีกเรื่องคือค่าใช้จ่าย DO คิดเงินทั้งจำนวน Request, เวลาที่ Object ทำงานอยู่ใน Memory และ Storage ถ้าเผลอเขียน Code ที่ทำให้ Object ไม่ได้หลับ เช่น ใช้ setInterval ค้างไว้ หรือถือ WebSocket แบบไม่ใช้ Hibernation API ค่า Duration ก็จะเดินไปเรื่อย ๆ รายละเอียดเรื่อง Limit และราคาควรดูจาก เอกสารของ Cloudflare อีกครั้ง เพราะตัวเลขเปลี่ยนได้

สิ่งที่อยากจำไว้

ไม่จำเป็นต้องใช้ DO กับทุกฟีเจอร์ ระบบส่วนใหญ่เริ่มจาก Worker + D1 ก็เพียงพอแล้ว เพราะง่ายกว่าและเข้าใจง่ายกว่า

จะเพิ่ม DO ก็ต่อเมื่อเจอคำถามว่า “ใครเป็นเจ้าของ State นี้” หรือ “ใครจะเป็นคนบอกทุกคนว่ามีอะไรเปลี่ยน” ถ้าตอบไม่ได้ด้วย Worker + D1 นั่นแหละคือจุดที่ DO เข้ามาช่วย

ยังมีอีกหลายเรื่องที่ผมยังศึกษาไม่จบ ทั้ง Lifecycle ของ Object, การ Reconnect ของ WebSocket, Backup และการรับมือเมื่อเกิดความผิดพลาด ไว้ลองทำ Chat Room หรือ Live Poll เล่นจริงแล้วค่อยมาเขียนต่อ

ภาพประกอบสร้างขึ้นสำหรับบันทึกนี้