HTTP ขาออกและความทนทานของบริการ
ที่ผ่านมา เรามักมองเซอร์วิสของเราในบทบาทของ “เซิร์ฟเวอร์” ที่คอยรับคำขอและส่งการตอบกลับ แต่ในความเป็นจริง เซอร์วิสส่วนใหญ่ก็ทำหน้าที่เป็น “ไคลเอนต์” ด้วยเช่นกัน โดยเว็บเซิร์ฟเวอร์ของเราต้องคอยเรียกใช้งาน payment gateway, ส่ง webhook, ยิงคิวรีไปยัง API ภายใน, ดึงข้อมูลจากบริการภายนอก (third-party), หรือส่งข้อความเข้าคิว ผมเคยพบเห็นเหตุการณ์ระบบล่มหลายครั้งที่ไม่เกี่ยวข้องอะไรเลยกับการจัดการทราฟฟิกขาเข้า แต่ปัญหาเกิดจากวิธีการที่เราเรียกออกไปยังภายนอก หาก downstream dependency เกิดทำงานช้าลงและคุณไม่มีกลไกป้องกัน (guardrails) ที่รัดกุมพอ มันก็พร้อมที่จะลากเซอร์วิสทั้งหมดของคุณล่มตามไปด้วยทันที
ในบทนี้ เราจะมาเจาะลึกแพตเทิร์นที่จะช่วยปกป้องไม่ให้การเรียก HTTP ขาออกสร้างหายนะให้กับระบบของคุณ: ไม่ว่าจะเป็นการตั้งเวลาหมดเวลา (timeout), การลองใหม่ (retry), การหน่วงเวลาถอยร่น (backoff), คุณสมบัติการทำซ้ำแล้วได้ผลคงเดิม (idempotency), ระบบตัดวงจร (circuit breaking), และการส่งต่อบริบทการติดตาม (trace context propagation)
reqwest ในฐานะไคลเอนต์ HTTP
Crate reqwest คือไคลเอนต์ HTTP ที่เป็นตัวเลือกอันดับหนึ่งในระบบนิเวศของ Rust รองรับ async มาตั้งแต่กำเนิด, จัดการเรื่อง TLS ให้โดยอัตโนมัติ, รองรับ connection pooling, และทำงานร่วมกับ Tokio runtime ได้อย่างกลมกลืน จุดหนึ่งที่มักทำให้หลายคนสะดุดในช่วงเริ่มต้นคือ: คุณควรสร้างอินสแตนซ์ Client เพียงตัวเดียวตอนเริ่มต้นระบบ (startup) แล้วแชร์ใช้งานร่วมกันทั่วทั้งแอปพลิเคชัน เนื่องจาก Client จะดูแล connection pool ภายในตัวมันเอง หากคุณสร้างอินสแตนซ์ใหม่ขึ้นมาทุกครั้งที่มีคำขอเข้ามา คุณจะสูญเสียประโยชน์ทั้งหมดที่ได้จากการทำ pooling ไปอย่างน่าเสียดาย
#![allow(unused)]
fn main() {
use reqwest::Client;
use std::time::Duration;
pub fn create_http_client() -> Client {
Client::builder()
.timeout(Duration::from_secs(10))
.connect_timeout(Duration::from_secs(3))
.pool_max_idle_per_host(10)
.build()
.expect("failed to create HTTP client")
}
}
เราจะเก็บไคลเอนต์นี้ไว้ใน AppState และดึงออกมาใช้งานในแฮนด์เลอร์หรือเซอร์วิสเมื่อต้องการยิงคำขอออกไปข้างนอก โดยไคลเอนต์ตัวเดียวกันนี้สามารถรองรับคำขอที่ทำงานพร้อมกันหลายรายการได้อย่างปลอดภัย ซึ่งตรงกับสิ่งที่เราต้องการอย่างยิ่ง
การหมดเวลาในทุกระดับ
หากผมต้องเลือกกลไกเพื่อความทนทาน (resilience) เพียงอย่างเดียวสำหรับการเรียกใช้งานภายนอก สิ่งนั้นคือการกำหนด “เวลาหมดเวลา” (timeout) อย่างแน่นอน เพราะหากปราศจากมัน เซอร์วิสปลายทางที่ตอบสนองช้าหรือไม่ตอบสนองเลยจะดึงการเชื่อมต่อของคุณค้างไว้แบบไม่มีกำหนด จนในที่สุด connection pool, file descriptor, หรือความสามารถในการรับคำขอของเซิร์ฟเวอร์ของคุณจะถูกกลืนกินจนหมดสิ้น ผมเคยเห็นปัญหานี้เกิดขึ้นจริงบน production มาแล้ว และมันไม่ใช่เรื่องน่าอภิรมย์เลยแม้แต่น้อย
มีระดับการกำหนด timeout อยู่ 3 ระดับที่คุณควรนำมาพิจารณา:
Connect timeout ควบคุมระยะเวลาที่เรารอเพื่อเปิดการเชื่อมต่อ TCP หากเซิร์ฟเวอร์ปลายทางไม่สามารถเข้าถึงได้หรือเกิดปัญหาเครือข่าย คุณย่อมต้องการให้มันล้มเหลวโดยเร็ว (fail fast) ดีกว่ารอจนหมดค่าเริ่มต้นของระบบปฏิบัติการ (ซึ่งบน Linux อาจยาวนานถึง 120 วินาที) ระยะเวลา 3 ถึง 5 วินาทีจึงเป็นจุดเริ่มต้นที่สมเหตุสมผล
Per-request timeout จำกัดเวลาการทำงานทั้งหมดสำหรับคำขอ HTTP หนึ่งรายการ ซึ่งครอบคลุมตั้งแต่การเชื่อมต่อ, การทำ TLS handshake, การส่งคำขอ, ตลอดจนการรับข้อมูลตอบกลับกลับมาจนครบถ้วน โดยทั่วไปมักตั้งไว้ที่ 10 ถึง 30 วินาที แต่ทั้งนี้ขึ้นอยู่กับว่าคุณคาดหวังให้ระบบปลายทางตอบสนองเร็วแค่ไหน
Overall operation timeout คือเส้นตาย (deadline) สูงสุดสำหรับการดำเนินงานทั้งหมด ซึ่งครอบคลุมถึงการพยายามลองใหม่ (retry) ด้วย หากกฎทางธุรกิจระบุว่า “ต้องดึงสถานะการชำระเงินให้ได้ภายใน 30 วินาที” งบเวลา 30 วินาทีนั้นจะต้องครอบคลุมการลองใหม่ทั้งหมด ไม่ใช่แค่งบต่อการยิงหนึ่งครั้ง ให้ใช้ tokio::time::timeout ครอบลูปของการลองใหม่ทั้งหมด แทนที่จะครอบเฉพาะคำขอแต่ละรอบ
#![allow(unused)]
fn main() {
use tokio::time::timeout;
async fn fetch_with_deadline(
client: &Client,
url: &str,
deadline: Duration,
) -> anyhow::Result<String> {
timeout(deadline, async {
// Individual attempts have their own timeout (via client config).
// The outer timeout caps the total time including retries.
let response = client.get(url).send().await?.error_for_status()?;
Ok(response.text().await?)
})
.await
.map_err(|_| anyhow::anyhow!("operation timed out after {:?}", deadline))?
}
}
การลองใหม่และการถอยหน่วง
ความผิดพลาดชั่วคราว (transient failure) คือสัจธรรมที่หลีกเลี่ยงไม่ได้ในระบบแบบกระจาย (distributed systems) ไม่ว่าจะเป็นปัญหาเครือข่ายกระตุกชั่วขณะ, เซอร์วิสปลายทางรีสตาร์ทสั้นๆ, หรือเกิด timeout จากโหลดที่พุ่งขึ้นชั่วคราว ข้อผิดพลาดเหล่านี้หากเราเว้นจังหวะแล้วลองส่งใหม่อีกครั้งในอีกสักครู่ก็มักจะทำงานสำเร็จ ดังนั้น ไคลเอนต์ขาออกที่ดีจึงควรมีระบบลองใหม่สำหรับความล้มเหลวลักษณะนี้ พร้อมทั้งเพิ่มระยะเวลาหน่วงระหว่างการลองแต่ละรอบเพื่อไม่ให้เป็นการซ้ำเติมระบบปลายทาง
#![allow(unused)]
fn main() {
use std::time::Duration;
use tokio::time::sleep;
async fn fetch_with_retries(
client: &Client,
url: &str,
max_retries: u32,
) -> anyhow::Result<reqwest::Response> {
let mut last_error = None;
for attempt in 0..=max_retries {
if attempt > 0 {
// Exponential backoff with jitter to prevent thundering herd.
let base = Duration::from_millis(100 * 2u64.pow(attempt - 1));
let jitter = Duration::from_millis(rand::random::<u64>() % 50);
sleep(base + jitter).await;
}
match client.get(url).send().await {
Ok(resp) if resp.status().is_server_error() => {
// 5xx errors are retryable.
last_error = Some(anyhow::anyhow!(
"server error: {}", resp.status()
));
}
Ok(resp) => return Ok(resp),
Err(e) if e.is_timeout() || e.is_connect() => {
// Timeouts and connection errors are retryable.
last_error = Some(e.into());
}
Err(e) => return Err(e.into()), // Non-retryable error.
}
}
Err(last_error.unwrap_or_else(|| anyhow::anyhow!("exhausted retries")))
}
}
ในการออกแบบกลยุทธ์การลองใหม่ มีการตัดสินใจหลักๆ ไม่กี่ข้อที่คุณต้องกำหนดให้ชัดเจน:
ข้อผิดพลาดประเภทใดที่ควรลองใหม่ (Which errors to retry) ให้ลองใหม่เฉพาะกับข้อผิดพลาดด้านการเชื่อมต่อ (connection errors), timeout, และการตอบกลับรหัสตระกูล 5xx ห้ามลองใหม่กับรหัสตระกูล 4xx โดยเด็ดขาด เพราะนั่นหมายถึงคำขอมีข้อผิดพลาด และการส่งคำขอเดิมซ้ำไปอีกก็ไม่มีวันช่วยอะไร เช่นเดียวกับข้อผิดพลาดที่บ่งชี้ว่าเป็นปัญหาถาวร เช่น การ resolve ชื่อโดเมน (DNS) ไม่สำเร็จเนื่องจากไม่มีโดเมนนั้นอยู่จริง
กลยุทธ์การถอยร่น (Backoff strategy) การใช้ Exponential backoff (เพิ่มระยะเวลาหน่วงเป็นสองเท่าในแต่ละรอบ) ควบคู่กับ Jitter (การเพิ่มค่าสุ่มเล็กๆ น้อยๆ เข้าไป) คือแนวทางมาตรฐาน โดย jitter มีความสำคัญอย่างยิ่งในการป้องกันปัญหาฝูงชนแห่เข้าซ้ำ (thundering herd problem) ซึ่งเกิดจากการที่ไคลเอนต์จำนวนมากต่างแห่กันยิงคำขอรอบใหม่เข้ามาพร้อมกันเป๊ะๆ ทันทีที่ระบบฟื้นตัว ทำให้เซอร์วิสปลายทางที่กำลังตั้งหลักต้องล่มซ้ำลงไปอีก
จำนวนครั้งสูงสุดในการลองใหม่ (Maximum attempts) โดยทั่วไปมักกำหนดไว้ที่ 3 ถึง 5 ครั้ง หากเกินกว่านั้นมักหมายความว่าระบบปลายทางล่มแบบต่อเนื่องยาวนาน และการฝืนลองใหม่ต่อไปก็มีแต่จะเพิ่มโหลดโดยเปล่าประโยชน์
การทำซ้ำแล้วได้ผลเหมือนเดิมของปฏิบัติการที่ลองใหม่
การลองใหม่กับคำขอแบบ GET ย่อมปลอดภัยเสมอ เพราะ GET มีคุณสมบัติ idempotent (ทำซ้ำแล้วได้ผลลัพธ์คงเดิม) ตามนิยาม แต่การลองใหม่กับคำขอ POST ที่ทำการสร้างรีซอร์สขึ้นใหม่ล่ะ? นั่นเป็นคนละเรื่องกันเลย หาก API ปลายทางไม่ได้รองรับ idempotency key การลองยิง POST ซ้ำอาจส่งผลให้เกิดข้อมูลซ้ำซ้อนในระบบ ซึ่งคงเป็นสิ่งสุดท้ายที่คุณอยากให้เกิดขึ้น
หากคุณกำลังเรียกใช้ API ที่รองรับ idempotency key (ตัวอย่างเช่น Stripe ที่รองรับเฮดเดอร์ Idempotency-Key) แนวทางจัดการจะตรงไปตรงมามาก: เพียงแค่สร้าง UUID สำหรับการทำรายการนั้นขึ้นมาหนึ่งตัว แล้วแนบส่งไปในทุกๆ รอบที่มีการลองใหม่:
#![allow(unused)]
fn main() {
let idempotency_key = Uuid::new_v4().to_string();
for attempt in 0..=max_retries {
let result = client
.post(url)
.header("Idempotency-Key", &idempotency_key)
.json(&payload)
.send()
.await;
// Same retry logic as above.
}
}
แล้วถ้า API ปลายทางไม่ได้รองรับ idempotency key ล่ะ? คุณมีทางเลือกอยู่ 2 ทาง: ข้อแรกคือออกแบบการทำงานให้มีคุณสมบัติ idempotent โดยธรรมชาติ (เช่น เปลี่ยนไปใช้ PUT พร้อมระบุ ID ที่กำหนดไว้ล่วงหน้า แทนที่จะใช้ POST ไปยังคอลเลกชัน) หรือข้อสองคือ ไม่ต้องลองใหม่สำหรับการทำงานที่เป็นการเขียนข้อมูลเลย แล้วส่งต่อข้อผิดพลาดออกมาเพื่อให้มนุษย์เข้ามาตรวจสอบและแก้ไขด้วยตนเอง แม้จะไม่มีวิธีใดที่สมบูรณ์แบบไร้ที่ติ แต่ทั้งสองทางเลือกก็ยังดีกว่าการปล่อยให้ระบบตัดเงินหรือสร้างรายการซ้ำซ้อนอย่างเงียบๆ โดยไม่รู้ตัว
การตัดวงจร (Circuit breaking)
คุณอาจตั้งคำถามว่า: หากเซอร์วิสปลายทางเกิดความล้มเหลวอย่างต่อเนื่อง ทำไมเรายังต้องดันทุรังส่งคำขอต่อไปเรื่อยๆ? การทำเช่นนั้นมีแต่จะทำให้เราสูญเสียทรัพยากรไปโดยเปล่าประโยชน์ และยิ่งเป็นการเพิ่มโหลดซ้ำเติมระบบปลายทางที่กำลังวิกฤตอยู่แล้ว นี่คือเหตุผลที่ต้องมี Circuit Breaker (ระบบตัดวงจร) โดยระบบจะคอยติดตามอัตราความล้มเหลว และเมื่อตัวเลขพุ่งสูงจนเกินเกณฑ์ที่กำหนด มันจะทำการตัดวงจร (short-circuit) ปฏิเสธคำขอทันทีในช่วงเวลาคูลดาวน์ ก่อนที่จะเริ่มเปิดให้ทดลองส่งใหม่อีกครั้ง
ในระบบนิเวศของ tower มี crate เช่น tower-resilience ที่เตรียมมิดเดิลแวร์สำหรับ circuit breaker, bulkhead, และ retry ให้คุณสามารถนำมาประกอบเข้ากับ reqwest client หรือ Tower service ใดๆ ได้อย่างยืดหยุ่น และสำหรับความต้องการในระดับพื้นฐาน คุณสามารถเขียน circuit breaker อย่างง่ายได้ด้วยตัวเองโดยใช้ตัวนับความล้มเหลวแบบ AtomicU32 ร่วมกับ tokio::time::Instant สำหรับบันทึกเวลาที่ทำการตรวจสอบล่าสุด
สถานะการทำงานมีอยู่ 3 สถานะหลัก ได้แก่:
- Closed (สภาวะปกติ): คำขอวิ่งผ่านได้ตามปกติ หากเกิดข้อผิดพลาดจะเพิ่มตัวนับความล้มเหลวขึ้น
- Open (ตัดวงจร): คำขอจะถูกปฏิเสธกลับไปทันทีโดยไม่มีการยิงออกไปยังปลายทางจริง เมื่อพ้นช่วงเวลาคูลดาวน์ วงจรจะเปลี่ยนสถานะเป็น half-open
- Half-open (ทดลองเปิดรับ): ปล่อยให้คำขอบางส่วนผ่านไปทดสอบ หากคำขอนั้นสำเร็จ วงจรจะกลับมาเป็น Closed แต่ถ้าล้มเหลว ก็จะกลับไป Open อีกครั้ง
การส่งต่อบริบทเทรซ
เมื่อเซอร์วิสของเรายิงคำขอไปยังเซอร์วิสอื่น เราย่อมต้องการให้บริบทการติดตาม (trace context ได้แก่ trace ID, span ID, และ sampling decision) ถูกส่งต่อแนบไปกับคำขอนั้นด้วย นี่คือหัวใจสำคัญที่ช่วยให้คุณสามารถเชื่อมโยงล็อกและสแปน (span) ข้ามพรมแดนระหว่างแต่ละเซอร์วิสได้ และทำให้ระบบ Distributed Tracing เกิดประโยชน์ในการใช้งานจริง ไม่ใช่เป็นเพียงแค่ของประดับ
หากทั้งสองเซอร์วิสใช้งาน OpenTelemetry บริบทของเทรซจะถูกส่งต่อไปทาง HTTP header ชื่อ traceparent (ตามมาตรฐาน W3C Trace Context) ซึ่ง crate อย่าง reqwest-tracing หรือ reqwest-middleware สามารถแทรกเฮดเดอร์นี้ให้อัตโนมัติได้อย่างสะดวกสบาย แต่หากคุณใช้การตั้งค่าที่เรียบง่ายกว่านั้น อย่างน้อยที่สุดก็ควรส่งต่อ request ID ของคุณผ่าน custom header เพื่อให้สามารถนำมาค้นหาจับคู่ล็อกด้วยตนเองได้ คุณจะต้องขอบคุณตัวเองแน่นอนเมื่อต้องตื่นขึ้นมาไล่ตรวจหาปัญหาบน production ตอนตีสอง
#![allow(unused)]
fn main() {
let request_id = "req-abc-123"; // from the inbound request's span
let response = client
.get(url)
.header("x-request-id", request_id)
.send()
.await?;
}
เมื่อไหร่ไม่ควรลองใหม่
ไม่ใช่ทุกข้อผิดพลาดที่จะเหมาะกับการลองใหม่ นี่คือหนึ่งในเรื่องที่ฟังดูเหมือนเข้าใจง่ายเวลาอ่าน แต่จากประสบการณ์จริง ผู้คนมักทำพลาดกันบ่อยมาก การแห่ส่งคำขอลองใหม่อย่างรุนแรงใส่เซอร์วิสที่กำลัง overload อยู่แล้ว มีแต่จะยิ่งทำให้สถานการณ์เลวร้ายลงไปอีก ต่อไปนี้คือสถานการณ์ที่คุณ ไม่ควร ทำการลองใหม่เป็นอันขาด:
- ข้อผิดพลาดฝั่งไคลเอนต์รหัส 4xx (ยกเว้นรหัส 429 Too Many Requests ซึ่งเป็นการแจ้งเตือนอย่างชัดเจนให้คุณเว้นระยะห่างแล้วค่อยส่งใหม่)
- ข้อผิดพลาดที่บ่งชี้ถึงปัญหาถาวร (เช่น ข้อมูลประจำตัวยืนยันตัวตนไม่ถูกต้อง, รีซอร์สถูกลบไปแล้ว, หรือโครงสร้างข้อมูลไม่ตรงกัน)
- เมื่อหมดงบเวลา (deadline) ของการทำงานแล้ว (ไม่มีประโยชน์ที่จะส่งคำขอรอบใหม่ หากฝั่งผู้เรียกเดิมถอดใจและยกเลิกการรอไปแล้ว)
- เมื่อ Circuit Breaker อยู่ในสถานะ Open (เพราะระบบรู้อยู่แล้วว่าปลายทางกำลังมีปัญหา)
หลักการทั่วไปที่ผมยึดถือคือ: ลองใหม่เฉพาะกับความผิดพลาดชั่วคราวโดยใช้ระยะเวลาหน่วงที่เหมาะสม, เคารพ rate limit ของระบบปลายทาง, และให้รีบล้มเหลวโดยเร็ว (fail fast) หากเป็นปัญหาเชิงโครงสร้าง คราวนี้เรามาดูกันว่าเราจะห่อหุ้มตรรกะทั้งหมดนี้ให้ออกมาเป็นโค้ดที่สะอาดเรียบร้อยได้อย่างไร
การห่อไคลเอนต์ขาออก
สำหรับเซอร์วิสปลายทางที่แอปพลิเคชันของคุณจำเป็นต้องเรียกใช้งานอยู่บ่อยครั้ง ผมขอแนะนำให้ห่อหุ้ม reqwest::Client แบบดิบๆ ไว้ภายใน struct ไคลเอนต์โดยเฉพาะ ซึ่ง struct นี้จะทำหน้าที่รวบรวม base URL, กลไกการยืนยันตัวตน, นโยบายการตั้ง timeout, ตรรกะการลองใหม่, และการแปลงข้อผิดพลาดทั้งหมดไว้ในจุดเดียว ให้มองว่านี่คือเวอร์ชันฝั่งขาออกของ repository pattern ที่เราเคยใช้สำหรับจัดการการเข้าถึงฐานข้อมูลนั่นเอง
#![allow(unused)]
fn main() {
pub struct PaymentClient {
http: Client,
base_url: String,
api_key: String,
}
impl PaymentClient {
pub async fn charge(
&self,
amount_cents: i64,
currency: &str,
idempotency_key: &str,
) -> Result<PaymentResult, PaymentError> {
let url = format!("{}/v1/charges", self.base_url);
let response = self.http
.post(&url)
.bearer_auth(&self.api_key)
.header("Idempotency-Key", idempotency_key)
.json(&serde_json::json!({
"amount": amount_cents,
"currency": currency,
}))
.send()
.await
.map_err(PaymentError::Network)?;
match response.status() {
s if s.is_success() => {
let result = response.json().await.map_err(PaymentError::Parse)?;
Ok(result)
}
StatusCode::UNPROCESSABLE_ENTITY => {
let body = response.text().await.unwrap_or_default();
Err(PaymentError::Validation(body))
}
s => Err(PaymentError::Upstream(s)),
}
}
}
}
โครงสร้างเช่นนี้ช่วยให้เซอร์วิสในเลเยอร์โดเมนของเรามีอินเทอร์เฟซที่สะอาดตาและปลอดภัยด้วยระบบชนิดข้อมูล (type-safe) สำหรับติดต่อกับระบบภายนอก โดยช่วยซ่อนรายละเอียดทางเทคนิคของ HTTP เอาไว้เบื้องหลัง ทั้งยังเป็นจุดที่เหมาะสมอย่างยิ่งในการสอดแทรกตรรกะการลองใหม่, ระบบตัดวงจร, และการเก็บเมตริกเพิ่มเติมในอนาคตได้โดยไม่ต้องแตะต้องโค้ดฝั่งผู้เรียกใช้งานเลย จากประสบการณ์ของผม แพตเทิร์นนี้ให้ผลตอบแทนที่คุ้มค่าอย่างรวดเร็ว โดยเฉพาะอย่างยิ่งเมื่อระบบของคุณมี dependency ภายนอกเพิ่มจำนวนมากขึ้นเรื่อยๆ