Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ประสิทธิภาพ

ข้อดีที่ยอดเยี่ยมประการหนึ่งของการเลือกใช้ Rust และ Axum คือคุณจะได้รับขีดความสามารถด้านประสิทธิภาพ (Performance Baseline) ที่แข็งแกร่งตั้งแต่เริ่มต้นโดยแทบไม่ต้องปรับแต่งอะไรเป็นพิเศษ การทำงานร่วมกันระหว่าง zero-cost abstractions, การไม่มี garbage collector และ async runtime ของ Tokio ทำให้แอปพลิเคชัน Axum ทั่วไปของเราสามารถรองรับการเชื่อมต่อพร้อมกันได้หลายพันรายการบนฮาร์ดแวร์ขนาดพอประมาณ ถึงกระนั้น เราก็ยังอาจพลาดโอกาสในการรีดเค้นประสิทธิภาพออกมาได้อย่างเต็มเม็ดเต็มหน่วย หากเราไม่ได้ใส่ใจกับวิธีใช้งานเครื่องมือต่างๆ อย่างถี่ถ้วน

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

อย่าบล็อก async runtime

หากมีกฎเหล็กด้านประสิทธิภาพเพียงข้อเดียวที่คุณควรจดจำจากหนังสือทั้งเล่มนี้ ขอให้เป็นข้อนี้: Tokio runtime อาศัย thread pool เพื่อรัน async task ร่วมกันแบบเอื้ออารี (cooperatively) หากมี task ใด task หนึ่งเข้าไปบล็อกเธรดไว้ (เช่น ทำงานที่กิน CPU หนักๆ, ทำ synchronous I/O หรือเรียกใช้ blocking library function) เธรดนั้นจะไม่สามารถไปรับ task อื่นได้เลยจนกว่างานที่บล็อกจะเสร็จสิ้น และเนื่องจากค่าเริ่มต้นของ Tokio จะจัดสรร worker thread หนึ่งตัวต่อหนึ่ง CPU core เท่านั้น การบล็อกแม้เพียงเธรดเดียวจึงส่งผลกระทบให้ throughput ลดลงอย่างเห็นได้ชัดในทันที

สิ่งที่รับมือได้ยากคืออาการของปัญหามักไม่ปรากฏให้เห็นในสภาวะปกติ แอปพลิเคชันอาจจัดการกับโหลดระดับปานกลางได้อย่างสบายๆ แต่เมื่อการทำงานพร้อมกัน (concurrency) เพิ่มสูงขึ้น เราจะเริ่มเห็นค่า latency พุ่งสูงขึ้นอย่างกะทันหันและ throughput ตกฮวบ สิ่งที่เกิดขึ้นจริงเบื้องหลังคือ async task จำนวนมากต้องต่อคิวรอเธรดที่กำลังติดหล่มอยู่กับงานแบบ synchronous บางอย่าง

ทางออกของเรื่องนี้คือการย้ายงานที่บล็อกเหล่านั้นไปยัง thread pool แยกต่างหากสำหรับงานประเภทนี้โดยเฉพาะ:

#![allow(unused)]
fn main() {
// CPU-intensive work (password hashing, image processing, etc.)
let hash = tokio::task::spawn_blocking(move || {
    hash_password(&password)
})
.await
.context("password hashing task panicked")??;
}

spawn_blocking จะรัน closure บน blocking thread pool ของ Tokio ซึ่งแยกขาดจาก async worker thread และในระหว่างที่รอลำดับผลลัพธ์ async task ของเราจะยอมสละ (yield) การควบคุมคืน ทำให้ worker thread ว่างไปประมวลผลคำขออื่นๆ ได้อย่างต่อเนื่อง

