บทนำ: ทำไมแบนด์วิดท์บนพร็อกซีถึงสำคัญกว่าที่คิด

คนส่วนใหญ่พูดถึงพร็อกซีในเรื่องความเป็นส่วนตัว ตำแหน่งทางภูมิศาสตร์ และ "จะโดนแบนไหม" แต่แบนด์วิดท์กลับถูกมองข้าม ทั้งที่มันเป็นตัวกำหนดว่าพาร์เซอร์ของคุณจะทำงานเสร็จในกี่ชั่วโมง หนึ่งช่องสัญญาณรับบัญชีได้กี่บัญชี และทำไมสคริปต์ที่รันลื่นบนเครื่องทดสอบ กลับเริ่มโยน timeout ทุกสิบนาทีเมื่อขึ้นโปรดักชัน

เราจะมาคุยเรื่องที่ rarely มีคนเขียนอย่างเป็นระบบ นั่นคือ ขีดจำกัดแบนด์วิดท์ บนพร็อกซีทำงานอย่างไร shaping กับ policing ต่างกันตรงไหน เพดานช่องสัญญาณในตัวเลขจริงเป็นแบบไหน และที่สำคัญที่สุด โค้ดไคลเอนต์ของคุณทำตัวอย่างไรเมื่อชนเพดานนั้น เราจะไม่พูดถึงวิธีประเมินคุณภาพพร็อกซีโดยรวม ที่นี่พูดเรื่องแบนด์วิดท์ ขีดจำกัดของมัน และสิ่งที่เกิดกับแอปพลิเคชันตอนช่องสัญญาณอิ่มตัวเท่านั้น

ทำไมเรื่องนี้ถึงร้อนแรงตอนนี้? เพราะพอถึงปี 2026 หน้าเว็บหนึ่งหน้าเมื่อรวมทรัพยากรทั้งหมดทะลุสามเมกะไบต์ไปแล้ว API ส่ง JSON กลับมาหนักขึ้นเรื่อย ๆ และช่องสัญญาณมือถือที่พร็อกซีมือถือต้องใช้ ก็แชร์คลื่นวิทยุของเซลล์เดียวกันกับผู้ใช้ทั่วไป ในขณะเดียวกัน โอเปอเรเตอร์และผู้ให้บริการพร็อกซีก็เริ่มใช้ shaping ระดับเซสชันมากขึ้น เพื่อไม่ให้ลูกค้ารายเดียว "กิน" ช่องสัญญาณจนคนอื่นไม่มีใช้ นักพัฒนาที่ไม่เข้าใจกลไกของตัวจำกัดจะต้องเขียนโค้ดแบบลองผิดลองถูกไปตลอด

จากคู่มือนี้คุณจะได้เรียนรู้: วิธีแยก shaper กับ policer จากรูปกราฟ วิธีวัดเพดานของสตรีมเดียวและของภาพรวมอย่างถูกต้อง วิธีประเมินขนาด "ถัง" และความลึกของคิว ทำไมเวลาเน็ตอิ่มตัวแล้ว latency พุ่งและประสิทธิภาพตก วิธีเขียนไคลเอนต์ที่มี backpressure และขนานแบบปรับตัว และวิธีวางแผนงบประมาณทราฟฟิกเป็นไบต์แทนจำนวนรีเควส ปิดท้ายด้วยเช็กลิสต์ เครื่องมือ เคสจริงสามเคสพร้อมตัวเลข และ FAQ คำถามยาก ๆ

พื้นฐาน: คำศัพท์ที่ต้องรู้ก่อนไปต่อ

แบนด์วิดท์, throughput และความเร็วที่มีประโยชน์

ศัพท์เหล่านี้มักถูกใช้ปนกัน แต่ความต่างสำคัญมาก แบนด์วิดท์ (bandwidth) คือเพดานระบุของช่องสัญญาณว่าส่งได้กี่บิตต่อวินาทีในอุดมคติ Throughput คือจำนวนบิตที่ผ่านจริงต่อหน่วยเวลา รวม overhead ทั้งหมด ทั้งเฮดเดอร์ TCP/IP การส่งซ้ำ และการเข้ารหัส Goodput คือเฉพาะไบต์ที่ไปถึงแอปพลิเคชันและถูกใช้จริง ถ้าไฟล์ 100 เมกะไบต์ดาวน์โหลดเสร็จใน 20 วินาที goodput ของคุณคือ 5 เมกะไบต์ต่อวินาที แม้ช่องสัญญาณอาจส่งได้มากกว่านี้ 8–12 เปอร์เซ็นต์เพราะข้อมูลควบคุม

สิ่งสำคัญที่ต้องจำ: ตัวจำกัดบนพร็อกซีนับ throughput ระดับแพ็กเก็ตเกือบทั้งหมด แต่คุณเห็น goodput ระหว่างสองค่านี้จะมีช่องว่างเสมอ

เพดานช่องสัญญาณและระดับของขีดจำกัด

เพดาน คือความเร็วสูงสุดที่ตัวจำกัดอนุญาตในระดับการรวมที่กำหนด ระดับมีหลายชั้นและซ้อนกันเหมือนตุ๊กตา:

  • ต่อการเชื่อมต่อ TCP — แต่ละสตรีมเกิน เช่น 2 เมกะบิตต่อวินาทีไม่ได้ แต่สิบสตรีมรวมกันได้ยี่สิบ
  • ต่อเซสชันหรือพอร์ตพร็อกซี — ทุกการเชื่อมต่อผ่านพอร์ตเดียวแชร์ลิมิตรวม
  • ต่อบัญชี — รวมทุกพอร์ตของไคลเอนต์
  • ต่อโหนด — ขีดจำกัดกายภาพของโมเด็ม เซิร์ฟเวอร์ หรือ uplink
  • ต่อช่องสัญญาณโอเปอเรเตอร์ — สิ่งที่เซลล์ให้ได้ในขณะนั้นเมื่อคิดภาระเครือข่ายวิทยุ

เพดานจริงคือค่าต่ำสุดของทุกระดับ และค่านี้ลอยไปมาตามเวลา เพราะระดับล่างสุดคือช่องสัญญาณวิทยุ ขึ้นกับจำนวนผู้ใช้附近โมเด็ม

Token bucket: กลไกของตัวจำกัดแทบทุกตัว

นึกภาพถังที่มีโทเคนหยดลงมาด้วยความเร็วคงที่ ทุกไบต์ที่ผ่านตัวจำกัดจะหยิบโทเคนหนึ่งอัน ถ้าถังว่าง ไบต์นั้นรอ (shaping) หรือถูกทิ้ง (policing) ความเร็วที่หยดคือ rate หรือความเร็วเป้าหมาย ขนาดถังคือ burst หรือการระเบิดที่อนุญาต ระหว่างที่ถังเต็มคุณส่งชุดข้อมูลเร็วกว่าปกติได้ หลังจากนั้นความเร็วจะเรียบลงเท่า rate

แบบจำลองนี้อธิบายได้เยอะมาก ทำไมสองวินาทีแรกดาวน์โหลดเร็ว потомช้าลง? ถังยังเต็ม ทำไมรีเควสสั้นแทบไม่ชนลิมิต? มันพอดีกับขนาดถัง ทำไมดาวน์โหลดยาวจู่ ๆ "ดร็อป" ลงตัวเลขเดียว? ถังว่างแล้ว ทำงานที่ rate ล้วน

Shaping กับ Policing

Shaper เอาะแพ็กเก็ตเกินไปต่อคิวและปล่อยออกด้วยความเร็วที่กำหนด ทราฟฟิกเนียนขึ้น สูญเสียน้อย แต่ latency เพิ่ม: แพ็กเก็ตรอคิว Policer ไม่มีคิว มันทิ้งทุกอย่างที่เกินลิมิตทันที latency ไม่เพิ่ม แต่ TCP เห็นการสูญเสีย ลดหน้าต่างลง sharply แล้วค่อยเร่งใหม่ กราฟความเร็วกลายเป็นฟันเลื่อย

