ไทม์เอาต์ของ HTTP Client ผ่านพร็อกซี: connect, read, write และงบเวลารวมของคำขอ
บทความ
- บทนำ: ทำไมไทม์เอาต์ผ่านพร็อกซีจึงต้องพูดถึงแยกต่างหาก
- พื้นฐาน: ไทม์เอาต์คืออะไร และคำขอประกอบด้วยเฟสอะไรบ้าง
- เจาะลึก: เกิดอะไรขึ้นจริง ๆ เมื่อไทม์เอาต์แต่ละตัวทำงาน
- วิธีที่ 1: ตั้งค่า connect timeout โดยคำนึงถึงการกระโดดสองช่วง
- วิธีที่ 2: read timeout ในฐานะช่วงไม่มีการเคลื่อนไหว และการปกป้องไบต์แรก
- วิธีที่ 3: write timeout และการจัดการ body คำขอขนาดใหญ่
- วิธีที่ 4: งบเวลารวมของคำขอและการแพร่กระจายเดดไลน์
- วิธีที่ 5: การสังเกตไทม์เอาต์และการตั้งค่าแบบปรับตัว
- ข้อผิดพลาดทั่วไป: สิ่งที่ไม่ควรทำ
- เครื่องมือและทรัพยากร
- เคสและผลลัพธ์
- คำถามที่พบบ่อย: คำถามซับซ้อนเรื่องไทม์เอาต์ผ่านพร็อกซี
- บทสรุป: ไทม์เอาต์ในฐานะวินัยทางวิศวกรรม
บทนำ: ทำไมไทม์เอาต์ผ่านพร็อกซีจึงต้องพูดถึงแยกต่างหาก
ลองจินตนาการดูว่า: ตัว scraper ของคุณทำงานมาแล้วสามวัน กินทราฟฟิกพร็อกซีมือถือไปเรื่อย ๆ แต่ผลลัพธ์ที่ได้กลับกลายเป็นระเบียนว่างเปล่าครึ่งหนึ่ง และล็อกก็เต็มไปด้วยคำว่า timeout, connection reset และ remote end closed connection คุ้น ๆ ไหม? เราเคยเห็นระบบแบบนี้มาหลายสิบระบบ และแทบทุกครั้งต้นตอของปัญหาก็คือเรื่องเดียวกัน: ไทม์เอาต์ถูกตั้งค่า "ตามความรู้สึก" — ใช้เลขมหัศจรรย์ตัวเดียวเช่น 30 วินาที ครอบคลุมทุกอย่างไปหมด ผ่านการเชื่อมต่อตรง ๆ แบบนี้ยังพอใช้ได้ แต่ผ่านพร็อกซี โดยเฉพาะพร็อกซีมือถือ ใช้ไม่ได้แล้ว
สาเหตุก็คือพร็อกซีเพิ่มอีกหนึ่งช่วงเครือข่ายเข้าไปในห่วงโซ่ เพิ่มคิวอีกชุด และเพิ่มอีกหนึ่งโหนดที่มีไทม์เอาต์เป็นของตัวเอง คำขอหนึ่งครั้งไม่ได้ผ่านเฟสการรอแค่เฟสเดียว แต่ผ่านห้าถึงหกเฟส และแต่ละเฟสก็ "ค้าง" ได้ด้วยเหตุผลที่ต่างกัน ลิมิตตัวเดียวรวม ๆ ไม่สามารถแยกแยะได้ว่าติดอยู่ตรงไหน: ตอน TCP handshake กับพร็อกซี ตอนสร้างทันเนลไปยังเว็บเป้าหมาย ตอนรอไบต์แรกของคำตอบที่มาช้า หรือตอนส่งบอดี้ก้อนใหญ่
บทความนี้พูดถึงสถาปัตยกรรมของการรอ เราจะแยกให้ดูว่าคำขอ HTTP ผ่านพร็อกซีประกอบด้วยเฟสอะไรบ้าง ไทม์เอาต์ตัวไหนรับผิดชอบแต่ละเฟส เกิดอะไรขึ้นจริง ๆ เมื่อมันทำงาน และจะประกอบลิมิตแยกส่วนให้เป็นงบเวลารวมที่สอดคล้องกันได้อย่างไร สิ่งสำคัญคือต้องแยกให้ชัดจากหัวข้อที่ใกล้เคียงกันตั้งแต่ต้น: ที่นี่เรา ไม่ พูดถึงรหัสตอบกลับ 429 หรือ 503 และกลยุทธ์การ retry แบบ exponential backoff นั่นเป็นอีกชั้นหนึ่ง — การตอบสนองต่อสิ่งที่เซิร์ฟเวอร์ตอบกลับมาแล้ว ที่นี่เราพูดถึงสถานการณ์ที่ไม่มีคำตอบเลย และเรื่องว่าเรายอมรอมันนานแค่ไหนในแต่ละระดับ
หลังจากอ่านจบ คุณจะสามารถ: แตกคำขอใด ๆ ออกเป็นเฟสและกำหนดลิมิตให้แต่ละเฟสได้ อธิบายได้ว่าทำไม client ถึงแสดงไทม์เอาต์ แต่เซิร์ฟเวอร์กลับทำงานสำเร็จไปแล้ว ประสานไทม์เอาต์ของ client, connection pool และตัวพร็อกซีเองให้ถูกต้อง และที่สำคัญที่สุด คือเลิกสูญเสียข้อมูลและเงินกับการรอที่ไร้ประโยชน์
พื้นฐาน: ไทม์เอาต์คืออะไร และคำขอประกอบด้วยเฟสอะไรบ้าง
ไทม์เอาต์คือสัญญาว่าจะรอ
ไทม์เอาต์ คือเวลาสูงสุดที่ client ยอมรอให้เหตุการณ์หนึ่งเกิดขึ้น ก่อนที่จะยอมรับว่าความพยายามล้มเหลวและคืนทรัพยากร คำสำคัญคือ เหตุการณ์หนึ่ง ไม่มีสิ่งที่เรียกว่า "ไทม์เอาต์ของคำขอโดยทั่วไป" มีไทม์เอาต์สำหรับสร้างการเชื่อมต่อ TCP ไทม์เอาต์สำหรับ TLS handshake ไทม์เอาต์สำหรับรอข้อมูลจากซ็อกเก็ต ไทม์เอาต์สำหรับเขียนลงซ็อกเก็ต ไทม์เอาต์รอการเชื่อมต่อว่างในพูล และสุดท้ายคือเดดไลน์รวมของการดำเนินการทั้งหมด
อุปมาที่ดีคือการเดินทางที่มีการต่อรถ คุณมีเวลาถึงสถานี เวลารอรถไฟ เวลาเดินทาง เวลาต่อรถ และมีลิมิตโดยรวมคือ เก้าโมงเช้าคุณต้องถึงที่นัดหมาย ถ้าคุณควบคุมแค่ลิมิตโดยรวม คุณจะรู้เรื่องปัญหาก็ตอนที่คุณไปสายแล้ว ถ้าควบคุมแต่ละช่วง คุณจะตัดสินใจได้ล่วงหน้า เช่น เรียกรถแท็กซี่เพราะรถเมล์ไม่มาเกินสิบนาที
เฟสของคำขอ HTTP ผ่านการเชื่อมต่อตรง
แม้ไม่มีพร็อกซี คำขอหนึ่งครั้งก็ยังเป็นลำดับขั้นตอน:
- การแปลงชื่อ (DNS) client แปลงชื่อโดเมนเป็นที่อยู่ IP ปกติใช้เวลาตั้งแต่หน่วยมิลลิวินาทีถึงหลายร้อยมิลลิวินาที แต่ถ้า resolver มีปัญหาก็ค้างได้หลายวินาที
- การเชื่อมต่อ TCP การจับมือสามทาง: SYN, SYN-ACK, ACK ต้องใช้การไปกลับเต็มรอบ (RTT) หนึ่งครั้งไปยังเซิร์ฟเวอร์
- TLS handshake สำหรับ HTTPS ต้องไปกลับอีกหนึ่งถึงสองรอบ ขึ้นอยู่กับเวอร์ชันโปรโตคอล
- ส่งคำขอ (write) header และ body ถูกเขียนลงซ็อกเก็ต คำขอเล็ก ๆ ใช้เวลาแทบจะทันที ส่วนการอัปโหลดไฟล์ใช้เวลาที่สังเกตได้
- รอไบต์แรกของคำตอบ (TTFB) เซิร์ฟเวอร์กำลังคิด: query ฐานข้อมูล เรนเดอร์หน้าเว็บ เรียกไมโครเซอร์วิสของตัวเอง
- อ่าน body ของคำตอบ (read) ข้อมูลมาเป็นก้อน ระหว่างก้อนก็มีช่วงหยุดบ้าง
พร็อกซีเพิ่มอะไรเข้ามา
พร็อกซีแบ่งห่วงโซ่นี้ออกเป็นสองส่วน client สร้างการเชื่อมต่อกับพร็อกซีเซิร์ฟเวอร์ แล้วพร็อกซีก็สร้างการเชื่อมต่อกับโหนดเป้าหมายเอง สำหรับ HTTPS ผ่าน HTTP พร็อกซีจะใช้วิธี CONNECT: client ขอให้พร็อกซีเปิดทันเนล TCP ไปยัง host และ port พร็อกซีตอบสถานะ 200 และหลังจากนั้น client จึงเริ่ม TLS handshake กับเซิร์ฟเวอร์เป้าหมายผ่านทันเนล สำหรับ SOCKS5 ตรรกะก็คล้ายกัน: มีเฟสทักทายและพิสูจน์ตัวตนกับพร็อกซี จากนั้นคำสั่งสร้างการเชื่อมต่อกับเป้าหมาย แล้วรอการยืนยัน
ผลก็คือได้รายการเฟสที่ยาวขึ้น:
- การแปลงชื่อ (DNS) ของที่อยู่พร็อกซี (ถ้าตั้งเป็นโดเมน)
- การเชื่อมต่อ TCP กับพร็อกซี
- การพิสูจน์ตัวตนและคำสั่งสร้างทันเนล (CONNECT หรือคำขอ SOCKS)
- รอให้พร็อกซีแปลงชื่อ host เป้าหมายและสร้างการเชื่อมต่อ TCP กับมัน — เฟสนี้เกิดฝั่งพร็อกซี แต่ client ก็รออยู่
- TLS handshake กับเซิร์ฟเวอร์เป้าหมายผ่านทันเนล
- ส่งคำขอ HTTP
- รอไบต์แรกของคำตอบ
- อ่าน body
สังเกตข้อสี่ให้ดี ตรงนี้แหละที่กับดักใหญ่ของพร็อกซีมือถือซ่อนอยู่ ตัวพร็อกซีเซิร์ฟเวอร์มักอยู่ในดาต้าเซ็นเตอร์ และการเชื่อมต่อ TCP ไปถึงมันใช้เวลาหลักสิบมิลลิวินาที แต่หลังจากนั้นทราฟฟิกวิ่งผ่านโมเด็มเซลลูลาร์ ซึ่ง RTT อยู่ที่ 40–120 มิลลิวินาที และเมื่อสถานีฐานโหลดหนักก็พุ่งไปถึงครึ่งวินาทีหรือมากกว่า การแปลงชื่อและการจับมือกับเป้าหมายในช่วงนี้ใช้เวลาได้สบาย ๆ หนึ่งถึงสองวินาที client ที่คิดว่า "connect timeout" นับเฉพาะถึงพร็อกซี จะมั่นใจว่าการเชื่อมต่อสำเร็จในพริบตา แล้วก็ไปติดอยู่กับการรอที่ไม่เข้าใจในขั้นตอนถัดไป
เจาะลึก: เกิดอะไรขึ้นจริง ๆ เมื่อไทม์เอาต์แต่ละตัวทำงาน
ตั้งค่าตัวเลขเป็นแค่ครึ่งเดียว การเข้าใจว่าหลังจากลิมิตทำงานแล้วระบบเหลืออยู่ในสถานะไหนสำคัญกว่ามาก มาแยกดูทีละเฟส
เมื่อ connect timeout ทำงาน
client ส่ง SYN ไปแล้วและไม่ได้รับ SYN-ACK ภายในเวลาที่กำหนด ระบบปฏิบัติการเองก็ส่ง SYN ซ้ำตามรูปแบบเอกซ์โพเนนเชียล: 1, 2, 4, 8 วินาที ไปเรื่อย ๆ รวมแล้วถึง 60–120 วินาทีตามค่าเริ่มต้นในเคอร์เนลยอดนิยม connect timeout ของคุณตัดการรอนี้ให้สั้นลง ซ็อกเก็ตถูกปิด ไม่มีข้อมูลใด ๆ ไปถึงเซิร์ฟเวอร์ สถานะฝั่งปลายทางไม่เปลี่ยน นี่คือไทม์เอาต์ที่ ปลอดภัยที่สุด: จะลองซ้ำก็ไม่ต้องกังวลเรื่อง idempotency
ผ่านพร็อกซีภาพจะซับซ้อนขึ้นเล็กน้อย ถ้า TCP ถึงพร็อกซีสร้างสำเร็จ แต่เฟส CONNECT ค้าง client ก็ได้ส่งคำสั่งไปให้พร็อกซีแล้วและกำลังรอสถานะ เมื่อลิมิตทำงาน client ปิดซ็อกเก็ตไปหาพร็อกซี พร็อกซีจะรู้ว่าปิดและมักจะยกเลิกความพยายามเชื่อมต่อกับเป้าหมาย แต่ก็ไม่เสมอไป: บาง implementation จะรอ upstream timeout ของตัวเองก่อน แล้วค่อยคืนทรัพยากร สำหรับ client มองไม่เห็น แต่บนพร็อกซีเซิร์ฟเวอร์จะสะสมการเชื่อมต่อแบบครึ่งเปิดไว้ ซึ่งเมื่อโหลดมากจะลด throughput ของมัน
ข้อควรระวัง: ในไลบรารี client ต่าง ๆ เฟส CONNECT ถูกนับไม่เหมือนกัน บางตัวนับรวมใน connect timeout บางตัวไม่มีอะไรคลุมเลยนอกจากเดดไลน์รวมของคำขอ ถ้าคุณไม่มีเดดไลน์รวม และ CONNECT ค้าง คำขออาจค้างได้ไม่จำกัดเวลา ตรวจสอบไม่ยาก: ชี้ client ไปที่พร็อกซีที่รับ TCP แต่ไม่ตอบ CONNECT (TCP เซิร์ฟเวอร์ธรรมดาที่ไม่มีตรรกะอะไรก็ใช้เป็นกับดักได้) แล้วดูว่ากี่วินาที client ถึงยอมแพ้
เมื่อ TLS handshake timeout ทำงาน
ทันเนล TCP ผ่านพร็อกซีเปิดแล้ว client ส่ง ClientHello ไป แต่ ServerHello ไม่มา สาเหตุ: ช่องทางโมเด็มช้า แพ็กเก็ตหายในฝั่งมือถือ เซิร์ฟเวอร์เป้าหมายโหลดหนักที่รับ TCP แต่ประมวลผล TLS ไม่ทัน เมื่อลิมิตทำงาน ซ็อกเก็ตถูกปิด คำขอ HTTP ยังไม่ถูกส่ง สถานะบนเซิร์ฟเวอร์ไม่เปลี่ยน ปลอดภัยต่อการ retry เช่นกัน
ข้อสังเกตในทางปฏิบัติ: ผ่านช่องทางมือถือ TLS handshake เป็นจุดที่หน่วงบ่อย เพราะต้องไปกลับหลายรอบติดกัน และแพ็กเก็ตที่หายไปหนึ่งครั้งก็เพิ่มเวลาสำหรับการส่งซ้ำอีกวินาที เมื่อเปลี่ยนมาใช้ TLS 1.3 จำนวนรอบลดลง ซึ่งลดสัดส่วนไทม์เอาต์ประเภทนี้ลงอย่างเห็นได้ชัด
เมื่อ write timeout ทำงาน
client กำลังเขียน body ของคำขอลงซ็อกเก็ต แต่บัฟเฟอร์สำหรับส่งเต็มและไม่ถูกปลดปล่อย: ปลายทางไม่ยอมอ่านหรือไม่ยืนยันการรับ เมื่อลิมิตทำงาน ข้อมูลบางส่วนอาจไปถึงเซิร์ฟเวอร์แล้ว ถ้าเป็นการอัปโหลดไฟล์หรือส่งฟอร์ม เซิร์ฟเวอร์อาจได้รับบางส่วน ปกติ body ที่ไม่สมบูรณ์จะทำให้เกิดข้อผิดพลาดในการแยกวิเคราะห์ฝั่งเซิร์ฟเวอร์ แต่สำหรับโปรโตคอลแบบสตรีมและ multipart upload ผลลัพธ์ขึ้นอยู่กับ implementation การ retry คำขอแบบนี้จึงต้องระวัง
เมื่อ read timeout ทำงาน
ตรงนี้แหละที่เริ่มน่าสนใจและอันตรายที่สุด คำขอถูกส่งไปครบแล้ว client รอข้อมูล และมันไม่มาในระยะเวลาที่กำหนด client ปิดซ็อกเก็ตและโยน exception ทิ้ง แต่เกิดอะไรขึ้นที่ปลายอีกด้าน?
พร็อกซีเห็นว่า client ปิดการเชื่อมต่อ พร็อกซีที่ดีจะปิดการเชื่อมต่อ upstream ไปยังเซิร์ฟเวอร์เป้าหมายด้วยในจังหวะนั้น แต่เซิร์ฟเวอร์เป้าหมายได้รับคำขอไปแล้วและกำลังประมวลผลอยู่ ถ้าเป็น POST ที่สร้างคำสั่งซื้อ หักยอดเงิน หรือส่งข้อความ การกระทำนั้นมีโอกาสสูงที่จะสำเร็จ เซิร์ฟเวอร์จะรู้ว่าการเชื่อมต่อขาดก็ต่อเมื่อมันพยายามเขียนคำตอบแล้วเจอ error ซึ่งตอนนั้น transaction ในฐานข้อมูลจบไปนานแล้ว
นี่คือคุณสมบัติพื้นฐานของ read timeout: มันบอกคุณว่าคุณไม่ได้รับคำตอบ แต่ไม่ได้บอกอะไรเลยว่าการกระทำนั้นสำเร็จหรือไม่ ด้วยเหตุนี้สำหรับการดำเนินการที่ไม่มี idempotency read timeout จึงต้องจัดการต่างจาก connect timeout และด้วยเหตุนี้ API จริงจังจึงต้องมี idempotency key
อีกจุดที่ต้องสนใจคือคุณติดอยู่ตรงไหนกันแน่ read timeout ทำงานทั้งตอนรอไบต์แรก (เซิร์ฟเวอร์กำลังคิด) และตอนที่ body หยุดระหว่างก้อน (เซิร์ฟเวอร์ส่งข้อมูลเป็นสตรีมแบบมีดีเลย์) ไลบรารีหลายตัวตีความ read timeout เป็น ช่วงเวลาที่ไม่มีการเคลื่อนไหว ระหว่างการอ่านซ็อกเก็ตสองครั้งที่สำเร็จ ไม่ใช่เวลารวมของการอ่าน ซึ่งหมายความว่าคำตอบขนาดหลายร้อยเมกะไบต์ที่มาด้วยความเร็วหนึ่งกิโลไบต์ต่อวินาทีจะไม่มีวันทำให้ read timeout 10 วินาทีทำงาน เพราะข้อมูลก็ยังมาเรื่อย ๆ ถ้าไม่มีเดดไลน์รวม คำขอแบบนี้อาจค้างได้หลายชั่วโมง
พร็อกซีเห็นอะไรและส่งอะไรกลับมา
พร็อกซีก็มีไทม์เอาต์ของตัวเอง และมันก่อให้เกิดอาการที่ต่างออกไป ถ้าพร็อกซีเชื่อมต่อกับเป้าหมายไม่สำเร็จภายในลิมิตของตัวเอง มันจะตอบกลับคำขอ CONNECT ด้วยสถานะ 502 หรือ 504 — ซึ่งจากมุมของ client นี่ไม่ใช่ไทม์เอาต์ แต่เป็นข้อผิดพลาดของพร็อกซี ถ้าพร็อกซีรอคำตอบจากเป้าหมายแล้วไม่มา มันก็อาจตอบ 504 Gateway Timeout ภายใน HTTP response (สำหรับ HTTP ธรรมดาที่ไม่ใช้ทันเนล) และถ้าพร็อกซีมีลิมิต idle บนทันเนลและมันทำงาน client จะเห็นการเชื่อมต่อขาดทันที — connection reset หรือ response ว่างเปล่า — โดยไม่มีไทม์เอาต์จากฝั่งตัวเองเลย
จากตรงนี้ได้กฏข้อหนึ่ง: ไทม์เอาต์ของ client ต้องสอดคล้องกับไทม์เอาต์ของพร็อกซี ถ้าพร็อกซีตัดทันเนลเมื่อไม่มีกิจกรรม 60 วินาที แต่ read timeout ของคุณคือ 90 วินาที คุณจะไม่เห็นไทม์เอาต์เลย คุณจะเห็นการตัดขาดที่ลึกลับ ถ้าพร็อกซีให้เวลา 30 วินาทีในการเชื่อมต่อกับเป้าหมาย แต่ลิมิตของคุณในเฟสนี้คือ 10 วินาที คุณจะยอมแพ้ก่อนและไม่รู้ว่าจริง ๆ พร็อกซีอาจจะทำสำเร็จก็ได้
วิธีที่ 1: ตั้งค่า connect timeout โดยคำนึงถึงการกระโดดสองช่วง
ทฤษฎี: อะไรถูกครอบคลุม และอะไรที่ควรถูกครอบคลุม
Connect timeout จำกัดการสร้างการเชื่อมต่อระดับ transport ผ่านพร็อกซี สิ่งนี้ตั้งคำถามว่า: เชื่อมต่อกับใคร? ในทางรูปแบบคือกับพร็อกซี แต่ในทางปฏิบัติคือเราสนใจว่าเมื่อไหร่เราจะได้ทันเนลพร้อมใช้ถึงเป้าหมาย ดังนั้นเราขอแนะนำให้คิดเป็นสองลิมิตแยกกัน แม้ไลบรารีจะให้พารามิเตอร์เดียว
ลิมิตช่วงแรก — TCP ถึงพร็อกซีเซิร์ฟเวอร์ พร็อกซีอยู่ในดาต้าเซ็นเตอร์ RTT ถึงมันคงที่ แนวทาง: 5–8 RTT แต่ไม่น้อยกว่า 2 วินาที และไม่เกิน 5 ถ้าพร็อกซีไม่ตอบ SYN ภายใน 3 วินาที ไม่ว่ามันจะโหลดหนักหรือล่ม ก็ไม่มีประโยชน์ที่จะรอต่อ ควรเปลี่ยนไปใช้ที่อยู่อื่นในพูลดีกว่า
ลิมิตช่วงที่สอง — เวลาตั้งแต่ส่ง CONNECT จนได้สถานะ 200 ตรงนี้ช่องทางมือถือทำงาน แนวทางขึ้นอยู่กับว่าเป้าหมายอยู่ที่ไหนและคุณภาพเครือข่ายเซลลูลาร์เป็นอย่างไร: โดยทั่วไป 3–10 วินาที เราสังเกตว่าเปอร์เซ็นไทล์ที่ 95 ของเวลาสร้างทันเนลผ่าน LTE ไปยังเว็บยอดนิยมอยู่ที่ 1.5–2.5 วินาที และเปอร์เซ็นไทล์ที่ 99 อยู่ที่ 4–6 วินาที การตั้งลิมิตต่ำกว่าเปอร์เซ็นไทล์ที่ 99 เท่ากับสูญเสียคำขอทุก ๆ ร้อยครั้งด้วยน้ำมือตัวเอง
วิธีวัดค่าของคุณเอง
- เก็บตัวอย่างอย่างน้อย 500 คำขอผ่านพร็อกซีของคุณไปยัง host เป้าหมายในเวลาต่าง ๆ ของวัน
- บันทึกเวลาแยกกัน: เวลาถึงการสร้าง TCP กับพร็อกซี เวลาถึงการตอบ CONNECT เวลา TLS handshake client ส่วนใหญ่ให้เมตริกเหล่านี้ได้: ใน curl คือตัวแปร time_connect และ time_appconnect ใน Go คือ hook ของ httptrace ใน client ฝั่ง Python คือเหตุการณ์ tracing หรือวัดรอบ phases
- สร้างการกระจายตัว สิ่งที่คุณสนใจคือ p50, p95, p99 และค่าสูงสุด
- ตั้งลิมิตที่ระดับ p99 บวกสำรอง 30–50 เปอร์เซ็นต์ ไม่ใช่ที่ค่าสูงสุด — ค่าผิดปกติมีเสมอ และการปรับตามมันหมายถึงการถือทรัพยากรไว้เพื่อความผิดปกติเพียงไม่กี่ครั้ง
- ทบทวนไตรมาสละครั้ง หรือเมื่อเปลี่ยนโอเปอเรเตอร์ ภูมิภาค หรือแพ็กเกจพร็อกซี
ในทางปฏิบัติใน client ต่าง ๆ
ในไลบรารี requests ของ Python ไทม์เอาต์กำหนดเป็น tuple โดยค่าแรกคือ connect ค่าที่สองคือ read ผ่านพร็อกซี ค่าแรกครอบคลุม TCP ถึงพร็อกซี และโดยปกติครอบคลุมการรอตอบ CONNECT ด้วย เพราะทันเนลถูกสร้างบนซ็อกเก็ตเดียวกันกับลิมิตเดียวกัน ตัวอย่าง:
resp = session.get(url, proxies=proxies, timeout=(5, 20))ใน httpx มีออบเจ็กต์ Timeout แยกต่างหากที่มีสี่ฟิลด์: connect, read, write และ pool นี่คือโมเดลที่ชัดเจนที่สุดในบรรดา client ฝั่ง Python:
timeout = httpx.Timeout(connect=5.0, read=20.0, write=10.0, pool=3.0)ใน curl มีสองแฟล็กหลัก: --connect-timeout กำหนดลิมิตการสร้างการเชื่อมต่อ รวมถึง CONNECT และ TLS ส่วน --max-time คือเพดานรวม ใน Go ไทม์เอาต์สำหรับสร้าง TCP กำหนดผ่าน Dialer ใน Transport, TLS ผ่าน TLSHandshakeTimeout และเฟส CONNECT ถูกจำกัดด้วย context ของคำขอ ใน Java HttpClient นั้น connectTimeout ตั้งบน builder ของ client ส่วนลิมิตของคำขอตั้งบนตัวคำขอเอง ใน Node.js ผ่าน undici มี connectTimeout, headersTimeout และ bodyTimeout บวก AbortSignal สำหรับเดดไลน์รวม
เช็กลิสต์ connect timeout
- ค่าไม่น้อยกว่า 2 และไม่เกิน 10 วินาทีสำหรับพร็อกซีดาต้าเซ็นเตอร์และมือถือตามลำดับ
- คุณรู้แน่ชัดว่า client ของคุณครอบคลุมเฟส CONNECT ด้วยลิมิตนี้หรือไม่
- เมื่อลิมิตทำงาน คุณสลับไปพร็อกซีอื่นในพูล ไม่ใช่กระแทกที่เดิม
- คำนึงว่า OS ส่ง SYN ซ้ำเอง — ลิมิตของคุณต้องสั้นกว่าของระบบ
- สำหรับ host ที่เป็น IPv6 เปิด fallback ไป IPv4 (Happy Eyeballs) ไม่งั้นเส้นทาง IPv6 ที่ล้มเหลวจะกินลิมิตไปหมด
วิธีที่ 2: read timeout ในฐานะช่วงไม่มีการเคลื่อนไหว และการปกป้องไบต์แรก
สองงานที่แตกต่างกันในชื่อเดียวกัน
Read timeout แก้สองปัญหาพร้อมกัน และเป็นประโยชน์ที่จะแยกความคิด แม้ไลบรารีจะให้พารามิเตอร์เดียว
รอไบต์แรก นี่คือเวลาที่เซิร์ฟเวอร์ทำงานกับคำขอของคุณ สำหรับหน้าสแตติกคือหลักสิบมิลลิวินาที สำหรับหน้าผลการค้นหาของมาร์เก็ตเพลสที่มีตัวกรองคือตั้งแต่ครึ่งวินาทีถึงหลายวินาที สำหรับ API รายงานที่หนัก ๆ คือหลายสิบวินาที ผ่านพร็อกซีมือถือยังต้องบวกดีเลย์ของช่องทางขากลับอีก
ช่วงหยุดระหว่างก้อน body เซิร์ฟเวอร์เริ่มส่งข้อมูลแล้ว แต่มีช่วงหยุด: สร้างหน้าเว็บทีละส่วน สตรีมผลลัพธ์ หรือแค่ชนเพดานช่องทางแคบ สิ่งที่สำคัญไม่ใช่ขนาดรวม แต่คือความเงียบสูงสุด
client บางตัวมีพารามิเตอร์แยกกัน ใน Go คือ ResponseHeaderTimeout สำหรับไบต์แรกของ header และกลไกแยกสำหรับ body ใน undici คือ headersTimeout และ bodyTimeout ใน client ฝั่ง Python ส่วนใหญ่ read timeout เดียวทำงานเป็นช่วงไม่มีการเคลื่อนไหวในทุกขั้นตอนของการอ่าน
วิธีเลือกค่า
- กำหนดลักษณะของคำตอบเป้าหมาย หน้า HTML กับ JSON แบบสตรีมต้องการลิมิตต่างกัน
- วัด TTFB ผ่านพร็อกซีของคุณ เอา p99 คูณ 1.5 สำหรับการ scrape เว็บทั่วไปผ่านช่องทางมือถือจะได้ 8–15 วินาที
- วัดช่วงหยุดสูงสุดระหว่าง chunk ในตัวอย่างคำตอบที่สำเร็จ ปกติมันน้อยกว่า TTFB หลายเท่า: 1–3 วินาที ถ้า client ให้ตั้ง bodyTimeout แยกได้ ก็ตั้งให้เข้มกว่า
- อย่าพึ่ง read timeout เป็นการป้องกันการส่งช้าเด็ดขาด สำหรับเรื่องนั้นมีเดดไลน์รวม (วิธีที่ 4)
ทำอย่างไรเมื่อลิมิตทำงาน
ตรงนี้เกิดคำถามสำคัญ: retry ได้ไหม? คำตอบขึ้นอยู่กับ method และความหมายเชิงความหมาย:
- GET, HEAD, OPTIONS — retry ได้ สถานะเซิร์ฟเวอร์ไม่เปลี่ยน (ถ้าเว็บไม่ละเมิดความหมายของโปรโตคอล)
- PUT ที่มี body ครบ, DELETE — ในทางรูปแบบมี idempotency retry ปลอดภัย
- POST ที่ไม่มี idempotency key — retry อาจสร้างรายการซ้ำ การตอบสนองที่ถูกต้องคือ ไม่ retry แบบสุ่มสี่สุ่มห้า แต่ตรวจสอบสถานะด้วยคำขออื่นก่อน หรือทำเครื่องหมายการดำเนินการว่า "ผลลัพธ์ไม่ทราบ" เพื่อกระทบยอดภายหลัง
- POST ที่มี idempotency key — retry ปลอดภัย เซิร์ฟเวอร์จะคืนผลลัพธ์ของการทำงานครั้งแรก
เราขอแนะนำอย่างยิ่งให้ในล็อกและเมตริกแยกความแตกต่างระหว่าง read timeout ก่อนไบต์แรก กับ read timeout กลาง body อย่างแรกมักบ่งชี้ว่าเซิร์ฟเวอร์เป้าหมายหรือพร็อกซีโหลดหนัก อย่างที่สองบ่งชี้ว่าปัญหาช่องทาง วิธีรักษาต่างกัน: กรณีแรกช่วยได้ด้วยการลด concurrency กรณีที่สองช่วยได้ด้วยการเปลี่ยนพร็อกซีหรือภูมิภาค
ลักษณะพิเศษของช่องทางมือถือ
เครือข่ายเซลลูลาร์ทำงานด้วยดีเลย์ที่แปรผัน โมเด็มอาจ "หยุดนิ่ง" หนึ่งถึงสองวินาทีเมื่อสลับระหว่างเซกเตอร์ของสถานีฐาน หรือเมื่อออกจากโหมดประหยัดพลังงาน จากมุมของ client มันดูเหมือนความเงียบในซ็อกเก็ต ถ้า read timeout ของคุณคือ 2 วินาที คุณจะเจอการทำงานผิดพลาดปลอมหลายครั้งต่อชั่วโมงในทุกโมเด็ม เราสังเกตว่าการเพิ่มลิมิตจาก 3 เป็น 6 วินาทีลดสัดส่วนไทม์เอาต์บนพร็อกซีมือถือลง 4–5 เท่า โดยเวลาคำขอเฉลี่ยไม่เพิ่มขึ้นอย่างมีนัยสำคัญ วินาทีที่หยุดนิ่งในคำขอหายาก ๆ ถูกกว่าคำขอซ้ำและทราฟฟิกที่สูญเสียไป
เช็กลิสต์ read timeout
- ค่าอ้างอิงจาก p99 TTFB ที่วัดผ่านพร็อกซีของคุณ ไม่ใช่จากความรู้สึก
- คุณเข้าใจว่าลิมิตคือช่วงไม่มีการเคลื่อนไหว ไม่ใช่เวลาการอ่านรวม
- สำหรับคำขอที่ไม่มี idempotency ไม่มี retry อัตโนมัติโดยไม่ตรวจสอบเมื่อลิมิตทำงาน
- ในเมตริกแยกไทม์เอาต์ก่อนไบต์แรกและภายใน body
- ค่าน้อยกว่า idle timeout ของทันเนลฝั่งพร็อกซี
วิธีที่ 3: write timeout และการจัดการ body คำขอขนาดใหญ่
เมื่อการเขียนสามารถค้างได้จริง ๆ
สำหรับคำขอส่วนใหญ่ body พอดีใน TCP segment เดียวและออกไปทันที — การเขียนจบก่อนที่ข้อมูลจะออกจากเครื่องด้วยซ้ำ write timeout จึงมีความหมายในสามกรณี: การอัปโหลดไฟล์ การส่ง JSON array ขนาดใหญ่ และการส่งข้อมูลใด ๆ ผ่านช่องทางแคบ พร็อกซีมือถือเป็นช่องทางแบบนั้นในทิศทางขาออก: ความเร็วอัปโหลดจากโมเด็มมักต่ำกว่าความเร็วดาวน์โหลดอย่างเห็นได้ชัด และบัฟเฟอร์บนโหนดกลางก็จำกัด
กลไกเป็นอย่างนี้: client เรียก write ข้อมูลเข้าบัฟเฟอร์ส่งของซ็อกเก็ต เคอร์เนลส่งเป็นก้อนตามการยืนยันที่ได้รับ ถ้าการยืนยันไม่มา บัฟเฟอร์เต็ม และการเขียนครั้งถัดไปถูกบล็อก write timeout จำกัดเวลาของการบล็อกแบบนี้
สามกลยุทธ์สำหรับ body ขนาดใหญ่
กลยุทธ์ A: ลิมิตเดี่ยวสำหรับการเขียน วิธีง่าย: write timeout หนึ่งตัวสำหรับทั้งคำขอ เหมาะกับ body ถึงไม่กี่เมกะไบต์ ค่าเลือกจากประมาณการ: ขนาด body หารด้วยความเร็วต่ำสุดที่ยอมรับได้ บวกสำรอง ตัวอย่าง: 5 เมกะไบต์ที่ความเร็วต่ำสุด 500 กิโลไบต์ต่อวินาที คือ 10 วินาที บวกสำรองเป็น 15
กลยุทธ์ B: ลิมิตต่อก้อน client เขียน body เป็น chunk แล้วจำกัดเวลาของแต่ละครั้ง ส่วนใหญ่ client แบบอะซิงโครนัสทำงานแบบนี้: write timeout ในนั้นหมายถึงช่วงหยุดสูงสุดในการส่งหนึ่งก้อน ค่าคือ 3–10 วินาที ไม่ขึ้นกับขนาดไฟล์ การป้องกันการส่งช้าทั้งหมดต้องพึ่งเดดไลน์รวม
กลยุทธ์ C: ควบคุมความเร็ว client ติดตามความเร็วส่งจริงและยกเลิกคำขอถ้ามันต่ำกว่าเกณฑ์ต่อเนื่อง N วินาที curl มีคู่แฟล็กสำหรับเรื่องนี้: --speed-limit และ --speed-time นี่คือเครื่องมือที่แม่นยำที่สุด: มันแยกแยะ "ช้าแต่ยังไป" กับ "ติดแล้ว"
เกิดอะไรขึ้นเมื่อลิมิตทำงาน
body บางส่วนไปถึงเซิร์ฟเวอร์แล้ว ถ้าคุณอัปโหลดไฟล์ในคำขอเดียว เซิร์ฟเวอร์จะได้ body ที่ถูกตัด สำหรับโปรโตคอล multipart ส่วนใหญ่มักทำให้เกิดข้อผิดพลาดในการแยกวิเคราะห์และปฏิเสธทั้งหมด ซึ่งปลอดภัย สำหรับ API ที่รองรับการอัปโหลดต่อเนื่องจากจุดเดิม (tus, โปรโตคอลแบบ chunk ของคลาวด์สตอเรจ) การตอบสนองที่ถูกต้องคือขอ offset จากเซิร์ฟเวอร์และทำต่อจากตรงนั้น เราขอแนะนำให้ใช้การอัปโหลดต่อเนื่องสำหรับ body ใด ๆ ที่เกิน 10 เมกะไบต์ผ่านพร็อกซีมือถือ: คำขอยาว ๆ เดียวผ่านช่องทางเซลลูลาร์เปราะบางต่อการขาดการเชื่อมต่อเกินไป
การตั้งค่าทีละขั้นสำหรับการอัปโหลดผ่านพร็อกซี
- ประเมินความเร็วส่งมัธยฐานและต่ำสุดผ่านพร็อกซีของคุณ อัปโหลดไฟล์ทดสอบ 5–10 เมกะไบต์ยี่สิบครั้งในเวลาต่าง ๆ
- ถ้าความเร็วผันผวนเกินสามเท่า ให้ใช้กลยุทธ์ B หรือ C ไม่ใช่ลิมิตเดี่ยว
- แบ่งไฟล์ใหญ่เป็นส่วน 1–5 เมกะไบต์ ถ้าเซอร์วิสเป้าหมายรองรับ
- ตั้ง write timeout ต่อก้อนที่ 5–10 วินาที
- เสริมด้วยเดดไลน์รวมสำหรับทั้งคำขอ คำนวณจากขนาดและความเร็วต่ำสุดอย่างแน่นอน
- เมื่อลิมิตทำงาน — ระบุว่าเซิร์ฟเวอร์ได้รับอะไรไปแล้วบ้าง ไม่ใช่เริ่มใหม่ทั้งหมด
วิธีที่ 4: งบเวลารวมของคำขอและการแพร่กระจายเดดไลน์
ทำไมผลรวมของลิมิตย่อยยังไม่ใช่งบเวลา
สมมติว่าคุณตั้ง connect 5, TLS 5, write 10, read 15 วินาที ดูเหมือนคำขอไม่น่ายาวเกิน 35 วินาที แต่ read timeout คือช่วงไม่มีการเคลื่อนไหว คำตอบที่มาทีละหนึ่งกิโลไบต์ทุก 14 วินาที จะไม่มีวันละเมิดมัน คำขอ 10 เมกะไบต์ในอัตรานั้นจะใช้เวลาเกือบทั้งวัน ถ้าไม่มีลิมิตโดยรวม worker ของคุณจะถูกจับไว้ไม่สิ้นสุด connection pool จะหมด และระบบจะหยุด — ทั้งที่ไม่มีไทม์เอาต์ย่อยตัวใดทำงานเลย
งบเวลารวม (deadline, total timeout) คือเพดานแน่นอนสำหรับการดำเนินการทั้งหมด ตั้งแต่การเรียกระบบครั้งแรกจนถึงไบต์สุดท้ายที่อ่านได้ มันไม่ได้แทนที่ลิมิตย่อย แต่เสริมมัน: ลิมิตย่อยให้การวินิจฉัยที่รวดเร็วและแม่นยำ ส่วนลิมิตโดยรวมให้การรับประกันว่ามันจะจบ
วิธีคำนวณงบเวลา
เราทำจากบนลงล่าง ไม่ใช่จากล่างขึ้นบน เริ่มจากคำถาม: เวลารอสูงสุดสำหรับผลลัพธ์หนึ่งรายการที่ยอมรับได้สำหรับงานธุรกิจคือเท่าไร? สำหรับสถานการณ์แบบอินเทอร์แอกทีฟ (ผู้ใช้รอ) — 3–10 วินาที สำหรับการ scrape เบื้องหลัง — 30–60 วินาที สำหรับการอัปโหลดไฟล์ขนาดใหญ่ — คำนวณจากขนาด
จากนั้นงบเวลานี้ถูกแบ่งไปยังแต่ละเฟสตามการกระจายที่วัดได้:
- การสร้างทันเนลผ่านพร็อกซี (TCP บวก CONNECT บวก TLS): โดยทั่วไป 15–25 เปอร์เซ็นต์ของงบ
- การเขียนคำขอ: 5–10 เปอร์เซ็นต์สำหรับคำขอทั่วไป
- รอไบต์แรก: 30–40 เปอร์เซ็นต์
- อ่าน body: ส่วนที่เหลือ
ตัวอย่าง: งบ 30 วินาทีสำหรับการ scrape ผ่านพร็อกซีมือถือ connect (รวม CONNECT) 6 วินาที TLS 4 วินาที write 3 วินาที read ในฐานะช่วงไม่มีการเคลื่อนไหว 10 วินาที เดดไลน์รวม 30 วินาที ผลรวมของลิมิตย่อยคือ 23 วินาที น้อยกว่างบ — เป็นเรื่องปกติ เพราะพวกมันทำงานแยกกัน เดดไลน์รวมจับกรณีการส่งช้าที่ไม่มีลิมิตย่อยตัวไหนจับได้
การแพร่กระจายเดดไลน์ผ่านห่วงโซ่
ในระบบแบบกระจาย คำขอแทบไม่เคยเป็นเพียงครั้งเดียว เซอร์วิสของคุณได้รับงานที่มีลิมิต 30 วินาที ใช้เวลา 4 วินาทีเตรียมการ แล้วผ่านพร็อกซีไปยังเว็บเป้าหมาย คำขอ HTTP เหลือเวลาเท่าไร? ไม่ใช่ 30 แต่เป็น 26 วินาทีลบสำรองสำหรับประมวลผลคำตอบ นี่แหละคือ การแพร่กระจายเดดไลน์: การเรียกครั้งถัดไปแต่ละครั้งได้รับไม่ใช่ไทม์เอาต์คงที่ แต่เป็นงบเวลาที่เหลือ
ใน Go สิ่งนี้ทำได้ด้วย context ที่มีเดดไลน์ ซึ่งส่งต่อไปยังคำขอ ใน Python — ผ่าน asyncio ด้วยการส่งเวลาที่เหลืออย่างชัดเจน ใน Java — คำนวณ Duration ก่อนการเรียกแต่ละครั้ง กฏมีข้อเดียว: ไทม์เอาต์สำหรับคำขอ HTTP คำนวณแบบไดนามิก เป็นค่าที่น้อยที่สุดระหว่างลิมิตคงที่และงบเวลาที่เหลือ
ถ้าไม่มีสิ่งนี้จะเกิดปัญหาคลาสสิก: ชั้นบนเลิกawait ไปแล้วและคืนข้อผิดพลาด แต่ชั้นล่างยังถือการเชื่อมต่อผ่านพร็อกซีอีกสิบวินาทีและกินทราฟฟิกเพื่อผลลัพธ์ที่ไม่มีใครต้องการ เมื่อทราฟฟิกพร็อกซีมือถือมีค่าใช้จ่าย นี่คือการเผาเงินอย่างแท้จริง
Connection pool และไทม์เอาต์ของมันเอง
อีกสองลิมิตที่มักถูกลืม Pool timeout — รอนานแค่ไหนสำหรับการเชื่อมต่อว่างจากพูล ถ้าทุกอันไม่ว่าง ถ้าไม่กำหนด เมื่อโหลดพุ่ง คำขอจะรออย่างไม่จำกัด และภายนอกดูเหมือน client ค้าง ตั้งไว้ 1–3 วินาที: ถ้าภายในเวลานั้นการเชื่อมต่อไม่ว่าง ระบบโหลดหนักและควรปฏิเสธทันที
Idle timeout ของการเชื่อมต่อในพูล — การเชื่อมต่อ keep-alive ที่ไม่ได้ใช้นานแค่ไหนก่อนถูกปิด ตรงนี้การประสานกับพร็อกซีสำคัญมาก ถ้าพร็อกซีปิดการเชื่อมต่อที่ไม่มีกิจกรรมใน 60 วินาที แต่พูลของคุณเก็บไว้ 90 วินาที คุณจะหยิบซ็อกเก็ตตายจากพูลที่วินาทีที่ 61 ส่งคำขอเข้าไป แล้วเจอ connection reset — ไม่ใช่ไทม์เอาต์ แต่คือการขาดการเชื่อมต่อ ไลบรารีหลายตัว retry คำขออย่างโปร่งใสในสถานการณ์นี้ แต่เฉพาะ method ที่มี idempotency กฎคือ: idle timeout ของ client ต้องน้อยกว่า idle timeout ของพร็อกซีอย่างเคร่งครัด โดยมีสำรองอย่างน้อย 10–20 เปอร์เซ็นต์
เฟรมเวิร์ก "งบเวลาจากบนลงล่าง"
- กำหนดข้อจำกัดทางธุรกิจเรื่องเวลารอผลลัพธ์
- ลบเวลาสำหรับการประมวลผลของตัวเองและสำรองสำหรับ retry ถ้ามี
- ส่วนที่เหลือคือเดดไลน์รวมของคำขอ HTTP
- แบ่งมันไปยังแต่ละเฟสตาม p99 ที่วัดได้ของแต่ละเฟสผ่านพร็อกซีของคุณ
- ตรวจสอบว่าลิมิตย่อยแต่ละตัวน้อยกว่าลิมิตที่สอดคล้องกันฝั่งพร็อกซี
- ตั้ง pool timeout และ idle timeout ของพูล ให้สอดคล้องกับพร็อกซี
- implement การส่งงบเวลาที่เหลือไปยังการเรียกซ้อนใน
- ล็อกว่าลิมิตตัวไหนทำงาน และเวลาที่ใช้ในแต่ละเฟส
วิธีที่ 5: การสังเกตไทม์เอาต์และการตั้งค่าแบบปรับตัว
ไม่มีการวัด ก็ไม่มีการตั้งค่า
วิธีทั้งหมดข้างต้นชนกำแพงเดียวกัน: คุณต้องรู้การกระจายเวลาจริงในแต่ละเฟสผ่านพร็อกซีของคุณ วิธีเดียวที่จะรู้คือวัดอย่างต่อเนื่อง client สมัยใหม่มี hook tracing: จุดเริ่ม DNS, การสร้าง TCP, การได้ตอบ CONNECT, การจบ TLS, การส่งคำขอ, ไบต์แรก, ไบต์สุดท้าย รวบรวมเหตุการณ์เหล่านี้เป็นเมตริก แยกตามพร็อกซี host เป้าหมาย และประเภทข้อผิดพลาด
ควรเก็บเมตริกอะไร
- ฮิสโตแกรมระยะเวลาแต่ละเฟส แยกตามพร็อกซีเอ็นด์พอยต์และโอเปอเรเตอร์
- สัดส่วนการทำงานของไทม์เอาต์แต่ละประเภทต่อจำนวนคำขอทั้งหมด
- สัดส่วนไทม์เอาต์ก่อนไบต์แรกเทียบกับภายใน body
- สัดส่วนการขาดการเชื่อมต่อโดยไม่มีไทม์เอาต์ (สัญญาณของ idle-limit ที่ไม่สอดคล้องกัน)
- เวลาเฉลี่ยที่ใช้กับคำขอที่จบด้วยไทม์เอาต์ — นี่คือการขาดทุนตรง ๆ ของคุณในรูปทราฟฟิกและทรัพยากร
ไทม์เอาต์แบบปรับตัว
เทรนด์ของช่วงหลายปีที่ผ่านมา ซึ่งกลายเป็นมาตรฐานในระบบที่โตเต็มที่ในปี 2026 คือ ลิมิตแบบปรับตัว แทนที่จะเป็นตัวเลขคงที่ client จะเก็บหน้าต่างเลื่อนของการสังเกตสำหรับแต่ละคู่พร็อกซี-เป้าหมาย และตั้งไทม์เอาต์เป็น p99 ของหน้าต่างคูณค่าสำรอง จำกัดด้วยขอบเขตบนและล่างที่สมเหตุสมผล เมื่อช่องทางแย่ลง ลิมิตจะเพิ่มขึ้นและมีการทำงานผิดพลาดปลอมน้อยลง เมื่อช่องทางกลับมาดี ลิมิตจะลดลงและระบบตอบสนองต่อปัญหาจริงได้เร็วขึ้น
implementation ไม่ซับซ้อน: บัฟเฟอร์วงกลม 200–500 ค่าล่าสุดต่อคีย์ คำนวณควอนไทล์ใหม่ทุกไม่กี่วินาที ขอบเขตเช่น "ไม่น้อยกว่า 3 และไม่เกิน 20 วินาทีสำหรับ read" สิ่งสำคัญคือต้องป้องกันการเสื่อมสภาพ: ถ้าทุกคำขอเริ่มไทม์เอาต์ หน้าต่างจะเต็มไปด้วยค่าที่ระดับลิมิต และลิมิตจะเพิ่มขึ้นเรื่อย ๆ ดังนั้นหน้าต่างควรรับเฉพาะคำขอที่สำเร็จ และการเพิ่มลิมิตถูกจำกัดด้วยขอบเขตบน
คำขอแบบ hedged
สำหรับการอ่านผ่านพูลที่มีพร็อกซีหลายตัว มีเทคนิคที่ลดผลกระทบของหางช้าโดยไม่ต้องเพิ่มไทม์เอาต์: ถ้าคำขอไม่เสร็จภายในเวลา p95 ให้ส่งสำเนาผ่านพร็อกซีอื่นและเอาคำตอบที่มาก่อน สิ่งนี้เพิ่มทราฟฟิกสองสามเปอร์เซ็นต์ แต่ลด p99 ของ latency ลงอย่างมาก เหมาะกับคำขอที่มี idempotency เท่านั้น และต้องยกเลิกสำเนาที่แพ้อย่างระมัดระวังเพื่อไม่ให้ทราฟฟิกเสียเปล่า
ข้อผิดพลาดทั่วไป: สิ่งที่ไม่ควรทำ
ตัวเลขเดียวครอบคลุมทุกอย่าง
ข้อผิดพลาดที่พบบ่อยที่สุด ไทม์เอาต์เดียว 30 วินาทีหมายความว่าคุณจะใช้เวลาครึ่งนาทีในการพบพร็อกซีที่ตาย และจะไม่มีวันพบคำตอบที่ช้ากลาง body แยกเฟสออกจากกัน
ไม่มีไทม์เอาต์เป็นค่าเริ่มต้น
ไลบรารียอดนิยมหลายตัวไม่มีไทม์เอาต์มาให้ตั้งแต่ต้น: คำขออาจค้างได้ไม่จำกัด ใน requests ยังเป็นแบบนี้จนถึงทุกวันนี้ การเรียกใด ๆ ที่ไม่มีไทม์เอาต์ชัดเจนผ่านพร็อกซีคือ worker ที่อาจถูกบล็อกตลอดไป
Read timeout มากกว่า idle-limit ของพร็อกซี
คุณจะไม่เห็นไทม์เอาต์ คุณจะเห็นการขาดการเชื่อมต่อ และจะไปหาปัญหาผิดที่ หาลิมิตของพร็อกซีโพรไวเดอร์ของคุณและตั้ง client ต่ำกว่าอย่างเคร่งครัด
Retry แบบสุ่มสี่สุ่มห้าหลัง read timeout บน POST
ทางตรงไปสู่คำสั่งซื้อซ้ำ การหักเงินซ้ำ และข้อความซ้ำ หลัง read timeout บนคำขอที่ไม่มี idempotency ผลลัพธ์ไม่ทราบแน่ชัด — ต้องจัดการกับมัน ไม่ใช่เดา
ละเลยเฟส CONNECT
คิดว่า connect timeout ครอบคลุมการสร้างทันเนล โดยไม่ตรวจสอบในเอกสารของไลบรารีที่ใช้ ใน client บางตัว เฟส CONNECT ค้างจนถึงเดดไลน์รวม และถ้าไม่มี ก็ค้างไม่จำกัด
ปรับตามค่าสูงสุด
เห็นคำขอหนึ่งครั้งใช้ 45 วินาที ก็ตั้งลิมิต 60 ตอนนี้ทุกปัญหาจริงทำให้คุณต้องรอนาทีหนึ่ง อ้างอิง p99 บวกสำรอง และปล่อยค่าผิดปกติให้กลไก retry หรือ hedging
ไทม์เอาต์ที่ไม่ยกเลิกงานชั้นล่าง
ชั้นบนโยน exception ตามลิมิตของตัวเอง แต่คำขอ HTTP ยังมีชีวิตอยู่ในงานเบื้องหลัง ข้อผิดพลาดที่พบบ่อยในโค้ดอะซิงโครนัส: wrapper ที่มี timeout ทำงานเสร็จ แต่ coroutine ไม่ถูกยกเลิก ตรวจสอบว่าการทำงานของไทม์เอาต์นำไปสู่การปิดซ็อกเก็ตจริง
ลิมิตเดียวกันสำหรับพร็อกซีดาต้าเซ็นเตอร์และมือถือ
ความต่างของดีเลย์และ jitter ระหว่างสองแบบคือหลายเท่าตัว โปรไฟล์ที่ใช้ได้บนพร็อกซีเซิร์ฟเวอร์ บนมือถือกลับก่อไทม์เอาต์ปลอมนับไม่ถ้วน แยกโปรไฟล์การตั้งค่าไว้
ไม่มี pool timeout
เมื่อโหลดพุ่ง คำขอรอการเชื่อมต่อว่างไม่จำกัด ภายนอกดูเหมือน client ทั้งตัวค้าง ทั้งที่ทราฟฟิกเครือข่ายเป็นศูนย์
เครื่องมือและทรัพยากร
การวินิจฉัยจากบรรทัดคำสั่ง
curl ยังคงเป็นเครื่องมือมาตรฐานสำหรับแยกเฟส แฟล็ก --connect-timeout, --max-time, --speed-limit, --speed-time ครอบคลุมทุกระดับ และรูปแบบผลลัพธ์ -w ที่มีตัวแปรเวลาก็แสดงว่าแต่ละเฟสใช้เวลาเท่าไร:
curl -x http://user:pass@proxy:port --connect-timeout 5 --max-time 30 -o /dev/null -s -w "dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}" https://example.com/สังเกตว่า: ผ่านพร็อกซี ตัวแปร time_connect แสดงเวลาถึงพร็อกซี และ time_appconnect แสดงถึงการจบ TLS กับเป้าหมาย นั่นคือรวม CONNECT ผลต่างระหว่างสองตัวคือช่วงที่สองของคุณ
ไลบรารี client และโมเดลไทม์เอาต์ของพวกมัน
- Python requests: tuple (connect, read) ไม่มี write และไม่มีไทม์เอาต์รวม ตัวรวมต้องใช้ wrapper ภายนอกหรือยกเลิกระดับ thread
- Python httpx: ออบเจ็กต์ Timeout ที่มี connect, read, write, pool ไม่มีตัวรวม แต่ในโหมดอะซิงโครนัสเติมได้ง่ายด้วยการรอแบบมีลิมิตและยกเลิก
- Python aiohttp: ClientTimeout ที่มีฟิลด์ total, connect, sock_connect, sock_read ตัวเดียวในบรรดา client ยอดนิยมฝั่ง Python ที่มีลิมิตโดยรวมในตัว
- Go net/http: Dialer.Timeout, TLSHandshakeTimeout, ResponseHeaderTimeout, ExpectContinueTimeout, IdleConnTimeout บน transport; Client.Timeout เป็นตัวรวม; context ของคำขอเป็นเดดไลน์ไดนามิก
- Java HttpClient: connectTimeout บน client, timeout บนคำขอ (ครอบคลุมถึงการได้ header) การอ่าน body จำกัดที่ระดับ BodyHandler หรือ wrapper
- Node.js undici: connectTimeout, headersTimeout, bodyTimeout, keepAliveTimeout; ตัวรวม — ผ่าน AbortSignal.timeout
การวิเคราะห์ทราฟฟิก
tcpdump และ Wireshark ช่วยให้เห็นว่าเกิดอะไรขึ้นจริงบนสาย: SYN ออกไปไหม SYN-ACK มาไหม ใครส่ง FIN หรือ RST ก่อน นี่เป็นวิธีเดียวที่จะตอบคำถาม "ใครตัดการเชื่อมต่อ — ฉัน พร็อกซี หรือเซิร์ฟเวอร์" ได้อย่างน่าเชื่อถือ สำหรับเนื้อหา HTTPS การมองเห็นจำกัด แต่เฟสการเชื่อมต่อและทันเนลมองเห็นได้ทั้งหมด
แท่นทดสอบสำหรับจำลอง
สำหรับทดสอบพฤติกรรมของ client เมื่อค้าง มีประโยชน์ที่จะมีชุดกับดัก: TCP เซิร์ฟเวอร์ที่รับการเชื่อมต่อแล้วเงียบ (ทดสอบ connect และ CONNECT); HTTP เซิร์ฟเวอร์ที่ตอบ header แล้วเงียบ (ทดสอบ read ก่อนถึง body); เซิร์ฟเวอร์ที่ส่งหนึ่งไบต์ต่อวินาที (ทดสอบเดดไลน์รวม) การเขียนกับดักเหล่านี้ใช้เวลาครั้งชั่วโมง แต่เวลาที่ประหยัดได้จากการดีบักในโปรดักชันวัดเป็นวัน นอกจากนี้ยังมีเครื่องมือจำลองเครือข่ายที่เพิ่มดีเลย์ jitter และการสูญเสียแพ็กเก็ตบนอินเทอร์เฟซ เพื่อจำลองช่องทางมือถือในห้องแล็บ
การสังเกต
มาตรฐานกลายเป็นการเก็บเมตริกและ tracing ในรูปแบบ OpenTelemetry พร้อม instrumentation อัตโนมัติของ HTTP client ฮิสโตแกรมตามเฟส แอตทริบิวต์ที่มีตัวระบุพร็อกซีและประเภทลิมิตที่ทำงาน — เป็นชุดขั้นต่ำที่หากไม่มี การตั้งค่าก็กลายเป็นการเดา
เคสและผลลัพธ์
เคส 1: การ scrape มาร์เก็ตเพลสผ่านพร็อกซีมือถือ
ทีมเก็บการ์ดสินค้าผ่านพูลพร็อกซีมือถือ การตั้งค่าเดิม: ไทม์เอาต์เดียว 15 วินาที ไม่มีเดดไลน์รวม connection pool มาตรฐาน อาการ: 11 เปอร์เซ็นต์ของคำขอจบด้วยข้อผิดพลาด สองในสามเป็นไทม์เอาต์ อีกหนึ่งในสามเป็นการขาดการเชื่อมต่อ ระยะเวลาเฉลี่ยของคำขอที่ล้มเหลวคือ 14 วินาที นั่นคือทุก ๆ คำขอที่สิบกินเวลาและทราฟฟิกไปเปล่า ๆ
การวินิจฉัยตามเฟสพบว่า: p99 ของการสร้างทันเนลคือ 4.8 วินาที p99 ของ TTFB คือ 6.2 วินาที ช่วงหยุดสูงสุดระหว่าง chunk ของคำตอบที่สำเร็จคือ 2.1 วินาที idle-limit ของทันเนลฝั่งโพรไวเดอร์คือ 60 วินาที แต่พูลของ client เก็บการเชื่อมต่อ 120 วินาที
การเปลี่ยนแปลง: connect 7 วินาทีที่ครอบคลุม CONNECT, read 9 วินาที, write 5 วินาที, เดดไลน์รวม 25 วินาที, idle ของพูล 45 วินาที, pool timeout 2 วินาที แยกไทม์เอาต์ก่อนไบต์แรกและภายใน body ในเมตริก
ผลลัพธ์หลังหนึ่งสัปดาห์: สัดส่วนข้อผิดพลาดรวมลดลงเหลือ 3.4 เปอร์เซ็นต์ การขาดการเชื่อมต่อหายไปเกือบทั้งหมด ระยะเวลาเฉลี่ยของคำขอที่ล้มเหลวลดลงเหลือ 8 วินาที การใช้ทราฟฟิกต่อหน่วยข้อมูลที่เก็บได้ลดลง 19 เปอร์เซ็นต์ ไม่มีการเปลี่ยนแปลงตรรกะการ retry — แค่ไทม์เอาต์เท่านั้น
เคส 2: การเชื่อมต่อกับ API การชำระเงินและรายการซ้ำ
เซอร์วิสส่งคำขอ POST เพื่อสร้างรายการชำระเงินผ่านพร็อกซีองค์กร read timeout 10 วินาที และ retry อัตโนมัติเมื่อมี exception ใด ๆ ทุกไม่กี่วันเกิดรายการซ้ำ การวิเคราะห์พบ: API เป้าหมายในช่วงโหลดหนักตอบกลับใน 11–14 วินาที client ตัดที่ read timeout แล้ว retry คำขอ และทั้งสองรายการก็สำเร็จ
วิธีแก้ประกอบด้วยสามส่วน: เพิ่ม read timeout เป็น 20 วินาทีบนพื้นฐานของ p99 ที่วัดได้ 15 วินาที; เปลี่ยน retry หลัง read timeout บน POST เป็นการขอสถานะรายการด้วย client identifier; เพิ่ม idempotency key ใน header ที่ API รองรับ รายการซ้ำหยุดหมดสิ้น ข้อสรุปแยกของทีม: read timeout บนคำขอที่ไม่มี idempotency ไม่ใช่ข้อผิดพลาด แต่เป็นสถานะ "ผลลัพธ์ไม่ทราบ" ที่ต้องมีสาขาการจัดการแยก
เคส 3: การอัปโหลดไฟล์มีเดียผ่านช่องทางมือถือ
แอปอัปโหลดวิดีโอขนาด 50–200 เมกะไบต์ผ่านพร็อกซีมือถือในคำขอเดียว write timeout 30 วินาที ไม่มีเดดไลน์รวม อาการ: ประมาณ 8 เปอร์เซ็นต์ของการอัปโหลดขาดกลางทาง ความล้มเหลวแต่ละครั้งหมายถึงเริ่มใหม่ทั้งหมด ทราฟฟิกที่ใช้เกินต่อวันสูงถึงหลายสิบกิกะไบต์
เปลี่ยนมาใช้การอัปโหลดแบบ chunk ละ 4 เมกะไบต์พร้อมทำต่อจากจุดเดิม write timeout ต่อ chunk 8 วินาที ควบคุมความเร็วต่ำสุด 100 กิโลไบต์ต่อวินาทีต่อเนื่อง 10 วินาที เดดไลน์รวมต่อ chunk 60 วินาที สัดส่วนการอัปโหลดที่ล้มเหลวทั้งหมดลดลงเหลือ 0.3 เปอร์เซ็นต์ ทราฟฟิกที่ใช้ซ้ำลดลง 12 เท่า เพราะ retry เฉพาะ chunk สุดท้ายที่ล้มเหลวเท่านั้น
เคส 4: CONNECT ค้างโดยไม่มีเดดไลน์รวม
ตัวเก็บข้อมูลแบบอะซิงโครนัสบนไลบรารี Python ตัวหนึ่งค้างเป็นระยะ: worker ยังมีชีวิต เครือข่ายเงียบ คิวไม่ขยับ ผ่านไปหนึ่งถึงสองชั่วโมงก็รีสตาร์ทตัวเก็บด้วยมือ การวิเคราะห์พบ: พร็อกซีบางตัวในพูลรับ TCP แต่ไม่ตอบ CONNECT ในการตั้งค่าที่ใช้ เฟสนี้ไม่ถูกครอบคลุมด้วยลิมิตใดเลย การเพิ่มเดดไลน์รวมสำหรับทั้งคำขอและลิมิตชัดเจนสำหรับการสร้างทันเนลกำจัดการค้างได้หมด นอกจากนี้เพิ่ม healthcheck พร็อกซีที่ตรวจสอบเฟส CONNECT จริง ๆ ไม่ใช่แค่การเข้าถึง TCP
คำถามที่พบบ่อย: คำถามซับซ้อนเรื่องไทม์เอาต์ผ่านพร็อกซี
ไทม์เอาต์ของ client ต่างจาก 504 จากพร็อกซีอย่างไร?
ไทม์เอาต์ของ client คือการตัดสินใจของคุณเองที่จะเลิกรอ พร็อกซีและเซิร์ฟเวอร์จะรู้ก็ต่อเมื่อการเชื่อมต่อถูกปิด คำตอบ 504 คือการตัดสินใจของพร็อกซี: มันเองรอเซิร์ฟเวอร์เป้าหมายไม่ไหวและบอกคุณด้วย HTTP response เต็มรูปแบบ กรณีแรกซ็อกเก็ตถูกปิดพร้อม exception กรณีที่สองคุณได้คำตอบปกติที่มีรหัสข้อผิดพลาด การจัดการต่างกัน: 504 หมายความว่าพร็อกซียังมีชีวิตอยู่แน่นอน และปัญหาอยู่ต่ำลงไปในห่วงโซ่ ไทม์เอาต์ของ client ไม่บอกอะไรเลยว่าติดอยู่ตรงไหน
ทำไมผ่านพร็อกซีมือถือต้องใช้ไทม์เอาต์นานกว่าผ่านพร็อกซีดาต้าเซ็นเตอร์?
เพราะ jitter ดีเลย์เฉลี่ยของช่องทางเซลลูลาร์ไม่ได้มากนัก แต่การกระจายตัวของมันมหาศาล: การสลับระหว่างเซกเตอร์ โหมดประหยัดพลังงานของโมเด็ม การแย่งทรัพยากรวิทยุ ไทม์เอาต์ตั้งตามหางของการกระจาย และหางของช่องทางมือถือยาวกว่าหลายเท่า ขณะที่ลิมิตยาวเกินไปก็เป็นโทษ — มันทำให้การพบพร็อกซีที่ตายจริงช้าลง สมดุลทำได้ด้วยการวัด p99 และสำรอง 30–50 เปอร์เซ็นต์ ไม่ใช่การคูณสองทุกตัวเลข
จะรู้ได้อย่างไรว่าไทม์เอาต์ตัวไหนทำงาน ถ้าไลบรารีโยน exception รวมเดียว?
สามวิธี วิธีแรก — ตามเวลา: ถ้า exception มาหลังจากเวลาที่เท่ากับ connect timeout ไม่ใช่ read คุณก็รู้เฟส วิธีที่สอง — ผ่าน hook tracing: ถ้าเหตุการณ์ "TLS จบ" เกิดแล้ว แต่ "ไบต์แรก" ไม่เกิด ก็ติดที่ TTFB วิธีที่สาม — ตามข้อความและประเภท exception: ไลบรารีหลายตัวแยก ConnectTimeout กับ ReadTimeout เป็นคลาสต่างกัน เราขอแนะนำให้ล็อกเสมอว่าเฟสไหนเสร็จก่อน exception — สิ่งนี้เปลี่ยนไทม์เอาต์ลึกลับให้เป็นการวินิจฉัยที่แม่นยำ
retry คำขอหลัง write timeout ทำงานได้ไหม?
สำหรับ GET ที่ไม่มี body — ได้ ไม่มีอะไรออกไป สำหรับ POST ที่มี body — เฉพาะถ้าคุณมั่นใจว่าเซิร์ฟเวอร์ปฏิเสธ body ที่ไม่สมบูรณ์ เซิร์ฟเวอร์ส่วนใหญ่ทำแบบนั้น: JSON ที่ไม่สมบูรณ์หรือ multipart ที่ถูกตัดทำให้เกิดข้อผิดพลาดในการแยกวิเคราะห์ แต่ API แบบสตรีมที่เริ่มประมวลผลเมื่อรับข้อมูล อาจนำการเปลี่ยนแปลงไปใช้บางส่วนได้ ถ้าไม่แน่ใจ — ตรวจสอบสถานะก่อน retry
จะประสานไทม์เอาต์ของ client กับไทม์เอาต์ของพร็อกซีโพรไวเดอร์ได้อย่างไร?
ขอจากโพรไวเดอร์หรือหาในเอกสารสามค่า: ลิมิตการเชื่อมต่อกับ host เป้าหมาย, idle-limit ของทันเนล และอายุสูงสุดของการเชื่อมต่อ ลิมิตของคุณสำหรับสร้างทันเนลต้องไม่น้อยกว่าของโพรไวเดอร์ (ไม่งั้นคุณยอมแพ้ก่อนที่พร็อกซีจะทำได้) และ read timeout กับ idle ของพูลของคุณต้องน้อยกว่า idle-limit ของโพรไวเดอร์อย่างเคร่งครัด ถ้าไม่มีเอกสาร ให้วัดเชิงประจักษ์: เปิดการเชื่อมต่อ เงียบ N วินาที ลองส่งคำขอ หา threshold ที่หลังจากนั้นการเชื่อมต่อขาด
ต้องมีเดดไลน์รวมไหม ถ้าตั้งลิมิตย่อยครบแล้ว?
ต้องแน่นอน ลิมิตย่อยไม่จำกัดเวลารวม: การส่ง body ช้าที่ละหนึ่งกิโลไบต์โดยมีช่วงห่างน้อยกว่า read timeout อาจยืดเยื้อไม่จำกัด เดดไลน์รวมคือการรับประกันเดียวว่า worker จะถูกปลดปล่อย นอกจากนี้ เมื่อแพร่กระจายงบเวลาผ่านห่วงโซ่การเรียก เดดไลน์รวมนั่นแหละที่ถูกส่งต่อไปข้างล่าง ส่วนลิมิตย่อยยังเป็นการตั้งค่าในเครื่อง
HTTP/2 และ HTTP/3 มีผลต่อโมเดลไทม์เอาต์ผ่านพร็อกซีอย่างไร?
HTTP/2 multiplex คำขอหลายตัวในหนึ่งการเชื่อมต่อ ดังนั้น read timeout ระดับซ็อกเก็ตจึงไม่ใช่ไทม์เอาต์ของคำขอเดียวอีกต่อไป: ซ็อกเก็ตได้รับข้อมูลของ stream อื่น การไม่มีการเคลื่อนไหวของคำขอหนึ่งจึงไม่ปรากฏ ต้องมีลิมิตระดับ stream — client HTTP/2 ส่วนใหญ่มีผ่านเดดไลน์คำขอ HTTP/3 บน QUIC ยังเปลี่ยนเฟสการเชื่อมต่อ: handshake รวมกับการเข้ารหัส และ connect timeout ครอบคลุมทั้งคู่ ผ่านพร็อกซี CONNECT แบบคลาสสิก โดยทั่วไป HTTP/3 ไปถึงเป้าหมายไม่ผ่าน — ทันเนลเป็นแบบ TCP และ client จะ fallback ไป HTTP/2 หรือ HTTP/1.1 ส่วน extension สำหรับทันเนล UDP ผ่านพร็อกซีกำลังพัฒนา แต่ในปี 2026 การรองรับใน client ทั่วไปยังจำกัด
ทำอย่างไรถ้าหลังไทม์เอาต์ การเชื่อมต่อถูกคืนกลับพูลและคำขอถัดไปล้มเหลว?
นี่เป็นสัญญาณว่า client ไม่ได้ปิดซ็อกเก็ตอย่างถูกต้อง หรือพูลไม่ได้ทำเครื่องหมายการเชื่อมต่อว่าเสีย การเชื่อมต่อที่ read timeout ทำงานใช้ซ้ำไม่ได้: อาจมีไบต์ของคำตอบที่มาสายค้างอยู่ ซึ่งจะถูกอ่านเป็นคำตอบของคำขอถัดไป ตรวจสอบว่า client ของคุณปิดการเชื่อมต่อเมื่อไทม์เอาต์ ไม่ใช่คืนกลับพูล ใน client ที่ออกแบบดี พฤติกรรมนี้เป็นค่าเริ่มต้น แต่เมื่อมี wrapper ของตัวเองและการทำงานกับซ็อกเก็ตระดับต่ำ ข้อผิดพลาดนี้พบได้บ่อย
ตั้งค่าไทม์เอาต์สำหรับพร็อกซี SOCKS5 ต่างจาก HTTP พร็อกซีอย่างไร?
หลักการเดียวกัน ต่างกันที่เฟส: แทนที่ CONNECT ด้วยการทักทาย การพิสูจน์ตัวตน และคำสั่งเชื่อมต่อ ซึ่งคือการไปกลับสองสามรอบถึงพร็อกซี บวกเวลาเชื่อมต่อของพร็อกซีกับเป้าหมาย ใน client ส่วนใหญ่ SOCKS handshake ทั้งหมดอยู่ใน connect timeout ตรวจสอบว่าค่าคำนึงถึงไม่เฉพาะ TCP ถึงพร็อกซี แต่รวมเวลาเชื่อมต่อของพร็อกซีกับเป้าหมายผ่านช่องทางมือถือ — 3–10 วินาทีเช่นกัน
บทสรุป: ไทม์เอาต์ในฐานะวินัยทางวิศวกรรม
มาสรุปกัน คำขอ HTTP ผ่านพร็อกซีไม่ใช่การดำเนินการเดียว แต่เป็นห่วงโซ่ของเจ็ดถึงแปดเฟสการรอ แต่ละเฟสมีธรรมชาติของดีเลย์และผลลัพธ์เมื่อขาดการเชื่อมต่อต่างกัน ไทม์เอาต์ connect และ TLS ปลอดภัย: ไม่มีอะไรออกไปยังเซิร์ฟเวอร์ ลองใหม่ได้ write timeout ทิ้งเซิร์ฟเวอร์ไว้กับข้อมูลที่ไม่สมบูรณ์ read timeout — ร้ายกาจที่สุด: คำขอถูกส่งไปแล้วและอาจจะทำสำเร็จแล้ว แต่คุณไม่รู้ เดดไลน์รวมไม่ได้แทนที่ลิมิตย่อย แต่กันการส่งช้าที่พวกมันจับไม่ได้
ผ่านพร็อกซีมือถือทั้งหมดนี้รุนแรงขึ้น: ช่วงที่สองผ่านช่องทางที่มี jitter สูง และลิมิตที่ปรับบนพร็อกซีเซิร์ฟเวอร์กลับก่อไทม์เอาต์ปลอมนับไม่ถ้วน วิธีเดียวที่จะตั้งค่าถูกต้องคือวัดการกระจายตามเฟสผ่านพร็อกซีเฉพาะของคุณ และตั้งลิมิตตาม p99 บวกสำรอง ประสานกับลิมิตของพร็อกซีเอง
ขั้นตอนต่อไปของคุณ:
- หาทุกการเรียก HTTP ผ่านพร็อกซีในโค้ดของคุณ และตรวจว่ามีไทม์เอาต์ชัดเจนครบทุกเฟสและมีเดดไลน์รวม
- ตรวจสอบว่า client ของคุณครอบคลุมเฟส CONNECT ไหม และตีความ read timeout อย่างไร — เป็นช่วงไม่มีการเคลื่อนไหวหรือเวลารวม
- หาข้อมูล idle-limit และลิมิตการเชื่อมต่อของพร็อกซีโพรไวเดอร์ แล้วปรับการตั้งค่า client ให้สอดคล้อง
- เปิด tracing เฟสและเก็บการกระจายเป็นเวลาหนึ่งสัปดาห์
- คำนวณลิมิตใหม่ตาม p99 แยกโปรไฟล์สำหรับพร็อกซีดาต้าเซ็นเตอร์และมือถือ
- แยกการจัดการไทม์เอาต์สำหรับคำขอที่มีและไม่มี idempotency
- เพิ่มในเมตริกประเภทลิมิตที่ทำงานและเฟสที่มันทำงาน
ไทม์เอาต์ไม่ใช่พารามิเตอร์ที่ตั้งครั้งเดียวแล้วลืม มันเป็นส่วนหนึ่งของสัญญาของระบบคุณกับโลกภายนอก และเช่นเดียวกับสัญญาใด ๆ มันต้องการการวัด การทบทวน และการประสานของทั้งสองฝ่าย ทำแบบนี้อย่างเป็นระบบสักครั้ง แล้วคุณจะประหลาดใจว่าล็อกของคุณเงียบลงแค่ไหน และทราฟฟิกของคุณถูกลงแค่ไหน