อย่างไรก็ตาม มีข้อควรระวังสำคัญประการหนึ่ง: spawn_blocking ถูกออกแบบมาเพื่อเป็นช่องทางผ่อนปรนฉุกเฉิน (escape hatch) ไม่ใช่ตัวจัดตารางงานคำนวณทั่วไป โดยค่าเริ่มต้น blocking pool ของ Tokio จะจำกัดไว้สูงสุดที่ 512 เธรด หากเราสั่ง spawn blocking task หนึ่งตัวต่อหนึ่งคำขอขาเข้าระหว่างที่ traffic พุ่งกระฉูด เราอาจทำให้ thread pool เต็มอย่างรวดเร็ว ส่งผลให้การเรียก spawn_blocking ในคำขอถัดๆ ไปต้องติดค้างรอคิว สำหรับงานที่กิน CPU หนักๆ ภายใต้ concurrency สูง ผมแนะนำให้จำกัดจำนวนงานบล็อกที่รันพร้อมกันด้วย tokio::sync::Semaphore หรือย้ายงานเหล่านั้นไปยัง thread pool สำหรับงานคำนวณโดยเฉพาะอย่าง rayon นอกจากนี้ควรทราบด้วยว่า เมื่อ blocking task เริ่มทำงานไปแล้วจะไม่สามารถสั่งยกเลิก (abort) ได้ ดังนั้นหากแอปพลิเคชันกำลังเข้าสู่กระบวนการ shutdown มันจะต้องรอจนกว่า blocking task ทั้งหมดจะทำงานเสร็จสิ้นก่อนจึงจะออกจากโปรเซสได้

แหล่งที่มาทั่วไปของการบล็อกเธรดโดยไม่ตั้งใจ ได้แก่:

  • การแฮชรหัสผ่าน ด้วย Argon2 หรือ bcrypt (ซึ่งออกแบบมาให้กินทรัพยากร CPU เป็นหลัก)
  • Synchronous File I/O (ควรใช้ tokio::fs แทนที่จะเป็น std::fs)
  • การ resolve DNS ใน HTTP client บางตัว (ควรเลือกใช้ async-native client อย่าง reqwest)
  • การเรียก .lock() บน std::sync::Mutex (ควรเปลี่ยนไปใช้ tokio::sync::Mutex หากจำเป็นต้องถือ lock ข้ามจุด await)

พูลการเชื่อมต่อ

การสร้าง database connection ใหม่ในทุกๆ คำขอนั้นมีต้นทุนสูงมาก ทั้ง TCP handshake, การเจรจา TLS negotiation ตลอดจนกระบวนการ authentication ซึ่งรวมกันแล้วอาจกินเวลาเพิ่มขึ้นหลายสิบมิลลิวินาทีได้อย่างง่ายดาย ระบบ connection pool จะช่วยเฉลี่ยต้นทุนดังกล่าวด้วยการเปิด connection เตรียมไว้ล่วงหน้าเป็นชุด เพื่อให้แต่ละคำขอยืมไปใช้งานแล้วส่งคืนกลับเข้าพูลเมื่อเสร็จสิ้น

PgPool ของ SQLx จัดการเรื่องนี้ให้เราอย่างโปร่งใส สิ่งสำคัญที่สุดคือการปรับขนาดของ pool ให้เหมาะสมกับการใช้งาน:

#![allow(unused)]
fn main() {
PgPoolOptions::new()
    .max_connections(10)
    .min_connections(2)
    .acquire_timeout(Duration::from_secs(3))
}

หากตั้งขนาดพูลเล็กเกินไป แต่ละคำขอก็จะต้องต่อคิวรอ connection นาน แต่หากตั้งขนาดใหญ่เกินไป ก็จะสิ้นเปลืองหน่วยความจำบนฐานข้อมูลเซิร์ฟเวอร์ และเสี่ยงต่อการชนขีดจำกัดจำนวน connection สูงสุดของ PostgreSQL จุดเริ่มต้นที่ดีคือประมาณ 2 ถึง 4 connection ต่อหนึ่ง CPU core บน application server จากนั้นจึงค่อยปรับจูนตามสัดส่วนเวลาจริงที่คำขอใช้ไปกับการทำงานในฐานข้อมูลเทียบกับการประมวลผลส่วนอื่น