เปรียบเทียบ: shaper คือไฟจราจรที่ปรับเวลาไฟเขียวได้ ทุกคันผ่านได้แต่ช้าลง policer คือรถลากที่เก็บรถเกินโควตาทุกคัน กระแสรถจะกระตุก สำหรับโค้ดคุณความต่างนี้มหาศาล เราจะกลับมาพูดถึง

ลักษณะเฉพาะของช่องสัญญาณมือถือ

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

เจาะลึก: เกิดอะไรขึ้นตอนช่องสัญญาณอิ่มตัว

ชั่วโมงแห่งความจริง: คิวเริ่มยาว

ระหว่างที่ทราฟฟิกต่ำกว่าเพดาน ตัวจำกัดแทบมองไม่เห็น ปัญหาเริ่มเมื่อผลรวมของสตรีมเกิน rate shaper จะเริ่มสะสมคิว แต่ละแพ็กเก็ตก่อนออกไปต้องรอในบัฟเฟอร์ ถ้าบัฟเฟอร์ลึก และบัฟเฟอร์แบบนี้มักถูกตั้งค่าไว้บนอุปกรณ์เครือข่ายราคาถูกหรือซอฟต์แวร์จำกัดที่มีการตั้งค่ามากเกิน latency อาจพุ่งจาก 60 มิลลิวินาทีเป็นหนึ่งวินาทีครึ่ง ปรากฏการณ์นี้เรียกว่า bufferbloat: บัฟเฟอร์ที่บวมทำให้ช่องสัญญาณเร็วกลายเป็นช้าและหนืด

สำหรับแอปพลิเคชันมันหน้าตาแบบนี้: ความเร็วดาวน์โหลดดูปกติ แต่ทุก reเควสใหม่เริ่มด้วย latency มหาศาล API ที่เคยใช้ 100 มิลลิวินาทีกลับใช้หนึ่งวินาที timeout ที่ตั้ง "เผื่อไว้" เริ่มทำงาน และที่หลอกที่สุดคือคุณจะไม่เห็น packet loss ทุกอย่างแค่ช้าลง

ปฏิกิริยา TCP: ทำไมอัลกอริทึมควบคุมความแออัดถึงสำคัญ

TCP พยายามหาเพดานช่องสัญญาณเอง อัลกอริทึมคลาสสิกอย่าง CUBIC เร่งหน้าต่างส่งจนเจอ loss แล้ว复位ความเร็วและเร่งใหม่ กับ policer CUBIC ทำงานได้แย่: loss บ่อยและรุนแรง ความเร็วเฉลี่ยอาจต่ำกว่าเพดาน 30–40 เปอร์เซ็นต์ กับ shaper CUBIC เติมคิวจนเต็มเพราะไม่มี loss นาน และมันเองก็เป็นตัวการหลักของ bufferbloat

อัลกอริทึม BBR ที่ถูกใช้บนเซิร์ฟเวอร์มากขึ้นทำตัวต่าง: มันประเมิน throughput และ RTT ต่ำสุด และพยายามไม่ทำคิวล้น ผ่าน shaper BBR ให้ความเร็วเรียบและ latency ปานกลาง แต่จำไว้: อัลกอริทึมฝั่งไคลเอนต์ควบคุมเฉพาะสตรีมขาออก สตรีมขาเข้าจากพร็อกซีถึงคุณถูกกำหนดโดยการตั้งค่าพร็อกซีและเว็บไซต์ปลายทาง ซึ่งคุณควบคุมไม่ได้

อุโมงค์เดียวหลายสตรีม: head-of-line blocking

เวลาคุณทำงานผ่าน HTTP proxy ด้วยวิธี CONNECT หรือ SOCKS5 การเชื่อมต่อ TCP ทุกเส้นของคุณไปยังเว็บไซต์ปลายทางจะถูกห่อเป็นการเชื่อมต่อแยกกับพร็อกซี ถ้าคุณใช้ HTTP/2 ไปยังเว็บไซต์ปลายทางในอุโมงค์เดียว ทุกรีเควสจะ multiplex กันใน TCP สตรีมเดียว ตอนอิ่มตัวจะเกิด head-of-line blocking: คำตอบหนักหนึ่งอันกินหน้าต่าง และรีเควสเบา ๆ ต้องรออยู่ข้างหลัง ผ่านตัวจำกัดต่อการเชื่อมต่อมันเจ็บเป็นพิเศษ: multiplex ทั้งหมดแชร์ลิมิตเดียว

บทเรียนปฏิบัติที่หลายคนรู้ตัวสายไป: การขนานผ่านพร็อกซีต้องสร้างบน TCP หลายเส้น ไม่ใช่ multiplex ในเส้นเดียว เราจะนำไปใช้ในหัวข้อโค้ด

ความเป็นธรรมระหว่างสตรีม

ตัวจำกัดแบ่งแบนด์วิดท์ระหว่างการเชื่อมต่อสิbเส้นของคุณอย่างไร? ถ้าลิมิตรวมและมีคิวเดียว สตรีมที่ก้าวร้าวกว่าจะกวาดแบนด์วิดท์ไป คือสตรีมที่มีข้อมูลบินอยู่มากกว่า รีเควสเล็กจะแพ้รายใหญ่ตลอด ถ้าตัวจำกัดมีคิวแบบเป็นธรรม แต่ละสตรีมจะได้ส่วนเท่ากัน จะรู้ว่าเจอแบบไหนต้องทดลองเท่านั้น และจากตรงนี้เองขึ้นกับว่าจะควรแยกดาวน์โหลดหนักกับ API เบาไปคนละการเชื่อมต่อหรือคนละพอร์ตเลยหรือเปล่า

Slow start กับรีเควสสั้น

TCP เริ่มจากหน้าต่างเล็กและเพิ่มเป็นสองเท่าทุก RTT ผ่านช่องสัญญาณมือถือที่ RTT ประมาณ 80 มิลลิวินาที การเร่งไปถึง เช่น 20 เมกะบิตใช้เวลาหลายร้อยมิลลิวินาที รีเควส 50 กิโลไบต์จบก่อนที่ TCP จะเร่งทัน ดังนั้นรีเควสสั้นไม่เคยชนเพดานแบนด์วิดท์ แต่ไวต่อ latency มาก นี่แยกทราฟฟิกคุณเป็นสองคลาสด้วยกฎต่างกัน: สตรีมหนักที่ rate สำคัญ และสตรีมเบาที่ RTT สำคัญ ขีดจำกัดเดียวบีบคลาสแรก และ bufferbloat จากคลาสแรกฆ่าคลาสที่สอง

ลายเซ็นบนกราฟ

ถ้าคุณพล็อตความเร็วต่อวินาที ตัวจำกัดจะบอกตัวตนผ่านรูปทรง:

  • ที่ราบเรียบพร้อมทางออกนุ่มนวล และ RTT เพิ่มขึ้น — shaper ที่มีคิวลึก
  • ที่ราบเรียบมีโหนกตอนต้น — shaper หรือ policer ที่มี burst bucket ชัดเจน
  • ฟันเลื่อย ที่มีรอยดิ่ง 30–50 เปอร์เซ็นต์ RTT คงที่ มี retransmission — policer
  • แกว่งวุ่นวายไม่มีที่ราบชัด — คุณชนไม่ใช่ตัวจำกัด แต่เป็นช่องสัญญาณวิทยุหรือโหนดที่โหลดหนัก

การอ่านลายเซ็นพวกนี้ช่วยประหยัดชั่วโมงการดีบัก ต่อไปคือวิธีเก็บมันอย่างถูกต้อง

วิธีที่ 1: วัดเพดานแบนด์วิดท์อย่างถูกต้อง

ทำไมต้องมีวิธี ไม่ใช่แค่เช็คครั้งเดียว

เปิดดาวน์โหลดไฟล์แล้วดูตัวเลข ใครก็ทำได้ ปัญหาคือตัวเลขเดียวไม่มีความหมาย: มันขึ้นกับเวลาของวัน แหล่งข้อมูล ช่องสัญญาณของคุณเอง และเฟส slow start เราต้องมีโปรโตคอลที่ทำซ้ำได้ ผลลัพธ์เปรียบเทียบข้ามช่องสัญญาณและข้ามวันได้

