บทนำ
ถ้าคุณเคยทำงานกับ React มาก่อน คุณอาจเคยได้ยินชื่อ bulletproof-react คู่มือที่นำเสนอแนวทางอย่างชัดเจนและมีจุดยืน (opinionated guide) เพื่อให้ทีมมีมุมมองร่วมกันว่าจะจัดโครงสร้างแอปพลิเคชันอย่างไร ควรเลือกใช้แพตเทิร์นไหน และตรรกะแต่ละประเภทควรจัดวางไว้ตรงไหน คู่มือนี้ไม่ได้คิดค้นแนวคิดใหม่ขึ้นมาเอง หากแต่คัดสรรแนวทางที่พิสูจน์แล้วว่าใช้งานได้ผลจริงบนระบบ production แล้วจัดระเบียบให้ร้อยเรียงเป็นเนื้อเดียวกันอย่างเข้าใจง่าย
ผมจึงอยากให้มีแนวทางเช่นเดียวกันนี้สำหรับ Rust และ Axum และนั่นคือที่มาของคู่มือเล่มนี้ครับ
Axum ถูกออกแบบมาให้มีความมินิมอลโดยตั้งใจ สิ่งที่คุณได้คือเราเตอร์, ตัวแยกข้อมูล (extractor) และการเชื่อมต่อกับ Tower อย่างลึกซึ้ง หลังจากนั้นมันก็จะไม่เข้ามาวุ่นวายหรือก้าวก่ายงานของคุณอีก ความกระชับเรียบง่ายนี้ถือเป็นจุดแข็งที่แท้จริง แต่ในทางกลับกัน ก็หมายความว่าโปรเจกต์ Axum สองโปรเจกต์ที่สร้างโดยสองทีมที่แตกต่างกัน อาจมีหน้าตาของโครงสร้างโค้ดไม่เหมือนกันเลยแม้แต่น้อย ทีมหนึ่งอาจเขียน SQL ลงในแฮนด์เลอร์โดยตรง ขณะที่อีกทีมหนึ่งอาจสร้างสถาปัตยกรรมเฮกซะโกนัล (hexagonal architecture) อันซับซ้อนที่แยกเป็น 5 เครตในเวิร์กสเปซเดียว ซึ่งก็ไม่มีแนวทางใดที่ผิดเสียทีเดียว แต่ความไม่สอดคล้องกันเช่นนี้ทำให้การรับสมาชิกใหม่เข้าสู่ทีม (onboarding) ทำได้ยากขึ้น ดูแลรักษาระบบในระยะยาวได้ลำบากขึ้น และตัดสินใจได้ยากว่าตรรกะแต่ละส่วนควรวางไว้ที่ใด ผมเห็นปัญหานี้เกิดขึ้นซ้ำแล้วซ้ำเล่าจนมั่นใจว่านี่คือปัญหาจริงในการพัฒนา
สิ่งที่ผมตั้งใจทำในคู่มือนี้ คือการรวบรวมชุดคำตอบที่ผ่านการคัดสรรมาอย่างดีสำหรับคำถามเชิงโครงสร้างเหล่านี้ แนวคิดทั้งหมดได้รับแรงบันดาลใจจากสถาปัตยกรรมเฮกซะโกนัลและสถาปัตยกรรม Clean Architecture รวมถึงประสบการณ์จริงที่ผมสั่งสมมาจากบล็อกโพสต์, บทบรรยายในงานประชุม และโปรเจกต์โอเพนซอร์สจำนวนมากในชุมชน Rust web
หนังสือเล่มนี้ครอบคลุมอะไรบ้าง
หนังสือเล่มนี้แบ่งเนื้อหาออกเป็น 6 ส่วน ผมขอพาคุณไปดูภาพรวมสั้นๆ เพื่อให้เห็นว่าเนื้อหาแต่ละเรื่องอยู่ตรงไหน
สถาปัตยกรรม เป็นการวางรากฐานที่มั่นคง เราจะพูดถึงวิธีจัดระเบียบไฟล์และโมดูล วิธีคิดเรื่องเลเยอร์และทิศทางของ dependency ตลอดจนวิธีสร้างแบบจำลองโดเมน (domain modeling) โดยใช้ระบบชนิดข้อมูลของ Rust เพื่อทำให้สถานะที่ไม่ถูกต้องกลายเป็นสิ่งที่ไม่สามารถเกิดขึ้นได้ในโค้ด (unrepresentable) นี่คือสิ่งที่ผมอยากรู้ตั้งแต่เริ่มทำโปรเจกต์ Axum จริงจังครั้งแรก
แพตเทิร์นหลัก จัดการกับปัญหาที่เว็บแอปพลิเคชันทุกตัวต้องเผชิญ ไม่ว่าจะเป็นการจัดการข้อผิดพลาด (error handling), การเข้าถึงฐานข้อมูล, สถานะของแอปพลิเคชัน (application state) และการจัดการการตั้งค่า (configuration) คุณจะได้พบกับแพตเทิร์นที่เป็นรูปธรรมพร้อมโค้ดจริงที่สามารถนำไปปรับใช้ในโปรเจกต์ของคุณได้ทันที
เลเยอร์ HTTP เจาะลึกไปยังส่วนเฉพาะของ Axum ในสแตกทั้งหมด ได้แก่ การกำหนดเส้นทาง (routing), แฮนด์เลอร์, การประกอบมิดเดิลแวร์, การตรวจสอบความถูกต้องของคำขอ (request validation), การยืนยันตัวตน (authentication) ตลอดจนแบบแผนในการออกแบบ API เช่น การแบ่งหน้า (pagination) และการกำหนดเวอร์ชัน
การนำไปใช้งานจริง ครอบคลุมสิ่งจำเป็นที่คุณต้องใช้ในการส่งมอบและดูแลระบบจริงบน production ตั้งแต่การบันทึกข้อมูลแบบมีโครงสร้าง (structured logging) และ tracing, การเสริมความปลอดภัย, กลยุทธ์การทดสอบ, ข้อควรพิจารณาด้านประสิทธิภาพ ไปจนถึงการดีพลอยต์ด้วย Docker พร้อมกลไกการปิดระบบอย่างนุ่มนวล (graceful shutdown) เพราะการเขียนโค้ดเป็นเพียงแค่ครึ่งหนึ่งของงานทั้งหมดเท่านั้น
ขั้นสูง ก้าวข้ามโมเดล HTTP เซิร์ฟเวอร์เดี่ยวไปสู่แพตเทิร์นที่พบในระบบ production ที่มีความซับซ้อนสูง เราจะเจาะลึกจุดที่ต้องระวังเป็นพิเศษของ async ใน Rust (ความปลอดภัยเมื่อถูกยกเลิก หรือ cancellation safety, พฤติกรรมการทำงานของ select!), การสื่อสารระหว่างคอมโพเนนต์ผ่านแชนเนล, การปิดระบบอย่างสอดประสานกันของหลายซับซิสเต็ม, การจัดการงานเบื้องหลัง (background jobs), การเพิ่มพื้นผิว gRPC ด้วย Tonic และการสร้าง state machine ระดับเวลาคอมไพล์ด้วยแพตเทิร์นไทป์สเตต (typestate) บางเรื่องผมต้องใช้เวลานานกว่าจะตกผลึกได้ด้วยตัวเอง จึงหวังเป็นอย่างยิ่งว่าเนื้อหาส่วนนี้จะช่วยให้คุณประหยัดเวลาและไม่ต้องมาปวดหัวกับเรื่องเดิมๆ
อ้างอิง รวบรวมตารางสรุปเครตสำคัญที่ค้นหาได้อย่างรวดเร็ว, แคตตาล็อกแอนติแพตเทิร์นที่พบบ่อยเพื่อช่วยเตือนให้ระวัง และรายการหนังสือ บทความ ตลอดจนตัวอย่างรีพอสิทอรีที่คัดสรรมาสำหรับผู้ที่ต้องการศึกษาต่อในเชิงลึก
หลักการชี้นำ
มีค่านิยมบางประการที่สอดแทรกอยู่ในทุกคำแนะนำของหนังสือเล่มนี้ สิ่งเหล่านี้ไม่ใช่แนวคิดใหม่ที่ผมคิดขึ้นมาเอง แต่เป็นหลักการที่ผมมักจะวนกลับมาใช้เป็นเข็มทิศอยู่เสมอ
ทำให้แฮนด์เลอร์บางที่สุด (Keep handlers thin) หน้าที่ของแฮนด์เลอร์มีเพียงแค่ดึงข้อมูลออกจากคำขอ เรียกใช้เซอร์วิส แล้วแปลงผลลัพธ์ให้เป็นการตอบกลับ (response) เท่านั้น หากแฮนด์เลอร์ของคุณต้องทำทั้งการตรวจสอบความถูกต้อง คิวรีฐานข้อมูล และประมวลผลตรรกะทางธุรกิจในฟังก์ชันเดียว แสดงว่ามันกำลังทำงานมากเกินไปแล้ว ผมเห็นแฮนด์เลอร์ยาว 200 บรรทัดมามากพอที่จะรู้ว่าหนทางนั้นจะนำไปสู่อะไร ดังนั้น จงผลักภาระงานเหล่านั้นไปยังเลเยอร์ที่เหมาะสม
ให้ระบบชนิดข้อมูลทำงานแทนเรา (Let the type system do the work) ระบบชนิดข้อมูลของ Rust ทรงพลังเป็นพิเศษเมื่อเทียบกับภาษาเชิงระบบทั่วไป และจากประสบการณ์ของผม มันเปล่งประกายอย่างเด่นชัดมากในเว็บแอปพลิเคชัน นิวไทป์ (newtype) ที่ช่วยบังคับเงื่อนไขคงสภาพ (invariant) ตั้งแต่ขั้นตอนการสร้างค่า, ชนิดข้อมูล Result ที่ระบุเส้นทางการจัดการข้อผิดพลาดอย่างชัดเจนเปิดเผย และการสร้างนามธรรมด้วย trait เพื่อลดการผูกมัด (decouple) ระหว่างแต่ละเลเยอร์ สิ่งเหล่านี้ช่วยดักจับบั๊กได้ตั้งแต่ตอนคอมไพล์ แทนที่จะหลุดรอดไปสร้างปัญหาบน production ตอนตีสอง ซึ่งคุ้มค่ากับความพยายามตั้งแต่แรกเริ่มเสมอ
แยกสิ่งที่เปลี่ยนแปลงด้วยเหตุผลที่ต่างกัน (Separate what changes for different reasons) เส้นทาง HTTP ของคุณอาจเปลี่ยนเพราะมีการเพิ่มเอนด์พอยต์ใหม่ คิวรีฐานข้อมูลอาจเปลี่ยนเพราะคุณต้องการเพิ่มประสิทธิภาพในจุดที่ช้า กฎเกณฑ์ทางธุรกิจอาจเปลี่ยนเพราะความต้องการของผลิตภัณฑ์พัฒนาไป เมื่อความรับผิดชอบเหล่านี้แยกอยู่ในคนละโมดูลที่มีขอบเขตชัดเจน คุณจะสามารถแก้ไขส่วนหนึ่งได้โดยไม่ต้องกังวลว่าจะกระทบส่วนอื่น ฟังดูเป็นเรื่องธรรมดา แต่ในทางปฏิบัติกลับง่ายมากที่เราจะเผลอปล่อยให้โค้ดแต่ละส่วนปะปนกันจนยุ่งเหยิง
เริ่มจากเรียบง่าย แล้วค่อยต่อยอดอย่างตั้งใจ (Start simple, evolve deliberately) ไม่ใช่ทุกโปรเจกต์ที่จะต้องเริ่มต้นด้วยสถาปัตยกรรมเฮกซะโกนัลและแยก 5 เครตในเวิร์กสเปซ API ขนาดเล็กที่มีเพียงไม่กี่เอนด์พอยต์สามารถเริ่มต้นด้วยโครงสร้างโมดูลแบบเรียบง่ายและเรียกใช้ SQLx โดยตรงได้ สิ่งสำคัญคือการเข้าใจหลักการเบื้องหลังสถาปัตยกรรมที่ซับซ้อนกว่า เพื่อให้คุณสามารถขยับขยายไปสู่จุดนั้นได้อย่างเป็นขั้นเป็นตอนเมื่อความซับซ้อนของระบบเรียกร้องจริงๆ แทนที่จะ over-engineer ตั้งแต่เริ่มต้น หรือต้องมารีแฟกเตอร์กันวุ่นวายเมื่อโครงสร้างเดิมเริ่มรับมือไม่ไหว
ให้ความสำคัญกับผู้อ่านโค้ดเป็นอันดับแรก (Optimize for the reader) โค้ดถูกอ่านบ่อยกว่าถูกเขียนเสมอ เรารู้ความจริงข้อนี้กันดี แต่ก็มักจะลืมได้ง่ายเมื่ออยู่ใต้ความกดดัน แพตเทิร์นในคู่มือนี้จึงให้ความสำคัญกับความชัดเจนและความตรงไปตรงมามากกว่าการเขียนโค้ดที่ดูฉลาดจนเกินไป เมื่อมีเพื่อนร่วมทีมคนใหม่เข้ามาและเปิดดูโค้ดเบสเป็นครั้งแรก พวกเขาควรจะค้นหาสิ่งที่ต้องการพบได้อย่างรวดเร็ว และเข้าใจได้ทันทีว่าทำไมโครงสร้างถึงถูกจัดวางไว้เช่นนั้น
วิธีใช้คู่มือนี้
คุณไม่จำเป็นต้องอ่านคู่มือนี้เรียงตามลำดับตั้งแต่หน้าแรกจนถึงหน้าสุดท้าย หากคุณกำลังเริ่มต้นโปรเจกต์ใหม่ เนื้อหาในส่วนสถาปัตยกรรมจะช่วยให้คุณวางรากฐานที่มั่นคง แต่หากคุณกำลังทำงานกับโปรเจกต์เดิมที่มีอยู่แล้วและต้องการปรับปรุงเฉพาะจุด คุณสามารถข้ามไปยังบทที่เกี่ยวข้องได้ทันที แต่ละบทมีความสมบูรณ์ในตัวเองเพียงพอที่จะอ่านแยกเดี่ยวได้ แม้จะมีการอ้างอิงข้ามบทในหัวข้อที่มีความเกี่ยวเนื่องกันบ้างก็ตาม
ผมพยายามทำให้ตัวอย่างโค้ดมีความสมจริงที่สุด โดยใช้ API จากเครตจริงในแบบที่คุณจะนำไปใช้งานจริงบน production พร้อมการจัดการข้อผิดพลาดที่ถูกต้องและระบุ type signature ชัดเจน ไม่มีการใส่โค้ดหลอกๆ อย่าง todo!() ไว้ในส่วนที่ยาก และในจุดที่มีข้อแลกเปลี่ยน (trade-off) สำคัญระหว่างแต่ละแนวทาง ผมจะอธิบายทั้งสองทางเลือกพร้อมบริบทที่เพียงพอ เพื่อให้คุณตัดสินใจเลือกแนวทางที่เหมาะสมที่สุดสำหรับสถานการณ์ของคุณ
อีกประการหนึ่ง: เอกสารชุดนี้คือเอกสารที่มีชีวิต (living document) ระบบนิเวศเว็บของ Rust ยังคงเติบโตและพัฒนาอย่างรวดเร็ว สิ่งที่เรามองว่าเป็นแนวปฏิบัติที่ดีที่สุดในวันนี้ย่อมได้รับการปรับปรุงต่อไปในอนาคต ทว่าหลักการพื้นฐานมักจะมีความยั่งยืนและมั่นคงกว่าตัวเครตหรือ API เฉพาะเจาะจง และนั่นคือจุดที่ผมเชื่อว่าคุณค่าที่แท้จริงของคู่มือเล่มนี้สถิตอยู่ ถ้าพร้อมแล้ว เรามาเริ่มกันเลยครับ