acquire_timeout เปรียบเสมือนตาข่ายนิรภัยของเรา หาก connection ทั้งหมดถูกใช้งานอยู่และคำขอใหม่ไม่สามารถขอรับ connection ได้ภายในระยะเวลา timeout ที่กำหนด มันจะแจ้งข้อผิดพลาดออกมาทันทีแทนที่จะค้างเติ่งอย่างไร้จุดหมาย ซึ่งดีกว่าการปล่อยให้คำขอนั่งรออยู่ในคิวนานถึง 30 วินาทีก่อนจะเกิด timeout ในระดับ HTTP อย่างเทียบกันไม่ได้

การบีบอัดการตอบกลับ

การบีบอัด response body ด้วย gzip หรือ brotli สามารถช่วยลดปริมาณข้อมูลที่ต้องส่งผ่านเครือข่ายได้อย่างมหาศาล โดยเฉพาะอย่างยิ่งกับ JSON API ซึ่งเนื้อหาของการตอบกลับเป็นข้อความที่สามารถบีบอัดได้อย่างมีประสิทธิภาพสูง

#![allow(unused)]
fn main() {
use tower_http::compression::CompressionLayer;

let app = Router::new()
    .merge(routes)
    .layer(CompressionLayer::new())
    .with_state(state);
}

CompressionLayer จะเจรจาเลือกอัลกอริทึมการบีบอัดกับไคลเอนต์โดยอัตโนมัติตาม header Accept-Encoding สำหรับ JSON API ส่วนใหญ่ การบีบอัดด้วย gzip สามารถลดขนาดของ response ลงได้ถึง 70 ถึง 90 เปอร์เซ็นต์ ซึ่งส่งผลให้ไคลเอนต์ได้รับข้อมูลเร็วขึ้นอย่างเห็นได้ชัด โดยเฉพาะอย่างยิ่งบนเครือข่ายที่มีความเร็วต่ำ

การจัดการข้อมูลอย่างมีประสิทธิภาพ

หลีกเลี่ยงการจัดสรรหน่วยความจำที่ไม่จำเป็น (Avoid unnecessary allocations) ในจุดที่เป็นเส้นทางประมวลผลหลัก (hot path) ควรเลือกใช้การยืม (&str) มากกว่าชนิดข้อมูลที่เป็นเจ้าของหน่วยความจำ (String) เท่าที่จะทำได้ และเลือกใช้ iterator แทนการสั่ง .collect() ลงใน vector พักข้อมูลชั่วคราว แม้สิ่งเหล่านี้จะเป็นการปรับแต่งจุดเล็กๆ แต่จะมีผลลัพธ์ทวีคูณเมื่อระบบต้องรับมือกับ traffic ปริมาณมหาศาล

ใช้ Arc สำหรับข้อมูลส่วนกลางที่ไม่เปลี่ยนแปลง (Use Arc for shared immutable data) ค่าคอนฟิกูเรชัน, static asset และข้อมูลอื่นๆ ที่ไม่มีการเปลี่ยนแปลงหลังสตาร์ตอัปควรห่อหุ้มไว้ด้วย Arc เพื่อให้การโคลน state ของแอปพลิเคชันมีต้นทุนที่ถูกมาก (เพียงแค่เพิ่มตัวนับ reference count) แทนที่จะต้องเสียต้นทุนสูงในการทำ deep copy ข้อมูลทั้งหมด

สตรีมการตอบกลับขนาดใหญ่ (Stream large responses) สำหรับ endpoint ที่ต้องส่งคืนข้อมูลปริมาณมาก ให้เลือกส่งข้อมูลแบบสตรีมแทนที่จะบัฟเฟอร์ข้อมูลทั้งหมดขึ้นมาไว้ในหน่วยความจำ โดย crate อย่าง axum-streams มีความสามารถรองรับการสตรีมทั้ง JSON array, ไฟล์ CSV และฟอร์แมตอื่นๆ ได้อย่างยอดเยี่ยม