เตรียมแหล่งอ้างอิง

กฎข้อแรก: วัดแบนด์วิดท์ต้องวัดกับแหล่งที่เร็วกว่าพร็อกซีแน่นอน ไม่งั้นคุณวัดแหล่ง ไม่ใช่วัดพร็อกซี ตัวเลือกที่เหมาะคือเซิร์ฟเวอร์ของคุณเองบนพื้นที่ที่มี uplink gigabit รับประกัน มีไฟล์ทดสอบขนาด 20, 100 และ 500 เมกะไบต์ สร้างจากข้อมูลสุ่ม ข้อมูลสุ่มสำคัญ: ไฟล์ที่บีบอัดได้อาจถูกบีบอัดระหว่างทาง และคุณจะได้ตัวเลขที่สูงเกินจริง

ไฟล์ทดสอบสาธารณะจาก CDN ยอดนิยมใช้ได้ แต่มีข้อแม้: CDN ส่งจากโหนดที่ใกล้พร็อกซีที่สุด และคุณกำลังวัดแบนด์วิดท์ "พร็อกซี — CDN" ไม่ใช่ "พร็อกซี — ไซต์ใดก็ได้" สำหรับประเมินเพดานยอมรับได้ แต่สำหรับประเมิน goodput จริงไปยังทรัพยากรเป้าหมายของคุณ ไม่ได้

ขจัดคอขวดของตัวเอง

เครื่องที่คุณวัดต้องมีช่องสัญญาณกว้างกว่าอย่างน้อยสามเท่าของเพดานพร็อกซีที่คาด เช็คด้วยการดาวน์โหลดไฟล์เดียวกันโดยตรง ปิดดาวน์โหลดพื้นหลัง ซิงค์คลาวด์ อัปเดต ถ้าคุณรันการวัดจากคอนเทนเนอร์หรือ VM ตรวจสอบว่าเครือข่ายเสมือนไม่ได้ตัดแบนด์วิดท์เอง

โปรโตคอลสตรีมเดียว

  1. เริ่มดาวน์โหลดไฟล์ 100 เมกะไบต์ผ่านพร็อกซีด้วยการเชื่อมต่อเดียว บันทึกความเร็วทุกวินาที ผ่าน curl ทำได้ด้วยคีย์ progress แต่สะดวกกว่าคือเขียนสคริปต์เล็กที่อ่าน body แบบสตรีมและบันทึกไบต์รายวินาที
  2. ทิ้งสามวินาทีแรก — มี slow start และการล้างถัง
  3. หยุดวัดที่ 40–60 วินาทีหรือเมื่อไฟล์จบ น้อยกว่า 20 วินาทีไม่พอให้เห็นสภาวะคงตัว
  4. คำนวณจากวินาทีที่เหลือ: มัธยฐาน เปอร์เซ็นไทล์ที่สิบและเก้าสิบ สัมประสิทธิ์ความแปรผัน (ส่วนเบี่ยงเบนมาตรฐานหารด้วยค่าเฉลี่ย)
  5. ทำซ้ำสามครั้ง ห่างกันหนึ่งนาที

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

โปรโตคอลภาพรวม

ทีนี้ทำแบบเดียวกันแต่ใช้ 2, 4, 8 และ 16 การเชื่อมต่อขนานไปยังไฟล์เดียวกันหรือหลายไฟล์ รวมความเร็วต่อวินาที จะได้ความสัมพันธ์ระหว่างความเร็วรวมกับจำนวนสตรีม มีสามแบบ:

  • เพิ่มเชิงเส้นจนถึงที่ราบ — ลิมิตต่อการเชื่อมต่อ เพดานภาพรวมสูงกว่า ที่ราบแสดงระดับถัดไปของขีดจำกัด
  • ที่ราบตั้งแต่สตรีมแรก — ลิมิตใช้ร่วมกันทั้งเซสชัน สตรีมเพิ่มไม่ได้อะไร นอกจากเพิ่ม latency
  • เพิ่มแล้วตก — จำนวนสตรีมมากทำให้ loss และ overhead เพิ่ม ช่องสัญญาณเสื่อม จุดที่เหมาะสมคือที่การเพิ่มหยุด

curl เดียวสำหรับปฐมนิเทศเร็วหน้าตาแบบนี้: curl -x http://user:pass@host:port -o /dev/null -w "%{speed_download} %{time_total}" https://your-server/100mb.bin มันให้ความเร็วเฉลี่ยทั้งไฟล์ พอสำหรับประเมินเบื้องต้น แต่สำหรับลายเซ็นต้องบันทึกรายวินาที

การกระจายตามเวลา

สำหรับช่องสัญญาณมือถือต้องวัดสี่ช่วงเวลาต่อวัน: กลางคืน เช้า กลางวัน เย็น เพดานตอนเย็นในย่านที่พักอาศัยอาจต่ำกว่ากลางคืนครึ่งหนึ่ง ถ้าคุณวางแผนโหลดตลอด 24 ชั่วโมง โค้ดต้องอยู่กับเพดานตอนเย็น ไม่ใช่ตอนกลางคืน

เช็กลิสต์การวัดเพดาน

  • แหล่งอ้างอิงเร็วกว่าพร็อกซีแน่นอน ไฟล์จากข้อมูลสุ่ม
  • ช่องสัญญาณตัวเองตรวจแยกและกว้างกว่าอย่างน้อยสามเท่า
  • บันทึกไบต์รายวินาที ทิ้งสามวินาทีแรก
  • ระยะสภาวะคงตัวไม่น้อยกว่า 20 วินาที
  • ทำซ้ำสามครั้ง มัธยฐานและเปอร์เซ็นไทล์ สัมประสิทธิ์ความแปรผัน
  • ชุดตามจำนวนสตรีม: 1, 2, 4, 8, 16
  • สี่ช่วงเวลาต่อวันสำหรับช่องสัญญาณมือถือ
  • ผลลัพธ์บันทึกในรูปแบบเดียวกัน ระบุเวลา พอร์ต แหล่งข้อมูล

วิธีที่ 2: ระบุชนิดของตัวจำกัดและพารามิเตอร์

ทำไมต้องรู้ว่าเจออะไร

เพดานเดียวกันที่ 10 เมกะบิตต้องใช้โค้ดต่างกัน ขึ้นกับว่าเป็น shaper หรือ policer มี burst bucket ไหม ขนาดเท่าไร latency เพิ่มตอนโหลดไหม วิธีนี้แปลงกราฟความเร็วเป็นชุดพารามิเตอร์ที่เอาไปใส่ Config ไคลเอนต์ได้

ทดสอบ burst: วัดถัง

  1. ปล่อยช่องสัญญาณพัก 30 วินาทีไม่มีทราฟฟิก ให้ถังเต็ม
  2. เริ่มดาวน์โหลดและบันทึกความเร็วด้วยความละเอียด 100–200 มิลลิวินาทีในห้าวินาทีแรก
  3. หาจุดที่ความเร็วตกลงสู่ค่าคงตัวจากวิธีที่ 1
  4. ประเมินขนาดถังเป็นไบต์รวมที่ส่งไปจนถึงจุดนั้น ลบด้วยwhat would pass at steady rate ในเวลาเท่ากัน

ตัวอย่าง: 1.5 วินาทีแรกไปที่ 40 เมกะบิต แล้ว 10 คงตัว ถังประมาณ 40 ลบ 10 คูณ 1.5 วินาที หาร 8 — ประมาณ 5.6 เมกะไบต์ หมายความว่ารีเควสไม่เกิน 5 เมกะไบต์ที่เว้นช่วง จะผ่านด้วยความเร็ว "เร็ว" เป็นเครื่องมือวางแผนที่ยอดเยี่ยมถ้าภาระของคุณเป็นคำตอบขนาดกลาง

