แอนติแพตเทิร์น
ทุกโปรเจกต์เว็บใน Rust ที่ผมเคยร่วมงานด้วย ล้วนเคยสะดุดกับความผิดพลาดเดิมๆ ซ้ำแล้วซ้ำเล่า บางอย่างผมเป็นคนก่อขึ้นมาเอง บางอย่างผมช่วยดักจับได้ระหว่างการรีวิวโค้ด และมีอีกไม่น้อยที่ผมได้รับสืบทอดมาจากโค้ดเบสรุ่นก่อน ซึ่งมอบบทเรียนราคาแพงให้ผมอย่างเจ็บปวด บทนี้จึงได้รวบรวมข้อผิดพลาดที่ผมพบบ่อยที่สุด อธิบายเหตุผลว่าทำไมสิ่งเหล่านั้นถึงส่งผลเสียต่อระบบของคุณ และชี้ทางเลือกที่ดีกว่าซึ่งได้แนะนำไว้ในบทอื่นๆ ของหนังสือเล่มนี้
SQL ในแฮนด์เลอร์
หน้าตาเป็นแบบนี้: ฟังก์ชันแฮนด์เลอร์ที่มีการเรียกใช้ sqlx::query! โดยตรง มีการจัดการทรานแซกชัน และแมปข้อผิดพลาดของฐานข้อมูลอยู่ภายในบอดี้ของแฮนด์เลอร์ HTTP
ทำไมถึงสร้างปัญหา: มันจะผูกมัดเลเยอร์ HTTP ของคุณเข้ากับสกีมาของฐานข้อมูลอย่างถาวร คุณจะไม่สามารถทดสอบแฮนด์เลอร์ได้เลยหากไม่มีฐานข้อมูลจริง และไม่สามารถนำตรรกะการคิวรีกลับมาใช้ซ้ำจากจุดเริ่มต้นอื่น (เช่น คำสั่ง CLI, เวิร์กเกอร์เบื้องหลัง หรือแฮนด์เลอร์ตัวอื่น) ได้เลย นอกจากนี้ เมื่อใดก็ตามที่คิวรีเปลี่ยน คุณจะต้องกลับมาแก้ไขไฟล์ที่ควรจะรับผิดชอบเฉพาะเรื่องของ HTTP
ควรทำอย่างไรแทน: ย้ายโค้ดส่วนการเข้าถึงฐานข้อมูลเข้าไปไว้ใน struct ของรีพอสิทอรีหรือคิวรี ตามที่เราได้อธิบายไว้ในบท เลเยอร์ฐานข้อมูล โดยแฮนด์เลอร์ควรทำหน้าที่เพียงเรียกใช้เมธอดของเซอร์วิสหรือรีพอสิทอรี และทำงานกับชนิดข้อมูลฝั่งโดเมนเท่านั้น โดยไม่ควรแตะต้อง SQL หรือชนิดข้อมูลข้อผิดพลาดเฉพาะของฐานข้อมูลโดยตรง
กรณีที่ยอมรับได้จริงๆ: สำหรับไมโครเซอร์วิสขนาดเล็กแบบ CRUD ที่แต่ละเอนด์พอยต์แมปตรงไปยังคิวรีเพียงหนึ่งหรือสองตัว และไม่มีแนวโน้มที่จะต้องมีจุดเริ่มต้นอื่น การเขียน SQL ในแฮนด์เลอร์อาจถือเป็นการลดความซับซ้อนที่สมเหตุสมผล โปรเจกต์อ้างอิงอย่าง launchbadge/realworld-axum-sqlx ก็เลือกใช้แนวทางนี้โดยตั้งใจ ซึ่งคิวรีแบบอินไลน์ของพวกเขามีโครงสร้างที่ดีและอ่านเข้าใจง่าย หัวใจสำคัญคือการเลือกใช้วิธีนี้ด้วยความตระหนักรู้และมีเจตนาชัดเจน ไม่ใช่เลือกเพราะเป็นค่าเริ่มต้น และต้องรู้ตัวเมื่อแฮนด์เลอร์เริ่มสะสมตรรกะการคิวรีมากจนถึงจุดที่ควรแยกเลเยอร์ออกไป หากคุณพบว่าตัวเองเริ่มเขียนคิวรีซ้ำข้ามแฮนด์เลอร์ หรือแฮนด์เลอร์เริ่มจัดการคิวรีหลายตัวที่ต้องสำเร็จหรือล้มเหลวไปพร้อมกัน นั่นคือสัญญาณเตือนว่าถึงเวลาต้องนำเลเยอร์รีพอสิทอรีหรือเซอร์วิสเข้ามาช่วยแล้ว
แฮนด์เลอร์อ้วน
หน้าตาเป็นแบบนี้: แฮนด์เลอร์ที่รับผิดชอบทุกอย่างในฟังก์ชันเดียว ตั้งแต่ตรวจสอบความถูกต้องของอินพุต, แฮชรหัสผ่าน, คิวรีฐานข้อมูล, ส่งอีเมลแจ้งเตือน, เผยแพร่อีเวนต์ ไปจนถึงประกอบการตอบกลับ HTTP
ทำไมถึงสร้างปัญหา: มันทำให้แฮนด์เลอร์ไม่สามารถแยกทดสอบแบบเดี่ยวๆ ได้ ยากต่อการทำความเข้าใจ และแก้ไขได้ลำบากอย่างยิ่ง อีกทั้งหากต้องการเพิ่มจุดเริ่มต้นที่สองสำหรับตรรกะทางธุรกิจชุดเดียวกัน (เช่น เอนด์พอยต์สำหรับผู้ดูแลระบบ หรือคอนซูเมอร์ของคิวข้อความ) คุณก็จำเป็นต้องคัดลอกตรรกะทั้งหมดเหล่านั้นซ้ำอีกรอบ
ควรทำอย่างไรแทน: รักษาแฮนด์เลอร์ของคุณให้ผอมเพรียว (thin handlers) โดยสกัดตรรกะทางธุรกิจออกไปไว้ในเมธอดของเซอร์วิสในเลเยอร์โดเมน หน้าที่ของแฮนด์เลอร์มีเพียงดึงข้อมูลจากคำขอ เรียกใช้เมธอดของเซอร์วิส และส่งคืนการตอบกลับเท่านั้น หากแฮนด์เลอร์ของคุณยาวเกิน 15 ถึง 20 บรรทัด แสดงว่ามันน่าจะรับหน้าที่มากเกินไปแล้ว
การใช้ unwrap() ในเส้นทางของคำขอ
หน้าตาเป็นแบบนี้: การเรียกใช้ .unwrap() หรือ .expect() บนค่า Result หรือ Option ภายในแฮนด์เลอร์หรือในโค้ดส่วนใดก็ตามที่ทำงานระหว่างการประมวลผลคำขอ
ทำไมถึงสร้างปัญหา: การเกิด panic ภายในแฮนด์เลอร์จะทำให้คำขอนั้นล้มเหลวและส่งข้อผิดพลาด 500 ที่คลุมเครือกลับไป ยิ่งไปกว่านั้น หากเกิด panic ในขณะที่กำลังถือครอง mutex อยู่ มันจะทำให้ mutex นั้นกลายเป็นพิษ (poisoned) จนลุกลามไปส่งผลกระทบต่อคำขออื่นๆ ทั้งระบบ ไคลเอนต์จะไม่ได้รับข้อมูลข้อผิดพลาดที่เป็นประโยชน์ และล็อกของคุณก็อาจเก็บข้อมูลบริบทได้ไม่ครบถ้วน
ควรทำอย่างไรแทน: ให้ใช้โอเปอเรเตอร์ ? เสมอในการส่งต่อข้อผิดพลาดผ่านชนิดข้อมูล Result หากต้องการแปลง Option ให้เป็นข้อผิดพลาด ให้ใช้ .ok_or(AppError::NotFound)? หรือรูปแบบที่ใกล้เคียงกัน จงสงวนการใช้ unwrap() ไว้เฉพาะกรณีที่คุณพิสูจน์ได้อย่างแน่นอนว่าค่านั้นมีอยู่เสมอ (เช่น regex ที่ฮาร์ดโค้ดไว้) และเก็บ expect() ไว้สำหรับโค้ดช่วงเริ่มต้นระบบ (startup) ซึ่งหากค่านั้นขาดหายไป แอปพลิเคชันก็ไม่ควรทำงานต่อได้ตั้งแต่แรก
การปล่อยให้ชนิดข้อมูลฐานข้อมูลรั่วเข้าไปใน API
หน้าตาเป็นแบบนี้: การส่งคืน struct ตัวเดียวกันจากเลเยอร์ฐานข้อมูลไปยังแฮนด์เลอร์ HTTP หรือการ derive ทั้ง sqlx::FromRow และ serde::Serialize บนชนิดข้อมูลเดียวกัน แล้วส่งคืนกลับไปตรงๆ ในรูป Json<UserRow>
ทำไมถึงสร้างปัญหา: หมายความว่าการเพิ่มคอลัมน์ใหม่ในฐานข้อมูล จะเป็นการเพิ่มฟิลด์นั้นเข้าไปในผลลัพธ์ของ API โดยอัตโนมัติ หากคอลัมน์ดังกล่าวเก็บข้อมูลที่ละเอียดอ่อน (เช่น รหัสผ่านที่แฮชแล้ว, แฟล็กภายในระบบ หรือสถานะการลบแบบ soft-delete) ข้อมูลเหล่านั้นจะหลุดไปให้ผู้เรียกใช้ API ทุกคนเห็นทันที นอกจากนี้ การเปลี่ยนชื่อหรือปรับโครงสร้างคอลัมน์ในฐานข้อมูลจะกลายเป็นการทำลายความเข้ากันได้ของ API (breaking change) โดยไม่ตั้งใจ
ควรทำอย่างไรแทน: แยกชนิดข้อมูลออกจากกันให้ชัดเจนตามแต่ละขอบเขตการทำงาน ตามที่เราได้แนะนำไว้ในบท การสร้างแบบจำลองโดเมน ให้ UserRow ทำหน้าที่แมปกับฐานข้อมูล, User ทำหน้าที่เป็นตัวแทนของเอนทิตีฝั่งโดเมน และ UserResponse ทำหน้าที่กำหนดข้อตกลง (contract) ของ API จากนั้นใช้การอิมพลีเมนต์ From อย่างชัดเจนเพื่อเชื่อมโยงข้อมูลข้ามขอบเขต ซึ่งจะช่วยให้การแปลงข้อมูลตรวจสอบได้ง่าย
การเปิดเผยข้อผิดพลาดภายในให้ไคลเอนต์เห็น
หน้าตาเป็นแบบนี้: การส่งคืนข้อความแจ้งข้อผิดพลาดแบบดิบๆ จากฐานข้อมูล, ระบบไฟล์ หรือการเรียกเซอร์วิสภายใน กลับไปในบอดี้ของการตอบกลับ HTTP โดยตรง
ทำไมถึงสร้างปัญหา: ข้อความแจ้งข้อผิดพลาดภายในมักแฝงไปด้วยชื่อตารางฐานข้อมูล, พาธของไฟล์, คำสั่งคิวรี SQL, สแตกเทรซ และข้อมูลเชิงลึกอื่นๆ ที่เปิดโอกาสให้ผู้ไม่หวังดีเข้าใจโครงสร้างภายในของระบบได้ แม้จะไม่มีการโจมตี แต่ข้อความเหล่านี้ก็สร้างความสับสนให้แก่ผู้ใช้งาน API อยู่ดี เพราะมันอธิบายรายละเอียดเชิงเทคนิคของการนำไปใช้ แทนที่จะอธิบายปัญหาในเชิงธุรกิจที่เกิดขึ้นจริง
ควรทำอย่างไรแทน: บันทึกรายละเอียดข้อผิดพลาดฉบับเต็มไว้ที่ฝั่งเซิร์ฟเวอร์ด้วยระดับล็อก error แล้วส่งคืนข้อความระดับทั่วไปที่ผู้ใช้ควรรู้กลับไปให้ไคลเอนต์ ซึ่งวาเรียนต์ AppError::Internal ที่เราได้แนะนำไว้ในบท การจัดการข้อผิดพลาด สามารถจัดการกับแพตเทิร์นนี้ได้อย่างเรียบร้อยและปลอดภัย
ความลับแบบฮาร์ดโค้ด
หน้าตาเป็นแบบนี้: การกำหนดค่า JWT secret หรือรหัสผ่านฐานข้อมูลเป็นข้อความแบบสตริงลิเทอรัลไว้ในซอร์สโค้ดโดยตรง หรือการเผลอคอมมิตไฟล์ .env เข้าสู่ระบบควบคุมเวอร์ชัน (Git)
ทำไมถึงสร้างปัญหา: ใครก็ตามที่สามารถเข้าถึงซอร์สโค้ด (หรือประวัติการคอมมิตใน Git) จะได้กุญแจสำคัญสำหรับระบบ production ของคุณไปทันที ซึ่งรวมถึงนักพัฒนาทุกคนในทีม, ระบบ CI ทุกตัวที่ดึงโค้ดไปบิลด์ และใครก็ตามที่พบเจตรีโพสิทอรีนี้หากวันใดวันหนึ่งมันถูกเปิดเป็นสาธารณะโดยไม่ตั้งใจ
ควรทำอย่างไรแทน: โหลดค่าความลับต่างๆ จากตัวแปรสภาพแวดล้อม (environment variables) ตามที่เราได้แนะนำไว้ในบท การตั้งค่า และใช้ SecretString จากเครต secrecy เพื่อช่วยปกป้องข้อมูลในหน่วยความจำ พร้อมทั้งใส่ .env ลงใน .gitignore และเตรียมไฟล์ .env.example เพื่อบันทึกรายชื่อตัวแปรที่จำเป็นทั้งหมดโดยไม่ต้องใส่ค่าจริงลงไป
การอิมพอร์ตข้ามเลเยอร์
หน้าตาเป็นแบบนี้: การที่โมดูลโดเมนไปอิมพอร์ตบางสิ่งจากโมดูล api (เช่น ชนิดข้อมูลตัวแยกข้อมูลของ Axum) หรือจากโมดูล infra (เช่น PgPool)
ทำไมถึงสร้างปัญหา: มันทำลายกฎทิศทางของดีเพนเดนซี (dependency rule) ซึ่งเป็นหัวใจสำคัญของ Clean Architecture หากโดเมนต้องพึ่งพา Axum คุณจะไม่สามารถนำตรรกะโดเมนนั้นไปใช้ในเครื่องมือ CLI ได้เลยโดยไม่ดึงเฟรมเวิร์ก HTTP ทั้งหมดตามไปด้วย และหากโดเมนต้องพึ่งพา SQLx คุณจะไม่สามารถทดสอบโดเมนได้เลยหากไม่มีฐานข้อมูลจริงรองรับ
ควรทำอย่างไรแทน: ทิศทางของดีเพนเดนซีต้องชี้เข้าหาแกนกลางเสมอ: เลเยอร์ API ต้องพึ่งพาโดเมน, เลเยอร์โครงสร้างพื้นฐานต้องพึ่งพาโดเมน แต่ตัวโดเมนจะต้องไม่พึ่งพาสิ่งใดจากภายนอก หากโดเมนจำเป็นต้องใช้ฟังก์ชันการทำงานจากโลกภายนอก ให้โดเมนนิยามเทรต (พอร์ต) ขึ้นมา แล้วให้เลเยอร์โครงสร้างพื้นฐานเป็นผู้นำไปอิมพลีเมนต์ (ในฐานะอะแดปเตอร์) ซึ่งเราได้ครอบคลุมเรื่องนี้อย่างละเอียดไว้แล้วในบทสถาปัตยกรรม
การบล็อก async runtime
หน้าตาเป็นแบบนี้: การเรียกใช้ฟังก์ชันที่ทำงานหนักบน CPU (เช่น การแฮชรหัสผ่านด้วย Argon2), การทำ I/O กับไฟล์แบบซิงโครนัส หรือการเรียกใช้ไลบรารีแบบบล็อกกิ้ง ภายในแฮนด์เลอร์แบบ async โดยตรง
ทำไมถึงสร้างปัญหา: รันไทม์ของ Tokio ใช้เธรดเวิร์กเกอร์จำนวนไม่มากเพื่อสลับกันประมวลผลทาสก์ async จำนวนมหาศาลแบบสมานฉันท์ (cooperatively) หากมีทาสก์ใดเข้าไปบล็อกเธรดนั้นไว้เพียงเธรดเดียว ทาสก์อื่นๆ ทั้งหมดที่เข้าคิวอยู่บนเธรดดังกล่าวจะไม่สามารถทำงานต่อได้ เมื่อระบบมีโหลดสูง อาการนี้จะทำให้ค่าความหน่วง (latency) พุ่งสูงขึ้นอย่างรวดเร็วและ throughput ลดฮวบ ซึ่งเป็นปัญหาที่ตรวจวิเคราะห์สาเหตุได้ยากมาก
ควรทำอย่างไรแทน: ให้ใช้ tokio::task::spawn_blocking() สำหรับงานที่กินทรัพยากร CPU หนักๆ หรืองานที่เป็นบล็อกกิ้ง, เปลี่ยนมาใช้ tokio::fs แทน std::fs, และตรวจสอบให้แน่ใจว่าไดรเวอร์ฐานข้อมูลของคุณทำงานแบบ async อย่างแท้จริง (เช่น SQLx และ diesel-async เป็น async แท้ ส่วน Diesel รุ่นพื้นฐานไม่ใช่)
ค่าโดเมนที่ใช้ String เป็นชนิด
หน้าตาเป็นแบบนี้: การใช้ชนิดข้อมูล String ธรรมดาๆ เป็นตัวแทนของอีเมล, ชื่อผู้ใช้ และค่าข้อมูลทางธุรกิจอื่นๆ กระจัดกระจายไปทั่วทั้งแอปพลิเคชัน
ทำไมถึงสร้างปัญหา: ฟังก์ชันที่รับพารามิเตอร์เป็น (String, String, String) สำหรับชื่อ, อีเมล และรหัสผ่าน สามารถถูกเรียกใช้งานโดยส่งอาร์กิวเมนต์สลับลำดับกันได้อย่างง่ายดาย โดยที่คอมไพเลอร์ไม่สามารถตรวจจับความผิดพลาดนี้ได้เลย นอกจากนี้ คุณยังสูญเสียจุดศูนย์กลางในการควบคุมกฎเกณฑ์ความถูกต้อง (อินแวเรียนต์ เช่น “อีเมลต้องมีเครื่องหมาย @”) ส่งผลให้ตรรกะการตรวจสอบความถูกต้องกระจัดกระจายไปทั่วทั้งโค้ดเบส
ควรทำอย่างไรแทน: ใช้แพตเทิร์น newtype ตามที่เราได้แนะนำไว้ในบท การสร้างแบบจำลองโดเมน โดยการสร้างชนิดข้อมูลเฉพาะตัวอย่าง Email, UserName และ UserId ที่มีกระบวนการบังคับใช้อินแวเรียนต์ตั้งแต่ขั้นตอนการสร้างค่า (construction time) แม้ว่าในช่วงแรกอาจดูเหมือนมีโค้ด boilerplate เพิ่มขึ้นมาบ้าง แต่มันจะตอบแทนคุณอย่างคุ้มค่าในระยะยาว
การขาด health check
หน้าตาเป็นแบบนี้: แอปพลิเคชันที่ถูกดีพลอยต์ขึ้นสู่ระบบ Container Orchestrator โดยไม่มีเอนด์พอยต์สำหรับการตรวจสุขภาพ (health check) หรือมีการใช้ liveness probe ไปตรวจสอบดีเพนเดนซีภายนอก
ทำไมถึงสร้างปัญหา: หากไม่มีระบบตรวจสุขภาพ ตัว Orchestrator จะไม่มีทางทราบได้เลยว่าแอปพลิเคชันของคุณยังทำงานได้ตามปกติหรือไม่ มันจึงไม่สามารถสั่งรีสตาร์ตโพรเซสที่ค้าง หรือหยุดส่งทราฟฟิกไปยังอินสแตนซ์ที่ขาดการเชื่อมต่อกับฐานข้อมูลได้ และในทางกลับกัน การตั้งค่า liveness probe ให้ตรวจสอบฐานข้อมูล จะทำให้เกิดการรีสตาร์ตระบบโดยไม่จำเป็นเมื่อฐานข้อมูลหยุดทำงานชั่วคราว ซึ่งรังแต่จะทำให้สถานการณ์เลวร้ายลงไปอีก
ควรทำอย่างไรแทน: อิมพลีเมนต์ liveness probe และ readiness probe แยกจากกันอย่างชัดเจน ตามที่อธิบายไว้ในบท การดีพลอยต์ โดย liveness probe ควรทำงานแบบไม่มีเงื่อนไข (ตอบกลับทันทีว่าตัวแอปยังไม่ตาย) ส่วน readiness probe ให้ทำหน้าที่ตรวจสอบความพร้อมของดีเพนเดนซีต่างๆ
การออกแบบเกินจำเป็นตั้งแต่เริ่ม
หน้าตาเป็นแบบนี้: โปรเจกต์ใหม่ที่เพิ่งเริ่มต้นแต่กลับแบ่ง workspace ออกเป็นสามเครต, มีรีพอสิทอรีแบบครอบด้วยเทรตพร้อมเจเนอริกเซอร์วิส, วางแพตเทิร์น CQRS และติดตั้ง event bus ทั้งหมดนี้ทำขึ้นเพื่อรองรับแอปพลิเคชันที่มีเอนด์พอยต์ CRUD เพียง 5 ตัว
ทำไมถึงสร้างปัญหา: การสร้างนามธรรมเร็วเกินไป (premature abstraction) เป็นการเพิ่มความซับซ้อนที่ฉุดรั้งความเร็วในการพัฒนาของคุณ โดยไม่ก่อให้เกิดประโยชน์ที่สมน้ำสมเนื้อเลย ทุกๆ เลเยอร์ที่เพิ่มขึ้นมา หมายถึงสิ่งที่คุณต้องทำความเข้าใจเพิ่มขึ้น, จุดที่บั๊กสามารถแอบซ่อนตัวได้มากขึ้น และเป็นอุปสรรคขัดขวางการเปลี่ยนแปลงโค้ด จากประสบการณ์ของผม โปรเจกต์ที่ส่งมอบงานได้เร็วที่สุด คือโปรเจกต์ที่เริ่มต้นอย่างเรียบง่าย แล้วจึงค่อยๆ ขยายโครงสร้างเมื่อมีความต้องการใช้งานจริงเกิดขึ้น
ควรทำอย่างไรแทน: เริ่มต้นด้วยโครงสร้างที่เรียบง่ายที่สุดแต่มีการแบ่งสัดส่วนที่ชัดเจน ตามที่แนะนำไว้ในบท โครงสร้างโปรเจกต์ และเพิ่มระดับนามธรรมเฉพาะเมื่อความซับซ้อนของปัญหาเรียกร้องจริงๆ เท่านั้น อย่าเพิ่งเพิ่มเพื่อดักทางความซับซ้อนในจินตนาการที่อาจไม่เคยเกิดขึ้นจริง คุณสามารถรีแฟกเตอร์โค้ดจากโครงสร้างแบบเรียบง่ายไปเป็นโครงสร้างแบบหลายเลเยอร์ได้เสมอเมื่อความต้องการชัดเจนขึ้น ดังนั้น อย่าไปกังวลกับการสร้างสถาปัตยกรรมที่ “สมบูรณ์แบบไร้ที่ติ” ตั้งแต่วันแรกของการพัฒนา