งานเบื้องหลังและการจัดการทาสก์
หากคุณเคยสร้างเว็บแอปพลิเคชันที่จริงจังกว่าโปรเจกต์ทดลองเล่นทั่วไป คุณคงเคยเผชิญกับสถานการณ์นี้: งานบางอย่างไม่ควรถูกผูกไว้ในวงรอบคำขอ-การตอบกลับ (request-response cycle) เลย ไม่ว่าจะเป็นการส่งอีเมลยืนยันตัวตน, การประมวลผลไฟล์ที่อัปโหลด, การสร้างรายงานขนาดใหญ่, การลองส่ง webhook ที่เคยล้มเหลวซ้ำ, หรือการเก็บกวาดเซสชันที่หมดอายุ ทั้งหมดนี้ล้วนทำให้ HTTP response ของเราตอบสนองช้าลงอย่างมากหากเราพยายามทำทุกอย่างแบบอินไลน์ (inline) ในบทนี้ เราจะมาเจาะลึกแพตเทิร์นสำหรับการจัดการงานเบื้องหลัง (background jobs) ในแอปพลิเคชันที่ใช้ Tokio ตั้งแต่ทาสก์แบบยิงแล้วลืม (fire-and-forget) ขั้นพื้นฐาน ไปจนถึงระบบคิวงานแบบถาวร (persistent job queue) ที่รองรับการลองใหม่อัตโนมัติ (retry)
การสร้างทาสก์ภายในกระบวนการ
วิธีที่ง่ายที่สุดในการรันงานเบื้องหลังคือการใช้ tokio::spawn ซึ่งจะสร้างทาสก์แบบแอซิงก์ตัวใหม่ที่ทำงานอย่างเป็นอิสระจากโค้ดตัวต้นทางที่สร้างมันขึ้นมา โดยโค้ดต้นทางจะไม่ต้องหยุดรอให้ทาสก์ใหม่ทำงานจนเสร็จ เว้นแต่คุณจะระบุ .await บน JoinHandle ที่ได้รับกลับมาอย่างชัดเจน
#![allow(unused)]
fn main() {
async fn create_user(
State(state): State<AppState>,
ValidatedJson(payload): ValidatedJson<CreateUserDto>,
) -> AppResult<(StatusCode, Json<UserResponse>)> {
let user = state.user_service.register(payload).await?;
// Send the welcome email in the background.
// The HTTP response does not wait for this to finish.
let email_client = state.email_client.clone();
let email = user.email().clone();
tokio::spawn(async move {
if let Err(e) = email_client.send_welcome(&email).await {
tracing::error!(error = ?e, "failed to send welcome email");
}
});
Ok((StatusCode::CREATED, Json(user.into())))
}
}
วิธีนี้ตอบโจทย์ได้เป็นอย่างดีสำหรับผลข้างเคียง (side effects) ที่ไม่ได้สำคัญถึงขั้นวิกฤต ซึ่งความผิดพลาดเป็นครั้งคราวเป็นสิ่งที่ยอมรับได้ (เช่น ข้อมูลผู้ใช้ยังคงถูกบันทึกลงฐานข้อมูลสำเร็จ แม้การส่งอีเมลต้อนรับจะล้มเหลวก็ตาม) ทว่ามีข้อควรระวังสำคัญบางประการที่คุณจำเป็นต้องรู้ไว้:
ประการแรก หากทาสก์ที่ถูก spawn เกิดอาการแพนิก (panic) ตัวแพนิกนั้นจะถูกดักจับและเก็บไว้ใน JoinHandle หากคุณไม่ได้ .await บนแฮนเดิลดังกล่าว แพนิกนั้นจะถูกกลืนหายไปอย่างเงียบๆ ซึ่งอาจทำให้การดีบักปัญหาบน production ชวนสับสนอย่างมาก คุณจึงควร await แฮนเดิล หรือหันไปใช้ JoinSet ที่สามารถรายงานข้อผิดพลาดกลับมาให้คุณได้
แต่ปัญหาที่ใหญ่หลวงกว่านั้นคือ: หากโพรเซสของคุณถูกรีสตาร์ท (เช่น จากการดีพลอยต์เวอร์ชันใหม่, เซิร์ฟเวอร์แครช, หรือถูกระบบปฏิบัติการทำ OOM kill) ทาสก์ที่ spawn ไว้และกำลังทำงานอยู่จะสูญหายไปทันทีโดยไร้ร่องรอย ไม่มีการลองใหม่ (retry), ไม่มีความคงทนของข้อมูล (persistence), และไม่มีการรับประกันใดๆ ว่างานนั้นจะทำเสร็จสมบูรณ์ ดังนั้นสำหรับงานที่ จำเป็นต้อง สำเร็จให้ได้ในท้ายที่สุด คุณจะต้องพึ่งพาระบบคิวงานแบบถาวร ซึ่งเราจะมาคุยกันในช่วงท้ายของบทนี้
JoinSet สำหรับจัดการกลุ่มทาสก์
เมื่อคุณมีชุดของทาสก์ที่ทราบจำนวนแน่นอนและทุกตัวจำเป็นต้องทำงานให้เสร็จสิ้น tokio::task::JoinSet จะช่วยมอบโครงสร้างที่เป็นระเบียบเรียบร้อยในการ spawn ทาสก์เหล่านั้นและรวบรวมผลลัพธ์กลับมา:
#![allow(unused)]
fn main() {
use tokio::task::JoinSet;
async fn process_batch(items: Vec<Item>, pool: PgPool) -> anyhow::Result<()> {
let mut set = JoinSet::new();
for item in items {
let pool = pool.clone();
set.spawn(async move {
process_item(&pool, &item).await
});
}
// Wait for all tasks to complete.
while let Some(result) = set.join_next().await {
match result {
Ok(Ok(())) => {}
Ok(Err(e)) => tracing::error!(error = ?e, "item processing failed"),
Err(e) => tracing::error!(error = ?e, "task panicked"),
}
}
Ok(())
}
}
JoinSet ยังมีประโยชน์อย่างยิ่งสำหรับการจำกัดอัตราการทำงานพร้อมกัน (concurrency limiting) โดยคุณสามารถตรวจสอบ set.len() ก่อนที่จะ spawn ทาสก์ใหม่ และหยุดรอให้มีทาสก์ตัวใดตัวหนึ่งเสร็จสิ้นก่อนได้หากความจุเต็มแล้ว ยิ่งไปกว่านั้น เมื่อ JoinSet ถูกทำลาย (dropped) ทาสก์ทั้งหมดที่อยู่ข้างในจะถูกยกเลิก (abort) โดยอัตโนมัติ ซึ่งเหมาะอย่างยิ่งกับสถานการณ์การปิดระบบ (graceful shutdown) ที่คุณต้องการยกเลิกงานที่ยังค้างอยู่ทั้งหมดอย่างเป็นระเบียบ
งานแบบเป็นคาบ
แอปพลิเคชันจำนวนมากจำเป็นต้องมีงานเบื้องหลังที่รันซ้ำตามช่วงเวลา (recurring tasks) เช่น การเคลียร์แคชทุกๆ 5 นาที, การส่งรายงานเมตริกทุกๆ 30 วินาที, หรือการส่งสัญญาณ heartbeat ตรวจสอบสุขภาพระบบทุกๆ 10 วินาที เป็นต้น ฟังก์ชัน interval ของ Tokio คือเครื่องมือหลักที่เราจะหยิบมาใช้ในกรณีนี้:
#![allow(unused)]
fn main() {
use tokio::time::{interval, Duration};
async fn run_cache_cleanup(
pool: PgPool,
shutdown: CancellationToken,
) {
let mut ticker = interval(Duration::from_secs(300));
loop {
tokio::select! {
_ = ticker.tick() => {
if let Err(e) = cleanup_expired_sessions(&pool).await {
tracing::error!(error = ?e, "session cleanup failed");
}
}
_ = shutdown.cancelled() => {
tracing::info!("cache cleanup shutting down");
return;
}
}
}
}
}
จุดหนึ่งที่เคยทำให้ผมสะดุดในช่วงแรกคือ: interval มีการตั้งค่า MissedTickBehavior เพื่อควบคุมว่าจะทำอย่างไรเมื่อการทำงานของทาสก์ในรอบหนึ่งใช้เวลานานเกินกว่ารอบเวลาที่กำหนดไว้ ค่าดีฟอลต์คือ Burst ซึ่งจะยิงสัญญาณ tick ที่เคยพลาดไปออกมารัวๆ ทันทีเพื่อไล่กวดให้ทันรอบ แต่สำหรับงานบำรุงรักษาในเบื้องหลังส่วนใหญ่ สิ่งที่คุณต้องการจริงๆ มักจะเป็น MissedTickBehavior::Skip เพราะคุณคงอยากให้ข้าม tick ที่ตกหล่นไประหว่างที่งานรอบก่อนหน้ายังทำไม่เสร็จ แทนที่จะปล่อยให้มันสะสมแล้วระดมยิงออกมาพร้อมกันจนระบบรับไม่ไหว
#![allow(unused)]
fn main() {
let mut ticker = interval(Duration::from_secs(300));
ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
}
การผสาน worker เบื้องหลังเข้ากับ Axum
ในทางปฏิบัติ คุณมักจะเริ่มรัน background worker ไปพร้อมๆ กับเซิร์ฟเวอร์ HTTP โดยแชร์ connection pool ของฐานข้อมูลและการตั้งค่าต่างๆ ร่วมกันผ่าน AppState หรือด้วยการ clone พูลออกมาโดยตรง ทั้งนี้ในบท การปิดระบบอย่างนุ่มนวล ได้แสดงรูปแบบเต็มรูปแบบในการ spawn หลายซับซิสเต็มและการประสานงานวงจรชีวิต (lifecycle) ของระบบไว้แล้ว
ขอสรุปจุดเชื่อมต่อที่สำคัญดังนี้:
สถานะที่ใช้ร่วมกัน (Shared state) Worker ในเบื้องหลังจำเป็นต้องใช้พูลฐานข้อมูล, ค่าคอนฟิก, และอาจรวมถึงออบเจกต์ของเซอร์วิสชุดเดียวกันกับแฮนด์เลอร์ HTTP ดังนั้นให้ clone สิ่งเหล่านี้มาจากแหล่งเดียวกันตั้งแต่ช่วงเริ่มต้นการทำงานของระบบ
การปิดระบบที่ประสานงานกัน (Coordinated shutdown) Worker จะต้องถือ CancellationToken ไว้ด้วย เพื่อให้สามารถหยุดการทำงานได้อย่างนุ่มนวลเมื่อแอปพลิเคชันกำลังจะปิดตัวลง โดยเราต้องการให้ worker เคลียร์งานชิ้นปัจจุบันให้เสร็จสิ้นก่อนออกจากลูป แทนที่จะทิ้งงานค้างไว้กลางคัน
การตัดขาดข้อผิดพลาด (Error isolation) การที่ทาสก์เบื้องหลังเกิดแพนิกไม่ควรส่งผลให้เซิร์ฟเวอร์ HTTP ล่มตามไปด้วย การแยก worker ออกมารันใน tokio::spawn ต่างหากจะช่วยจำกัดขอบเขตความเสียหายให้อยู่เฉพาะจุด จากนั้นให้ทำการบันทึกล็อกข้อผิดพลาด และตัดสินใจตามความต้องการของระบบว่าจะทำการรีสตาร์ท worker ขึ้นมาใหม่ หรือปล่อยให้มันหยุดทำงานไป
คิวงานแบบถาวร
สำหรับงานที่ต้องรอดพ้นจากการรีสตาร์ทโพรเซส คุณจำเป็นต้องใช้ระบบคิวแบบถาวร (persistent queue) ที่จัดเก็บข้อมูลลงฐานข้อมูลหรือ message broker ข่าวดีก็คือ ปัจจุบันมี crate ใน Rust ที่มีความสมบูรณ์พร้อมและช่วยแก้ปัญหานี้ให้เราอยู่แล้วหลายตัว:
apalis เป็นไลบรารีประมวลผลงานเบื้องหลังที่ปลอดภัยเรื่องชนิดข้อมูล (type-safe) และยืดหยุ่นขยายได้ง่าย รองรับสตอเรจแบ็กเอนด์หลากหลาย (PostgreSQL, Redis, SQLite) อีกทั้งยังมีระบบมอนิเตอร์, เมตริก, และ graceful shutdown ติดตั้งมาให้ในตัว โดยทำงานร่วมกับ Tokio และ async runtime อื่นๆ ได้เป็นอย่างดี
fang รัน worker แต่ละตัวในทาสก์ Tokio แยกต่างหาก พร้อมความสามารถในการรีสตาร์ทใหม่อัตโนมัติหากเกิดแพนิก รองรับการตั้งเวลางานด้วย cron expression, มีโหมดคำนวณการหน่วงเวลาเพื่อลองใหม่ (retry backoff) ที่ปรับแต่งได้, และรองรับการตัดงานที่ซ้ำซ้อน (deduplication) ตามคีย์เฉพาะ
backie มอบการประมวลผลทาสก์แบบ asynchronous และ persistent โดยใช้ PostgreSQL เป็นแบ็กเอนด์ ออกแบบมาเพื่อรองรับการขยายระบบในแนวนอน (horizontal scaling) โดย worker ไม่จำเป็นต้องรันอยู่ในโพรเซสเดียวกับฝั่งที่สร้างคิว
รูปแบบการทำงานทั่วไปของระบบเหล่านี้มีความคล้ายคลึงกัน และเข้าใจได้ไม่ยาก: แฮนด์เลอร์ HTTP (หรือเซอร์วิส) ของคุณจะส่งงานเข้าคิวโดยการแทรกแถวข้อมูลใหม่ลงในตารางงาน หรือเผยแพร่ไปยัง message broker จากนั้นโพรเซสของ worker ที่แยกออกมา (หรือทาสก์เบื้องหลังในโพรเซสเดียวกัน) จะคอยดึง (poll) งานที่รออยู่ไปประมวลผล แล้วอัปเดตสถานะว่างานสำเร็จหรือล้มเหลว หากงานล้มเหลว ระบบจะทำการลองใหม่ตามระยะเวลาหน่วงที่กำหนดไว้ และเมื่องานนั้นล้มเหลวจนครบจำนวนครั้งสูงสุด มันจะถูกย้ายไปยังสถานะ dead-letter เพื่อให้ผู้ดูแลระบบเข้ามาตรวจสอบปัญหาได้ด้วยตนเอง
การจัดการข้อผิดพลาดในงานเบื้องหลัง
นี่คือจุดที่มีความน่าสนใจเป็นพิเศษ เพราะต่างจากแฮนด์เลอร์ HTTP ตรงที่งานเบื้องหลังไม่มี client คอยรอรับ error response กลับไป เมื่อทาสก์เบื้องหลังเกิดข้อผิดพลาดขึ้น คุณจึงต้องมีกลยุทธ์ที่ชัดเจนในการทำให้ความล้มเหลวนั้นมองเห็นได้และสามารถเข้าไปแก้ไขได้อย่างทันท่วงที ต่อไปนี้คือแนวทางที่ผมพบว่าใช้งานได้ผลดีอย่างยิ่ง:
บันทึกข้อผิดพลาดพร้อมบริบท (Log with context) ใช้ tracing::error! พร้อมระบุฟิลด์ข้อมูลแบบมีโครงสร้าง (structured fields) เพื่อให้ข้อผิดพลาดปรากฏบนระบบรวบรวมล็อกส่วนกลางอย่างชัดเจน และสามารถสืบสาวกลับไปยังคำขอต้นทางที่ส่งงานนี้เข้าคิวได้ หากไม่มีข้อมูลเหล่านี้ คุณจะไม่ต่างอะไรกับการงมเข็มในความมืดเมื่อเกิดปัญหาขึ้นกลางดึก
ลองใหม่พร้อมการหน่วงเวลาแบบทวีคูณ (Retry with backoff) สำหรับข้อผิดพลาดชั่วคราว (transient errors) เช่น ปัญหาเครือข่ายขัดข้องชั่วขณะ หรือฐานข้อมูลไม่พร้อมใช้งานชั่วคราว ให้ลองประมวลผลใหม่อีกครั้งโดยเว้นระยะเวลาหน่วงที่เพิ่มขึ้นเรื่อยๆ ซึ่ง crate สำหรับคิวงานแบบถาวรส่วนใหญ่มักมีฟังก์ชันนี้มาให้พร้อมใช้งานอยู่แล้ว
ย้ายไปยังคิว Dead-Letter เมื่อครบโควตาการลองใหม่ หากงานยังคงล้มเหลวซ้ำๆ จนหมดจำนวนครั้งที่กำหนด ให้ย้ายงานนั้นไปยังตารางหรือคิว dead-letter เพื่อให้ทีมงานเข้ามาตรวจสอบ หาสาเหตุ และแก้ไขหรือลบทิ้งด้วยตนเอง อย่าตั้งให้ลองใหม่ไปเรื่อยๆ อย่างไม่มีที่สิ้นสุด เพราะงานที่ล้มเหลวถาวรจะคอยแย่งทรัพยากรของ worker และทำให้งานอื่นๆ ในคิวต้องล่าช้าตามไปด้วย
เก็บและรายงานเมตริก (Emit metrics) คอยติดตามอัตราความสำเร็จของงาน, ระยะเวลาที่ใช้ในการประมวลผล, ความยาวของคิว (queue depth), และจำนวนครั้งของการลองใหม่ เมตริกเหล่านี้เปรียบเสมือนระบบเตือนภัยล่วงหน้าที่จะแจ้งเตือนปัญหาที่กำลังก่อตัวก่อนที่ผู้ใช้งานจริงจะได้รับผลกระทบ จากประสบการณ์ของผม กราฟความยาวของคิวที่พุ่งสูงขึ้นอย่างต่อเนื่องมักเป็นสัญญาณเตือนแรกเสมอว่าระบบกำลังเริ่มมีปัญหา