ถ้าไม่มี burst และความเร็วขึ้นที่ราบทันทีด้วยการเร่งที่นุ่มนวล แสดงว่าถังเล็กหรือไม่มี และตัวจำกัดน่าจะเป็น shaper ที่ rate แข็ง

ทดสอบ latency ตอนโหลด

นี่คือการทดสอบหลักที่แยก shaper กับ policer ขนานกับการดาวน์โหลดยาว ให้เริ่มชุดรีเควสเบาผ่านพอร์ตพร็อกซีเดียวกัน: เช่น HEAD ไปเซิร์ฟเวอร์ทุก 500 มิลลิวินาที บันทึกเวลาตอบก่อนโหลด ระหว่าง และหลัง

  • Latency เพิ่มหลายเท่า ถึงหลายร้อยมิลลิวินาทีหรือวินาที ความเร็วคงที่ — shaper ที่มีคิวลึก บันทึกความลึก: latency ที่เพิ่มขึ้นคูณ rate ให้ขนาดบัฟเฟอร์โดยประมาณเป็นไบต์
  • Latency แทบไม่เปลี่ยน แต่สถิติการเชื่อมต่อมี retransmission และความเร็วฟันเลื่อย — policer
  • Latency เพิ่มปานกลาง 50–150 มิลลิวินาที ความเร็วคงที่ — shaper ที่มีการจัดการคิว เหมาะสมที่สุด

สถิติ retransmission บน Linux ดูได้ด้วยคำสั่ง ss -ti ตามการเชื่อมต่อที่ต้องการ: มีตัวนับ retrans และ RTT ปัจจุบัน นี่คือวิธีฟรีและแม่นยำในการดูว่าแพ็กเก็ตหายไหม

ทดสอบการรวม: ต่อการเชื่อมต่อหรือต่อเซสชัน

คุณได้เส้นโค้งจากวิธีที่ 1 แล้ว ทำให้ชัดขึ้น: เริ่มการเชื่อมต่อหนึ่งเส้นเต็มที่ และเส้นที่สองจำกัดฝั่งไคลเอนต์ที่ 10 เปอร์เซ็นต์ของเพดาน ถ้าเส้นแรกแทบไม่ช้าลง — ลิมิตแยกต่อการเชื่อมต่อ ถ้าเส้นแรกเสียเท่ากับที่เส้นที่สองใช้ไป — ลิมิตรวม การทดสอบนี้ถูกกว่าชุด 16 สตรีม และให้คำตอบชัดเจน

แยกตัวจำกัดออกจากช่องสัญญาณวิทยุ

จะรู้ได้อย่างไรว่าที่ราบคือการตั้งค่า ไม่ใช่ฟิสิกส์เซลล์? สามสัญญาณของการตั้งค่า: ที่ราบคงที่ในระดับไม่กี่เปอร์เซ็นต์ต่างเวลากัน ตัวเลข "กลม" (5, 10, 20, 50 เมกะบิต) และรูปการขึ้นที่ราบเหมือนกันทุกครั้งที่ทำซ้ำ ช่องสัญญาณวิทยุให้ค่า "ไม่กลม" และแกว่ง ขึ้นกับเวลา เพิ่มเติมสามารถวัดพอร์ตที่สองของโหนดเดียวกันในขณะเดียวกัน: ถ้าสองพอร์ตรวมกันได้มากกว่าหนึ่ง ลิมิตอยู่ที่พอร์ต ไม่ใช่โมเด็ม

กรอบการจำแนก

รวบรวมผลลัพธ์เป็นการ์ดช่องสัญญาณ:

  • เพดานสตรีมเดียว: มัธยฐาน สัมประสิทธิ์ความแปรผัน
  • เพดานภาพรวม: ค่าและจำนวนสตรีมที่ถึง
  • ระดับลิมิต: การเชื่อมต่อ เซสชัน โหนด
  • ชนิด: shaper หรือ policer
  • ถัง: ขนาดเป็นเมกะไบต์ หรือ "ไม่มี"
  • ความลึกคิว: latency ที่เพิ่มตอนโหลด
  • โปรไฟล์รายวัน: เพดานสี่ช่วง

การ์ดแบบนี้คือ input ตรงเข้าสู่ Config ไคลเอนต์ ถ้าไม่มีคุณจะปรับพารามิเตอร์แบบเดา

วิธีที่ 3: เขียนไคลเอนต์ที่สอดคล้องกับตัวจำกัด

ปรัชญา: ไม่สู้ แต่เจรจา

ข้อมูลเชิงลึกหลักที่ได้หลังปรับระบบมาสิบระบบ: ตัวจำกัดไม่สามารถ "เจาะ" ด้วยจำนวนสตรีมมาก ๆ ได้ ทำได้แค่เติมคิวและได้ bufferbloat หรือยั่ว policer ให้ทิ้งแพ็กเก็ตเป็นชุด ไคลเอนต์ที่มีประสิทธิภาพจะรักษาความเร็วต่ำกว่าเพดานเล็กน้อย เพื่อให้คิวของตัวจำกัดเกือบว่าง และ latency ต่ำ ปฏิทรรศการที่ทำให้นักพัฒนาใหม่ประหลาดใจ: ลดความเร็วลง 10 เปอร์เซ็นต์ กลับเพิ่ม goodput เพราะ timeout และการส่งซ้ำหายไป

องค์ประกอบ 1: token bucket ฝั่งไคลเอนต์

สร้างถังเหมือนของตัวจำกัด แต่ rate ที่ 85–90 เปอร์เซ็นต์ของเพดานคงตัวที่วัดได้ และขนาดถังไม่เกินครึ่งของถังพร็อกซีที่วัดได้ ตัวจำกัดใช้กับการอ่าน body คำตอบ: ก่อนอ่านชังค์ถัดไป ขอโทเคนจากถังเท่าจำนวนไบต์ที่จะอ่าน และรอถ้าไม่มี ลอจิกทีละขั้น:

  1. เก็บสองตัวเลข: โทเคนปัจจุบันและเวลาที่เติมล่าสุด
  2. เมื่อขอ N โทเคน เติมก่อน: tokens = min(burst, tokens + (now - last) * rate)
  3. ถ้าโทเคนพอ หักและไปต่อ ถ้าไม่พอ คำนวณเวลารอ (N - tokens) / rate แล้วนอนแบบอะซิงค์
  4. ถังหนึ่งต่อพอร์ตพร็อกซี ใช้ร่วมทุกการเชื่อมต่อผ่านพอร์ตนั้น ถ้าลิมิตต่อเซสชัน ถ้าลิมิตต่อการเชื่อมต่อ — ถังต่อการเชื่อมต่อบวกถังรวมต่อโหนด

ทำไมต้องจำกัดการอ่าน ไม่ใช่จำนวนรีเควส? เพราะการอ่านกำหนดว่าข้อมูลถูกดึงออกจากคิวตัวจำกัดเร็วแค่ไหน ถ้าคุณอ่านช้ากว่าที่พร็อกซีส่ง TCP จะบอกผู้ส่งให้ลดหน้าต่างเอง และข้อมูลจะไม่สะสมในบัฟเฟอร์กลาง นี่คือ backpressure ในความหมายบริสุทธิ์

องค์ประกอบ 2: สемафорการขนาน

จำกัดจำนวนการเชื่อมต่อพร้อมกันต่อพอร์ตด้วยสемафор ค่าเริ่มต้นจากเส้นโค้งการรวมวิธีที่ 1: จำนวนสตรีมที่การเพิ่มหยุด ลบหนึ่ง สำหรับช่องสัญญาณมือถือทั่วไปคือ 4–8 มากกว่านั้นมีแต่ latency เพิ่ม

องค์ประกอบ 3: อ่านแบบสตรีมและ timeout ความคืบหน้า