การปรับควิวรีฐานข้อมูลให้เหมาะสม

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

สร้างดัชนี (Index) บนคอลัมน์ที่ใช้ในการค้นหาหรือกรองข้อมูล หากเราต้องค้นหาผู้ใช้ด้วยอีเมล เราต้องมั่นใจว่าคอลัมน์ email มีการทำ index ไว้ เพราะหากไม่มี ฐานข้อมูลจะต้องสแกนอ่านข้อมูลทุกแถวในตาราง (Full Table Scan) ในทุกครั้งที่ค้นหา

ใช้ EXPLAIN ANALYZE เพื่อทำความเข้าใจแผนการทำงานของคิวรี (Query Plan) เมื่อพบว่าคิวรีทำงานช้า ให้ลองรันด้วย EXPLAIN ANALYZE บน database client ของคุณเพื่อดูว่าฐานข้อมูลประมวลผลคำสั่งนั้นอย่างไรในความเป็นจริง โดยเฉพาะการมองหา sequential scan บนตารางขนาดใหญ่ ซึ่งมักเป็นสัญญาณบ่งชี้ว่าคอลัมน์นั้นยังขาด index

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

ใช้ Pagination กับ endpoint ที่แสดงรายการข้อมูลเสมอ ตามที่เราได้กล่าวถึงในบท การออกแบบ API ให้ทำ pagination กับคิวรีประเภทรายการข้อมูลเสมอ การยิงคำสั่ง SELECT * FROM users แบบไม่มีขอบเขตจำกัดบนตารางที่มีข้อมูลนับล้านแถว ย่อมทำให้ระบบและแอปพลิเคชันล่มลงได้อย่างแน่นอน

การวัดประสิทธิภาพและการวิเคราะห์ประสิทธิภาพ

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

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

Flamegraph ช่วยสร้างภาพจำลองให้เห็นว่าแอปพลิเคชันของเราใช้เวลาของ CPU ไปกับฟังก์ชันใดบ้าง ซึ่งผมพบว่ามีประโยชน์อย่างยิ่งในการชี้เป้า hot spot ในสภาวะ workload ที่ใกล้เคียงกับบน production จริง

DHAT ช่วยวิเคราะห์โปรไฟล์การจัดสรรหน่วยความจำ ทำให้เราค้นพบจุดที่มีการจอง memory เกินความจำเป็นได้อย่างตรงจุด

tokio-console เป็นเครื่องมือวิเคราะห์และวินิจฉัยที่พัฒนาขึ้นสำหรับ async Rust โดยเฉพาะ แสดงให้เห็นภาพรวมว่ามี task ใดกำลังรันอยู่, task ใดถูกบล็อก และ runtime จัดตารางเวลาอย่างไร ซึ่งมีประโยชน์อย่างยิ่งสำหรับการค้นหาสาเหตุของปัญหา “รันไทม์ถูกบล็อก” ที่เราได้กล่าวถึงไปในตอนต้นของบท

สิ่งที่ไม่ควรปรับให้เหมาะสม

สิ่งสำคัญที่ควรตระหนักไว้เสมอคือ การด่วนปรับปรุงประสิทธิภาพก่อนเวลาอันควร (Premature Optimization) มีต้นทุนแฝงที่ต้องจ่ายจริง การพยายามทำ micro-optimize กับ handler ที่ใช้เวลาเพียง 2 มิลลิวินาที ทั้งๆ ที่ database query ภายในนั้นกินเวลาไปถึง 50 มิลลิวินาที นับเป็นการลงแรงที่สูญเปล่า จงโฟกัสความพยายามในการ optimize ไปที่คอขวดที่แท้จริง ซึ่งสำหรับเว็บแอปพลิเคชันแล้ว มักหนีไม่พ้น database query, network I/O และการบล็อก async runtime โดยไม่เจตนา

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