อย่าตั้ง timeout เดียวทั้งรีเควส ไฟล์ 50 เมกะไบต์ที่เพดาน 5 เมกะบิตจะดาวน์โหลด 80 วินาทีอย่างซื่อสัตย์ และ timeout 30 วินาทีจะฆ่ามันกลางทาง เสียแบนด์วิดท์ครึ่งทางเปล่า ๆ วิธีที่ถูก: timeout การเชื่อมต่อ (5–10 วินาที) timeout ไบต์แรก (10–20 วินาทีเผื่อ bufferbloat) และ timeout ความคืบหน้า — ระยะสูงสุดระหว่างสองชังค์ที่อ่านสำเร็จ ปกติ 15–30 วินาที อ่าน body เป็นชังค์ละ 32–64 กิโลไบต์ หลังทุกชังค์อัปเดตเวลาความคืบหน้า

องค์ประกอบ 4: การขนานแบบปรับตัวด้วย AIMD

เพดานช่องสัญญาณมือถือลอยไปมา และสемафорคงที่ไม่ติดตาม ทางออกคือจัดการการขนานแบบไดนามิกตามหลักการเพิ่มแบบบวกและลดแบบคูณ เหมือนที่ TCP ทำ:

  1. ทุก 10 วินาที คำนวณ goodput ในหน้าต่างและ latency มัธยฐานของไบต์แรก
  2. ถ้า latency ต่ำกว่าฐานหนึ่งเท่าครึ่งและไม่มี error — เพิ่มลิมิตรวมขึ้นหนึ่ง ถึงขอบบน
  3. ถ้า latency เพิ่มเกินสองเท่าของฐาน หรือมี timeout ความคืบหน้า — ลดลิมิตครึ่งหนึ่ง ไม่ต่ำกว่าหนึ่ง
  4. วัด latency ฐานตอนเริ่มที่การเชื่อมต่อเดียว และคำนวณใหม่ทุกชั่วโมง

คอนโทรลเลอร์แบบนี้หาจุดสบายในไม่กี่นาทีและทรงตัวแถวนั้นโดยอัตโนมัติ บีบตอนเย็น ขยายตอนกลางคืน เราเห็นมันเพิ่ม goodput รายวัน 20–35 เปอร์เซ็นต์โดยไม่เปลี่ยนเพดานเลย

องค์ประกอบ 5: ส่งซ้ำด้วย exponential backoff และ jitter

Timeout คือสัญญาณความแออัด ไม่ใช่คำเชิญให้ส่งซ้ำทันที ส่งซ้ำทันทีทำให้คิวยิ่งแย่ กฎ: ส่งซ้ำครั้งแรกใน 1–2 วินาที ครั้งต่อไปเพิ่มเป็นสองเท่า สูงสุด 5 ครั้ง เพิ่ม jitter สุ่มไม่เกิน 50 เปอร์เซ็นต์ทุกครั้ง เพื่อไม่ให้สิบสตรีมตื่นพร้อมกัน ตอน timeout ความคืบหน้าบนไฟล์ใหญ่ ควรทำต่อจากจุดที่ขาดด้วยรีเควส Range ถ้าเซิร์ฟเวอร์รองรับ: แบนด์วิดท์ที่ใช้ครึ่งแรกไม่หายเปล่า

องค์ประกอบ 6: คิวตามลำดับความสำคัญ

แบ่งงานเป็นคลาส: โต้ตอบ (API เบา ที่ latency สำคัญ) และพื้นหลัง (ดาวน์โหลดหนัก) งานพื้นหลังได้ส่วนแบ่งถัง เช่น 70 เปอร์เซ็นต์ งานโต้ตอบมีสำรองรับประกัน ถ้าลิมิตต่อการเชื่อมต่อ ไม่ใช่เซสชัน แยกคลาสไปคนละการเชื่อมต่อ ถ้าเป็นไปได้ไปคนละพอร์ตพร็อกซี ไฟล์หนักหนึ่งอันจะไม่บล็อกรีเควสเล็กเป็นร้อย

องค์ประกอบ 7: นับไบต์ ไม่ใช่จำนวนรีเควส

นับทุกไบต์ที่อ่าน ต่อพอร์ต ต่อคลาส ต่อโดเมนเป้าหมาย ส่งออกเป็นเมตริก ตัวเลขเหล่านี้จะบอกว่าแบนด์วิดท์หายไปไหน และให้วางแผนงบประมาณได้ ซึ่งเป็นหัวข้อถัดไป

โครงร่างขนาดเล็กใน Python

โครงสร้างการทำงานบน asyncio และไคลเอนต์ HTTP อะซิงค์ใด ๆ หน้าตาแบบนี้:

  1. คลาส TokenBucket มีเมธอด async def take(n) ตามองค์ประกอบ 1
  2. คลาส Channel: ที่อยู่พร็อกซี ถัง สемафор ตัวนับ คอนโทรลเลอร์ AIMD
  3. ฟังก์ชัน async def fetch(channel, url): ใต้สемафор เปิดรีเควสผ่านพร็อกซี รอเฮดเดอร์ด้วย timeout ไบต์แรก จากนั้นวนอ่าน chunk = await resp.content.read(65536) ก่อนหน้านั้นเรียก await channel.bucket.take(len(chunk)) อัปเดตความคืบหน้าและตัวนับไบต์
  4. งานพื้นหลัง async def tune(channel): ทุก 10 วินาทีอ่านเมตริกและปรับขนาดสемафор
  5. ตัวห่อการส่งซ้ำด้วย exponential backoff และรองรับ Range

รายละเอียดสำคัญสำหรับ Python: ไคลเอนต์มาตรฐานบัฟเฟอร์ทั้ง body คำตอบในหน่วยความจำโดยปริยาย ตรวจสอบว่าคุณใช้โหมดสตรีม ไม่งั้นจะไม่มี backpressure และตัวจำกัดตอนอ่านจะไร้ประโยชน์ ใน Go อะนาล็อกสร้างบน io.Reader กับตัวห่อลิมิตและ golang.org/x/time/rate ใน Node.js — บนการหยุดชั่วคราวและกลับมาทำงานของสตรีมคำตอบ

เช็กลิสต์ไคลเอนต์

  • ถังฝั่งไคลเอนต์ rate 85–90 เปอร์เซ็นต์ของเพดาน
  • อ่านแบบสตรีมเป็นชังค์ ลิมิตที่การอ่าน
  • สาม timeout แยก: การเชื่อมต่อ ไบต์แรก ความคืบหน้า
  • สемафорปรับตัวตาม latency
  • ส่งซ้ำด้วย exponential backoff, jitter และ Range
  • แยกงานโต้ตอบกับพื้นหลัง
  • ขนานบน TCP หลายเส้น ไม่ใช่ multiplex ในอุโมงค์เดียว
  • นับไบต์ต่อพอร์ต คลาส และโดเมน

วิธีที่ 4: งบประมาณทราฟฟิกและสถาปัตยกรรมภาระ

คิดเป็นไบต์

ระบบส่วนใหญ่วางแผนภาระเป็นรีเควสต่อวินาที แต่ตัวจำกัดแบนด์วิดท์นับไบต์ รีเควส API 4 กิโลไบต์ กับดาวน์โหลดหน้า 3 เมกะไบต์ ต่างกัน 750 เท่า ขั้นแรกคือแปลงแผนเป็นไบต์: กี่คำตอบ ขนาดไหน ต่อชั่วโมง และโปรไฟล์เพดานรายวันจากการ์ดช่องสัญญาณพอมั้ย

สูตรง่าย: ความจุรายวันเป็นไบต์เท่ากับผลรวมสี่ช่วงของเพดานคูณระยะเวลา คูณ 0.8 สำหรับ overhead และสำรอง สำหรับช่องสัญญาณที่เพดานกลางคืน 20 เมกะบิตและเย็น 8 ความจุรายวันประมาณ 120–130 กิกะไบต์ ถ้าแผนคุณต้อง 300 ไม่มีออปติไมซ์โค้ดใดช่วยได้ ต้องเพิ่มช่องสัญญาณ

ลดปริมาณต่อรีเควส

  • บีบอัด: ส่งเฮดเดอร์ Accept-Encoding ด้วย gzip และ br เสมอ คำตอบข้อความย่อ 4–8 เท่า ถ้าไคลเอนต์ไม่ขยายคำตอบอัตโนมัติ เปิดมัน
  • ตัดทรัพยากรเกิน: เมื่อทำบราวเซอร์ออโตเมชัน บล็อกการโหลดรูป ฟอนต์ และมีเดีย ถ้าไม่จำเป็นต่องาน ประหยัด 60–80 เปอร์เซ็นต์ของทราฟฟิกหน้า
  • รีเควสมีเงื่อนไข: เก็บ ETag และ Last-Modified ส่ง If-None-Match คำตอบ 304 หนักไม่กี่ร้อยไบต์แทนเมกะไบต์
  • HEAD ก่อน GET: ถ้าต้องเช็คว่ามีหรือขนาดเท่าไร อย่าดาวน์โหลด
  • รีเควส Range: เมื่อต้องการแค่ส่วนหนึ่งของไฟล์ เช่นเมตาดาต้าตอนต้น ขอช่วง
  • ฟิลด์ API: หลาย API รองรับเลือกฟิลด์คำตอบ ขอเท่าที่ต้อง

กระจายข้ามช่องสัญญาณ

ถ้ามีหลายช่องสัญญาณ อย่าแบ่งงานเท่ากัน แบ่งตามสัดส่วนเพดานปัจจุบันที่วัดสดผ่าน goodput ของแต่ละช่อง ตัวจัดตารางถือคิวงานและส่งอันถัดไปให้ช่องที่ถังว่างกว่าและ latency ต่ำกว่า ช่องที่เสื่อมจะได้งานน้อยลงอัตโนมัติ ไม่ต้องแทรกแซงด้วยมือ

วางแผนตามเวลา

งานพื้นหลังปริมาณมากเลื่อนไปช่วงกลางคืนที่เพดานสูง งานโต้ตอบและเร่งด่วนกระจายสม่ำเสมอแต่มีสำรองแบนด์วิดท์ ฟังดูธรรมดา แต่ในทางปฏิบัติ мало кто สร้างตัวจัดตารางที่คำนึงถึงโปรไฟล์รายวันของช่องสัญญาณ ความต่างของ goodput รายวันจากการจัดตารางแบบนี้สูงถึง 40 เปอร์เซ็นต์บนชุดช่องสัญญาณเดียวกัน

ฟิวส์นิรภัย

ใส่ฟิวส์ในไคลเอนต์: ถ้า goodput ของช่องในสองนาทีที่ผ่านมาลดต่ำกว่า 20 เปอร์เซ็นต์ของมัธยฐานการ์ด และ latency เพิ่มเกินสี่เท่า ให้ตัดช่องออกจากรอบ 5 นาที ป้องกันสถานการณ์ที่เซลล์โหลดหนักหรือโหนดมีปัญหา ลากทั้งระบบเข้าสู่การส่งซ้ำไม่รู้จบ

เช็กลิสต์งบประมาณ

  • แผนแปลงเป็นไบต์ตามคลาสงาน
  • ความจุรายวันของช่องคำนวณตามโปรไฟล์ เผื่อ 20 เปอร์เซ็นต์
  • ใช้การบีบอัด บล็อกทรัพยากรเกิน รีเควสมีเงื่อนไข Range
  • ตัวจัดตารางกระจายตาม goodput ปัจจุบัน ไม่แบ่งเท่า
  • งานปริมาณมากเลื่อนไปช่วงเพดานสูง
  • ตั้งฟิวส์ตาม goodput และ latency

ข้อผิดพลาดยอดฮิต: สิ่งที่ห้ามทำเด็ดขาด

เพิ่มสตรีมจนกว่าจะเร็วขึ้น

ข้อผิดพลาดที่พบบ่อยที่สุด เมื่อลิมิตรวมต่อเซสชัน สตรีมเพิ่มแค่ทำให้คิว shaper ยาวขึ้น ความเร็วไม่เพิ่ม latency เพิ่ม timeout พรุ่ง กับ policer — loss เพิ่ม และภาพรวมอาจตก การเพิ่มการขนานสมเหตุสมผลเฉพาะถึงจุดที่เส้นโค้งการรวมขึ้นที่ราบ

timeout เดียวทั้งรีเควส

ฆ่าดาวน์โหลดใหญ่ที่กำลังไปได้กลางทางและเสียแบนด์วิดท์เปล่า ใช้ timeout ความคืบหน้า

ส่งซ้ำทันที

ตอนแออัด ส่งซ้ำโดยไม่หยุดเพิ่มภาระคิวเป็นสองเท่า สิบสตรีมที่ส่งซ้ำพร้อมกันสร้างพายุเล็ก ๆ ต้องมี exponential backoff และ jitter

วัดเพดานครั้งเดียว

ตัวเลขเดียวตอนบ่ายสองวันอังคารไม่บอกพฤติกรรมช่องตอนสองทุ่มวันศุกร์ ถ้าไม่มีโปรไฟล์รายวัน คุณจะโหลดช่องไม่เต็ม หรือสร้างระบบบนแบนด์วิดท์ที่ไม่มีจริง

วัดกับแหล่งที่ช้า

เซิร์ฟเวอร์สาธารณะที่ uplink โหลดหนักจะแสดงเพดานของมัน ไม่ใช่เพดานพร็อกซี ตรวจแหล่งโดยตรง

บัฟเฟอร์คำตอบทั้งก้อน

ไม่มีการอ่านแบบสตรีม ไม่มี backpressure ไคลเอนต์ "กลืน" ทุกอย่างที่พร็อกซีให้ และลิมิตฝั่งไคลเอนต์ไม่ทำงาน บวกกับหน่วยความจำสำหรับคำตอบใหญ่

Multiplex ทุกอย่างในอุโมงค์เดียว

HTTP/2 ใน CONNECT เดียวเมื่อลิมิตต่อการเชื่อมต่อ แชร์แบนด์วิดท์ระหว่างทุกรีเควสและเกิด head-of-line blocking หลาย TCP เกือบทุกครั้งมีประสิทธิภาพกว่าผ่านพร็อกซี

มองข้ามการบีบอัด

Accept-Encoding ที่ปิดอยู่หมายความว่าคุณจ่ายแบนด์วิดท์ให้ข้อความไม่บีบอัด ต่างกันห้าเท่าแบบเปล่า ๆ

สับสนแบนด์วิดท์กับ latency

ช่อง 50 เมกะบิตที่ RTT 400 มิลลิวินาที สำหรับ API เล็กเป็นร้อย ช้ากว่าช่อง 10 เมกะบิตที่ RTT 60 มิลลิวินาที ประเมินทั้งสองค่าตามโปรไฟล์ทราฟฟิก

นับรีเควส ไม่ใช่ไบต์

วางแผนเป็นรีเควสต่อวินาทีไม่คำนึงขนาดคำตอบ และชนเพดานอย่างไม่คาดคิด

เครื่องมือและแหล่งข้อมูล

สำหรับการวัด

  • curl — เครื่องมืออเนกประสงค์สำหรับวัดเร็วผ่านพร็อกซี คีย์แสดงตัวแปรเวลาให้ความเร็วเฉลี่ย เวลาถึงไบต์แรก เวลาการเชื่อมต่อ สำหรับบันทึกรายวินาทีเขียน Python สิบบรรทัดง่ายกว่า
  • iperf3 — วัดแบนด์วิดท์บริสุทธิ์ระหว่างเครื่องคุณกับเซิร์ฟเวอร์โดยตรง เพื่อขจัดคอขวดของตัวเอง ผ่าน HTTP proxy มันไม่ทำงาน แต่เป็นตัวควบคุมแหล่งที่ดีเยี่ยม
  • ss -ti — สถิติการเชื่อมต่อ TCP บน Linux: RTT หน้าต่างแออัด retransmission อัลกอริทึมควบคุมแออัด ตัวตรวจจับ policer ฟรีที่สำคัญที่สุด
  • tcpdump และ Wireshark — เมื่อต้องเห็นระดับแพ็กเก็ต: รูปแบบ loss ความล่าช้าของ ACK พฤติกรรมหน้าต่าง
  • mtr — traceroute พร้อม loss ต่อโหนด ช่วยเข้าใจว่า loss เกิดตรงไหนบนเส้นทางถึงพร็อกซี

สำหรับจำลองในเครื่อง

ก่อนทดสอบโค้ดบนพร็อกซีจริง สร้างแท่นทดสอบ บน Linux ยูทิลิตี้ tc กับดิสซิพลิน tbf (token bucket filter) และ netem จำลอง shaper ด้วย rate และ burst ที่ตั้งได้ policer latency และ loss คุณสามารถสร้างการ์ดช่องสัญญาณจำลองในเครื่องและรันไคลเอนต์กับมันได้ไม่จำกัด ไม่เปลืองทราฟฟิกและไม่ขึ้นกับเวลาของวัน นักพัฒนาที่ตั้งแท่นแบบนี้ดีบักไคลเอนต์เร็วขึ้นหลายเท่า

สำหรับโค้ด

  • Python: asyncio, aiohttp หรือ httpx โหมดสตรีม token bucket เอง 20 บรรทัด มีไลบรารีลิมิตสำเร็จรูป แต่ส่วนใหญ่จำกัดรีเควส ไม่ใช่ไบต์ ดังนั้นเขียนเองเชื่อถือกว่า
  • Go: แพ็กเกจ rate จาก standard library ส่วนขยาย ตัวห่อ io.Reader สำหรับลิมิตการอ่าน context พร้อม deadline สำหรับ timeout
  • Node.js: สตรีมคำตอบพร้อมจัดการหยุดและกลับมือ ไลบรารีสำหรับสемафорและการส่งซ้ำ

สำหรับ observability

ส่งออกเมตริก goodput, latency ไบต์แรก, จำนวนการเชื่อมต่อที่ใช้งาน, timeout และการส่งซ้ำต่อพอร์ตพร็อกซีไปยังระบบเก็บเมตริกและสร้างแดชบอร์ด ลายเซ็นตัวจำกัดเห็นบนกราฟในหนึ่งนาที และความผิดปกติช่องสัญญาณเห็นได้ก่อนมันทำภารกิจล้ม ถ้าไม่มี observability คอนโทรลเลอร์ปรับตัวก็ทั้งตั้งและตรวจไม่ได้

อ่านเพิ่ม

สเปก RFC เรื่องการควบคุมแออัด TCP และอัลกอริทึมจัดการคิวแบบ active ให้ความเข้าใจเชิงลึกว่าทำไม shaper ถึงทำตัวแบบนั้น เอกสาร Linux เรื่องดิสซิพลินคิว tc เป็นคู่มือปฏิบัติสำหรับจำลอง บทความเรื่อง bufferbloat อธิบายว่าทำไมบัฟเฟอร์ลึกเป็นโทษและจัดการอย่างไรในระดับอุปกรณ์เครือข่าย

เคสและผลลัพธ์

เคส 1: พาร์เซอร์แคตตาล็อกมาร์เก็ตเพลสที่ "ตาย" ตอนเย็น

งาน: สำรวจแคตตาล็อกรายวัน ประมาณ 400,000 หน้าผ่านช่องสัญญาณมือถือแปดช่อง อาการ: กลางคืนระบบเสร็จในห้าชั่วโมง ตอนเย็น timeout ทุก ๆ สามรีเควส แผนรายวันไม่สำเร็จ

การวัดตามวิธีที่ 1 พบ: เพดานกลางคืนประมาณ 18 เมกะบิต เย็น — 6–7 วิธีที่ 2: shaper ที่มีคิวลึก latency ตอนโหลดเพิ่มจาก 90 เป็น 1400 มิลลิวินาที ลิมิตรวมต่อเซสชัน ไคลเอนต์ใช้ 32 สตรีมต่อช่องและ timeout เดียว 20 วินาที

สิ่งที่ทำ: ใส่ถังฝั่งไคลเอนต์ที่ 85 เปอร์เซ็นต์ของเพดานปัจจุบัน ลดการขนานเริ่มต้นเป็น 6 พร้อมคอนโทรลเลอร์ปรับตัว เปลี่ยน timeout เป็นสามระดับ เปิดการบีบอัดและบล็อกรูป (หน้าเบา 180 กิโลไบต์จาก 1.4 เมกะไบต์) ผลลัพธ์: เปอร์เซ็นต์ timeout ตอนเย็นลดจาก 33 เป็น 0.4 goodput รายวันเพิ่ม 41 เปอร์เซ็นต์บนชุดช่องสัญญาณเดิม การสำรวจเสร็จใน 7 ชั่วโมงทุกเวลา ที่ชัดที่สุด: ลดการขนานจาก 32 เป็น 6 กลับเพิ่มความเร็วที่มีประโยชน์ ไม่ลด

เคส 2: ดาวน์โหลดมีเดียกับ policer

งาน: ดาวน์โหลดวิดีโอ 40–200 เมกะไบต์จากโฮสติ้งสาธารณะผ่านพร็อกซี ประมาณ 2 เทระไบต์ต่อเดือน อาการ: ความเร็วขาด ๆ หาย ๆ เฉลี่ยต่ำกว่าที่ระบุสองเท่า ขาดกลางไฟล์บ่อย

การวัดแสดงฟันเลื่อยคลาสสิก: ดิ่ง 40–50 เปอร์เซ็นต์ทุกไม่กี่วินาที RTT คงที่ ตัวนับ retransmission เพิ่มเป็นสิบ ๆ ต่อวินาที Policer ลิมิตต่อการเชื่อมต่อประมาณ 12 เมกะบิต ภาพรวมถึง 4 สตรีมเพิ่มเกือบเชิงเส้น

สิ่งที่ทำ: แบ่งแต่ละไฟล์เป็นสี่ส่วนด้วย Range และดาวน์โหลดขนานสี่การเชื่อมต่อ แต่ละอันมีถังฝั่งไคลเอนต์ 10 เมกะบิต ต่ำกว่าลิมิต policer เล็กน้อยเพื่อไม่ยั่ว loss เพิ่มการดาวน์โหลดต่อด้วย Range ตอน timeout ความคืบหน้า ผลลัพธ์: ความเร็วเฉลี่ยต่อไฟล์เพิ่มจาก 5.5 เป็น 36 เมกะบิต การขาดไม่ทำให้เสียที่ดาวน์โหลดแล้ว ปริมาณรายเดือนผ่านใน 12 วันจาก 30 Policer หลอกไม่ได้ แต่ไม่ต้องให้เหตุ让它ทิ้งแพ็กเก็ต

เคส 3: ภาระผสม API กับดาวน์โหลด

งาน: ทำงานกับ API ของแพลตฟอร์มโซเชียล (รีเควสเล็กหลายพัน) พร้อมดาวน์โหลดมีเดียพื้นหลังผ่านช่องทางเดียวกัน อาการ: API เป็นครั้งคราว latency 3–5 วินาที แพลตฟอร์มเริ่มคิดว่าไคลเอนต์ช้า

การวินิจฉัย: shaper ต่อเซสชัน ดาวน์โหลดพื้นหลังเติมคิว รีเควสเล็กรออยู่ข้างหลัง bufferbloat คลาสสิกในเซสชันเดียว

สิ่งที่ทำ: แยกคลาสไปคนละพอร์ตพร็อกซีของโหนดเดียวกัน บนพอร์ตดาวน์โหลดพื้นหลังถัง 70 เปอร์เซ็นต์ของเพดาน บนพอร์ต API ขนานไม่เกิน 3 และลำดับความสำคัญตาม latency ผลลัพธ์: เปอร์เซ็นไทล์ 90 ของ latency API ลดจาก 3.8 วินาทีเป็น 210 มิลลิวินาที ดาวน์โหลดพื้นหลังช้าลง 12 เปอร์เซ็นต์ ซึ่งยอมรับได้ ประสิทธิภาพรวมของระบบ วัดจากปฏิบัติการสำเร็จต่อชั่วโมง เพิ่ม 27 เปอร์เซ็นต์

FAQ: คำถามยากเรื่องแบนด์วิดท์และ shaping

ทำไมสตรีมเดียวได้ 8 เมกะบิต สิบสตรีมก็ยัง 8 แต่ทุกอย่างช้าลง?

ลิมิตอยู่ที่เซสชัน ไม่ใช่การเชื่อมต่อ สิบสตรีมแชร์ rate เดียวและเติมคิว shaper แบนด์วิดท์ไม่เพิ่ม แต่ latency เพิ่มตามความลึกคิว เหมาะที่สุดคือถือ 2–4 สตรีมและจำกัดการอ่านฝั่งไคลเอนต์

จะรู้ได้อย่างไรว่าชนช่องสัญญาณวิทยุ ไม่ใช่การตั้งค่าพร็อกซี?

การตั้งค่าให้ที่ราบคงที่ด้วยตัวเลข "กลม" ต่างเวลากัน และรูปการขึ้นเหมือนกัน ช่องสัญญาณวิทยุให้ค่าไม่กลมและแกว่ง สัมประสิทธิ์ความแปรผันสูง โดยเฉพาะตอนเย็น เพิ่มเติมเปรียบเทียบสองพอร์ตของโหนดเดียวกันพร้อมกัน: ถ้ารวมสูงกว่าหนึ่ง ลิมิตอยู่ที่พอร์ต ไม่ใช่โมเด็ม

ควรติด BBR บนเซิร์ฟเวอร์ตัวเองถ้าทำงานผ่านพร็อกซีไหม?

BBR มีผลกับสตรีมขาออกจากเซิร์ฟเวอร์คุณ ถ้าคุณส่งข้อมูลผ่านพร็อกซี มันช่วยให้คิว shaper ว่างและลด latency ไม่มีผลกับสตรีมขาเข้าจากไซต์เป้าหมายถึงคุณ: ฝั่งนั้นผู้ส่งควบคุม สำหรับฝั่งไคลเอนต์ลิมิตตอนอ่านสำคัญกว่า

ถังฝั่งไคลเอนต์ควรต่ำกว่าเพดานเท่าไร?

สำหรับ shaper — 85–90 เปอร์เซ็นต์ของเพดานคงตัว: คิวเกือบว่าง latency ต่ำ สูญเสียแบนด์วิดท์น้อยที่สุด สำหรับ policer — 80–85 เปอร์เซ็นต์ของลิมิตต่อการเชื่อมต่อ เพื่อไม่ยั่วการทิ้ง สำหรับช่องสัญญาณวิทยุไม่เสถียร ควรให้คอนโทรลเลอร์ปรับตัวหาจุด และตั้งถังตามโปรไฟล์ตอนเย็น

ใช้ HTTP/2 ผ่านพร็อกซีเร่งความเร็วได้ไหม?

ผ่านอุโมงค์ CONNECT HTTP/2 ไปไซต์เป้าหมายทำงานได้ แต่ทุกสตรีมแชร์ TCP เดียวและลิมิตเดียวถ้าลิมิตต่อการเชื่อมต่อ บวก head-of-line blocking ตอนอิ่มตัว สำหรับงานหนัก HTTP/1.1 หลายการเชื่อมต่อผ่านพร็อกซีมักให้ goodput ดีกว่าและ latency คาดเดาได้

วัดขนาด burst bucket ให้แม่นขึ้นได้อย่างไร?

ปล่อยช่องพัก 30–60 วินาที บันทึกไบต์ด้วยความละเอียด 100 มิลลิวินาที หาจุดเปลี่ยนเป็นความเร็วคงตัว คำนวณส่วนเกินเหนือเส้นคงตัว ทำซ้ำห้าครั้ง เอามัธยฐาน ความแม่นประมาณ 15 เปอร์เซ็นต์พอสำหรับวางแผน

ทำอย่างไรถ้า timeout เกิดเฉพาะบางโดเมน?

น่าจะคอขวดไม่ใช่พร็อกซี แต่เป็นเส้นทางจากพร็อกซีถึงโดเมนนั้นหรือที่โดเมนเอง วัดเพดานกับแหล่งอ้างอิงในขณะเดียวกัน: ถ้าปกติ ขีดจำกัดอยู่ภายนอก ในโค้ดแยกโดเมนนั้นเป็นคลาสที่มีการขนานน้อยกว่าและ timeout ไบต์แรกยาวกว่า

จะรู้ได้อย่างไรว่าคอนโทรลเลอร์ปรับตัวทำงานถูก?

บนกราฟการขนานควรลดลงอย่างนุ่มนวลตอนเย็นและเพิ่มตอนกลางคืน latency ไบต์แรกควรอยู่ภายในหนึ่งเท่าครึ่งถึงสองเท่าของฐาน สัดส่วน timeout ต่ำกว่าหนึ่งเปอร์เซ็นต์ ถ้าการขนานกระตุกระหว่างต่ำสุดและสูงสุดทุกนาที หน้าต่างประเมินสั้นเกินไปหรือเกณฑ์ตอบสนองไวเกินไป

ต้องคิดการเข้ารหัสตอนคำนวณไบต์ไหม?

TLS เพิ่ม overhead 2–5 เปอร์เซ็นต์สำหรับเฮดเดอร์เรกคอร์ดและการ handshake สำหรับวางแผนงบประมาณ ค่าสัมประสิทธิ์ 0.8 รวม TCP/IP ก็พอ สำหรับการนับแม่น นับไบต์ระดับ socket ไม่ใช่ระดับ body คำตอบ

บทสรุป: จากการเดาสู่แบนด์วิดท์ที่จัดการได้

เราเดินทางจากแนวคิดพื้นฐานถึงสถาปัตยกรรมไคลเอนต์ที่ไม่สู้กับตัวจำกัด แต่สอดคล้องกับมัน สรุปสาระสำคัญ

  • เพดานคือค่าต่ำสุดหลายระดับ และสำหรับช่องสัญญาณมือถือมันลอยตามเวลาของวัน ตัวเลขเดียวไม่มีความหมาย ต้องมีโปรไฟล์
  • Shaper และ policer ต้องใช้โค้ดต่างกัน Shaper ลงโทษด้วย latency policer ลงโทษด้วย loss แยกได้ในสิบนาทีด้วยทดสอบ latency ตอนโหลดและสถิติ retransmission
  • การอิ่มตัวไม่ใช่เรื่องความเร็ว แต่เป็นเรื่องคิว Bufferbloat ทำให้ช่องสัญญาณเร็วกลายเป็นหนืดและฆ่ารีเควสเล็กก่อนที่ความเร็วรายใหญ่จะตก
  • ไคลเอนต์ต้องอ่านแบบสตรีม จำกัดการอ่านต่ำกว่าเพดานเล็กน้อย ใช้สาม timeout แยก จัดการการขนานแบบปรับตัว และส่งซ้ำด้วยความหน่วง
  • วางแผนเป็นไบต์ ไม่ใช่รีเควส การบีบอัด การตัดทรัพยากรเกิน และรีเควสมีเงื่อนไขมักให้มากกว่าการเล่นกลกับสตรีม

ทำอะไรต่อ? วันนี้: ตั้งแหล่งอ้างอิงและเก็บการ์ดช่องสัญญาณตามวิธีที่ 1 และ 2 อย่างน้อยหนึ่งพอร์ต อาทิตย์นี้: สร้างแท่นทดสอบในเครื่องด้วย tc จำลองการ์ด และเขียนไคลเอนต์ใหม่ตามเช็กลิสต์วิธีที่ 3 ภายในเดือน: เปิดการนับไบต์ สร้างแดชบอร์ด ตั้งคอนโทรลเลอร์ปรับตัว และคำนวณงบประมาณทราฟฟิกตามวิธีที่ 4

แบนด์วิดท์หยุดเป็นแหล่งความประหลาดใจทันทีที่คุณเริ่มวัดและให้เกียรติมัน โค้ดที่เขียนด้วยความเข้าใจตัวจำกัดไม่เพียงทำงานเร็วขึ้น แต่มันทำงานคาดเดาได้ และในงานโครงสร้างพื้นฐาน ความคาดเดาได้คือสกุลเงินหลัก