Rate limit ฝั่งไคลเอนต์: token bucket, leaky bucket และลิมิตแยกตามโฮสต์ — คู่มือระดับผู้เชี่ยวชาญ
บทความ
- บทนำ: ทำไมไคลเอนต์ถึงควรมี rate limit ของตัวเอง
- พื้นฐาน: rate limit ฝั่งไคลเอนต์คืออะไร และทำไมเซิร์ฟเวอร์อย่างเดียวมันไม่พอ
- เจาะลึก: ตระกูลของอัลกอริทึมและคณิตศาสตร์เบื้องหลัง
- วิธีที่ 1: token bucket ในทางปฏิบัติ — เขียนโดยไม่มีกับดัก
- วิธีที่ 2: leaky bucket และ gcra — เมื่อต้องการกระแสที่เรียบสม่ำเสมอ
- วิธีที่ 3: ลิมิตแยกตามโฮสต์ — รีจิสทรี ลำดับชั้น และการประกอบ
- วิธีที่ 4: ลิมิตเตอร์กับการหมุน ip — จะนับการเปลี่ยนที่อยู่ในโมเดลอย่างไร
- ข้อผิดพลาดที่พบบ่อยในการออกแบบ rate limit ฝั่งไคลเอนต์
- เครื่องมือและแหล่งข้อมูลสำหรับการใช้งาน
- กรณีศึกษาและสถานการณ์การใช้งาน
- Faq: ตอบคำถามที่ยาก
- บทสรุป: ก้าวต่อไป
บทนำ: ทำไมไคลเอนต์ถึงควรมี rate limit ของตัวเอง
ลองนึกภาพว่าคุณเดินเข้าไปในธนาคารที่มีเคาน์เตอร์ให้บริการแค่ช่องเดียว แต่มีคนต่อแถวอยู่เป็นพันคน คุณจะเบียด จะตะโกน ก็ไม่มีทางทำให้ธนาคารให้บริการเร็วขึ้นได้ สิ่งที่ทำได้มีแค่มาด้วยจังหวะที่สมเหตุสมผล หรือไม่ก็ถูกปฏิเสธ rate limit ฝั่งเซิร์ฟเวอร์ (การจำกัดความถี่ของคำขอ) ก็เหมือนพนักงานเคาน์เตอร์คนนั้น ที่วันหนึ่งจะหยุดให้บริการคุณเสียเฉยๆ ส่วน rate limit ฝั่งไคลเอนต์ คือการตัดสินใจของคุณเองว่าจะไม่ไปยืนที่เคาน์เตอร์บ่อยเกินกว่าที่มันจะรับไหวจริงๆ
บทความนี้ทุ่มเทให้กับอัลกอริทึมทั้งหมด เราตั้งใจจะไม่พูดซ้ำเรื่องวิธีจัดการกับโค้ด 429 และการทำ exponential backoff และจะไม่ถกกันว่าควรเปิดกี่เธรด โฟกัสของเราอยู่ที่อื่น: ทำอย่างไรให้รู้ล่วงหน้า ก่อนจะส่งคำขอ ว่าตอนนี้ส่งได้หรือไม่ และถ้าไม่ได้ ต้องรอกี่มิลลิวินาที คณิตศาสตร์ตรงนี้เองที่แยกไคลเอนต์ที่ "บางทีก็โดนปฏิเสธ" ออกจากไคลเอนต์ที่ทำงานกับ API เดียวกันมาหลายปีโดยไม่สร้างความรำคาญให้เจ้าของ
สิ่งที่จะได้เรียนรู้จากบทความนี้:
- อัลกอริทึมทั้งสี่ตระกูล — fixed window, sliding window, token bucket และ leaky bucket — ทำงานอย่างไร และต่างกันในระดับพฤติกรรม ไม่ใช่แค่ชื่อ;
- ทำไม token bucket และ GCRA (อีกรูปแบบของ leaky bucket) ถึงกลายเป็นมาตรฐานโดยพฤตินัย และจะเขียนมันได้ในคืนเดียวโดยไม่มีข้อผิดพลาดจากการปัดเศษอย่างไร;
- จะสร้างลำดับชั้นของลิมิตได้อย่างไร: งบประมาณระดับโลก, ระดับโฮสต์, ระดับเอ็นด์พอยต์, ระดับคีย์การยืนยันตัวตน และระดับ IP ขาออก;
- จะฝังการหมุน IP เข้าไปในโมเดลของลิมิตเตอร์โดยไม่ทำลายทั้งโควตาฝั่งเซิร์ฟเวอร์และเทเลเมทรีของตัวเองได้อย่างไร;
- ข้อผิดพลาดในการออกแบบแบบไหนที่ดูไม่เป็นอันตราย แต่กลับนำไปสู่การรอไม่รู้จบ, "การระเบิด" ต้นนาที และหน่วยความจำรั่ว
เราจะพูดกันแบบพี่เลี้ยงวิศวกร: มีสูตรแต่ไม่ต้องปวดหัว มีตัวอย่างแต่ไม่มีน้ำเยอะ ถ้าคุณเขียน parser, SDK สำหรับ API ของคนอื่น, อินทิเกรชันกับมาร์เก็ตเพลส หรือตัวรวมข้อมูลที่ยิงไปหลายร้อยโฮสต์ — คู่มือนี้ควรค่าแก่การบุ๊กมาร์กไว้
พื้นฐาน: rate limit ฝั่งไคลเอนต์คืออะไร และทำไมเซิร์ฟเวอร์อย่างเดียวมันไม่พอ
สองมุมมองต่อปัญหาเดียว
rate limit ฝั่งเซิร์ฟเวอร์ปกป้องโครงสร้างพื้นฐานของเจ้าของ API: มันนับคำขอของคุณและตอบปฏิเสธเมื่อโควตาหมด ส่วน rate limit ฝั่งไคลเอนต์ทำงานอีกอย่างหนึ่ง — ไม่ยอมให้ถึงจุดปฏิเสธ ความต่างตรงนี้คือหัวใจ เซิร์ฟเวอร์ตอบสนองย้อนหลัง: คำขอออกไปแล้ว ช่องทางถูกใช้ไปแล้ว ล็อกเปื้อนแล้ว ชื่อเสียงของไคลเอนต์เสียหายไปนิดหน่อยแล้ว ส่วนไคลเอนต์ลงมือล่วงหน้า: มันรู้ (หรือประเมิน) งบประมาณและใช้อย่างระมัดระวัง
ทำไมเราถึงเอาแต่พึ่งการปฏิเสธจากเซิร์ฟเวอร์แล้วลองใหม่ไม่ได้? เพราะทุกความพยายามที่ถูกปฏิเสธคือการเชื่อมต่อที่เสียเปล่า โทเคนการยืนยันตัวตนที่เสียเปล่า หนึ่งบรรทัดในบันทึกความปลอดภัยของคนอื่น และโดยปกติแล้วยังทำให้ตำแหน่งของคุณในระบบป้องกันแบบปรับตัวแย่ลง ไคลเอนต์ที่รู้จักควบคุมจังหวะตัวเองจะดูเหมือนหุ้นส่วนที่สุภาพในสายตาเซิร์ฟเวอร์ ส่วนไคลเอนต์ที่ "ลองไปเรื่อยๆ จนกว่าจะเปิดให้" จะดูเหมือนแหล่งปัญหา เดาสิว่าคนไหนจะถูกจำกัดหนักกว่าเมื่อมีการปรับนโยบายครั้งถัดไป?
ศัพท์พื้นฐาน
- Rate (ความเร็ว) — ความถี่คงที่ของคำขอ เช่น "สิบคำขอต่อวินาที" นี่คือสิ่งที่เซิร์ฟเวอร์ยินดีรับได้ไม่จำกัดเวลา
- Burst (การระเบิด) — จำนวนคำขอที่ส่งได้ทันที ติดกัน โดยไม่รอการเติม เซิร์ฟเวอร์มักยอมรับการระเบิดสั้นๆ ได้ หากความเร็วเฉลี่ยไม่ผิดนโยบาย
- Window (หน้าต่าง) — ช่วงเวลาที่ใช้ในการนับคำขอ: วินาที นาที ชั่วโมง วัน
- Quota (โควตา) — จำนวนคำขอสูงสุดในหน้าต่าง โควตาหารด้วยความยาวหน้าต่างคือความเร็วเฉลี่ย
- Limit key (คีย์ลิมิต) — คุณลักษณะที่เซิร์ฟเวอร์ใช้จัดกลุ่มคำขอ: IP, โทเคน, บัญชี, คู่ของ "โฮสต์บวกเอ็นด์พอยต์" ไคลเอนต์คนเดียวกันมักตกอยู่ภายใต้หลายคีย์พร้อมกันเสมอ
- Cost (ต้นทุน) — น้ำหนักของคำขอ บาง API คิดการค้นหาเป็นสิบหน่วย แต่การอ่านการ์ดสินค้าคิดเป็นหนึ่งหน่วย
หลักการสำคัญ: ลิมิตเตอร์ตัดสินใจ "เมื่อไหร่" ไม่ใช่ "เท่าไหร่"
ความเข้าใจผิดที่พบได้บ่อยคือการสับสนลิมิตเตอร์กับ semaphore ตัว semaphore จำกัดจำนวนการทำงานพร้อมกันและตอบคำถามว่า "ตอนนี้มีงานค้างอยู่ในระบบกี่งาน" ส่วนลิมิตเตอร์จำกัดความถี่และตอบคำถามว่า "ตอนนี้เริ่มงานอีกงานได้ไหม และถ้าไม่ได้ อีกกี่มิลลิวินาทีถึงจะได้" สองกลไกนี้เสริมกัน แต่แทนกันไม่ได้ คุณอาจถือการเชื่อมต่อเดียวและยังเกินลิมิตได้ถ้าคำขอสั้น คุณอาจถือการเชื่อมต่อร้อยอันและยังอยู่ในลิมิตได้ถ้าคำขอช้า
สามคุณสมบัติของลิมิตเตอร์ฝั่งไคลเอนต์ที่ดี
- คาดเดาได้ อินพุตเดิมให้คำตอบเดิม ไม่มี "บางทีก็ปล่อยเกินไปนิดหน่อย"
- ต้นทุนต่ำ ตัดสินใจในเวลาคงที่และใช้หน่วยความจำคงที่ต่อคีย์ ถ้าคุณมีหลายพันโฮสต์ ลิมิตเตอร์เก็บประวัติทุกคำขอไม่ได้
- ยุติธรรม ถ้ามีหลายงานรออยู่ พวกมันได้รับอนุญาตตามลำดับคิว ไม่ใช่ตามลำดับ "ใครตื่นมาพอดี"
จำสามเกณฑ์นี้ไว้ เพราะเราจะใช้มันเปรียบเทียบอัลกอริทึมในหัวข้อถัดไป
เจาะลึก: ตระกูลของอัลกอริทึมและคณิตศาสตร์เบื้องหลัง
Fixed window — ตัวนับที่ซื่อสัตย์แต่มีกับดัก
แบบง่ายที่สุด: แบ่งเวลาเป็นหน้าต่างความยาวคงที่ แต่ละหน้าต่างมีตัวนับหนึ่งตัว เมื่อถึงโควตาก็รอหน้าต่างถัดไปเริ่ม หน่วยความจำแค่ตัวเลขหนึ่งตัวและเวลาหนึ่งค่า ต่อคีย์ ฟังดูสมบูรณ์แบบ
ปัญหาคือ ปรากฏการณ์ขอบหน้าต่าง ถ้าโควตาคือหนึ่งร้อยคำขอต่อนาที ไคลเอนต์อาจส่งหนึ่งร้อยคำขอในวินาทีสุดท้ายของหน้าต่างหนึ่ง และอีกหนึ่งร้อยคำขอในวินาทีแรกของหน้าต่างถัดไป ในมุมของไคลเอนต์มันถูกต้องตามกติกาทุกประการ: แต่ละหน้าต่างมีหนึ่งร้อยพอดี แต่มุมของเซิร์ฟเวอร์มีสองร้อยคำขอมาในสองวินาที — สูงเป็นสองเท่าของการตีความลิมิตที่สมเหตุสมผลใดๆ ถ้าเซิร์ฟเวอร์นับแบบ sliding window (ซึ่งระบบสมัยใหม่ส่วนใหญ่ทำ) คุณจะโดนปฏิเสธทั้งที่เชื่อสนิทใจว่าตัวเองบริสุทธิ์
ปัญหาsecondาคือ การซิงโครไนซ์การระเบิด worker ทุกตัวของคุณ "ตื่น" พร้อมกันตอนต้นนาที เพราะตัวนับถูกรีเซ็ตตอนนั้น มันสร้างยอดแหลมบนเครือข่าย บนพร็อกซี่ และบนเซิร์ฟเวอร์ปลายทาง
Sliding window log — แม่นยำแต่แพง
เก็บเวลาของทุกคำขอในช่วงเวลาที่ผ่านมา ก่อนส่ง ทำทิ้งรายการที่หมดอายุแล้วนับที่เหลือ แม่นยำสมบูรณ์ ไม่มีปรากฏการณ์ขอบหน้าต่าง แต่หน่วยความจำโตเป็นเส้นตรงกับโควตา: ด้วยโควตาหนึ่งหมื่นคำขอต่อชั่วโมง คุณเก็บหนึ่งหมื่นเวลา ต่อคีย์ หนึ่งโฮสต์พอทน หนึ่งพันโฮสต์ไม่ไหว
Sliding window counter — ทางสายกลาง
เก็บตัวนับสองตัว: ของหน้าต่างปัจจุบันและของหน้าต่างก่อนหน้า การประเมินโหลดคือตัวนับปัจจุบันบวกตัวนับก่อนหน้าคูณด้วยเศษของหน้าต่างก่อนที่ยังตกอยู่ในช่วงเวลาแบบเลื่อน ถ้าผ่านไป 20 เปอร์เซ็นต์ของนาทีปัจจุบัน ให้นับ 80 เปอร์เซ็นต์ของตัวนับก่อนหน้า นี่คือการประมาณ แต่ทำให้ขอบหน้าต่างเรียบได้ดีและใช้แค่สองตัวแปร การใช้งานฝั่งเซิร์ฟเวอร์หลายตัวใช้วิธีนี้ ดังนั้นการเลียนแบบมันฝั่งไคลเอนต์จึงเป็นวิธีที่ดีในการ "คิดเหมือนเซิร์ฟเวอร์"
Token bucket — ถังที่มีโทเคน
ลองนึกถึงถังที่มีความจุ B โทเคน ทุกวินาทีมี r โทเคนหยดลงมา ส่วนที่เกินก็ล้นออกไป การจะส่งคำขอที่ต้นทุน c ต้องใช้ c โทเคน ถ้าไม่มีก็ต้องรอให้หยดมาพอ
สองพารามิเตอร์ให้คุณสมบัติที่แยกจากกันสองอย่าง พารามิเตอร์ r คือความเร็วคงที่: ไม่ว่าคุณจะรอนานแค่ไหน ความเร็วระยะยาวก็ไม่เกิน r คำขอต่อวินาที พารามิเตอร์ B คือการระเบิดสูงสุด: หลังหยุดพักสามารถส่งได้ทันที B คำขอ สิ่งนี้ตรงกับนโยบายฝั่งเซิร์ฟเวอร์จริงๆ อย่างลงตัว: "ไม่เกินหนึ่งร้อยต่อนาที ไม่เกินสิบต่อครั้ง"
รายละเอียดสำคัญคือ การเติมแบบขี้เกียจ ไม่ต้องมีเธรดพื้นหลังคอยเติมโทเคนทุกวินาที แค่ทุกครั้งที่มีการเรียก คำนวณว่าผ่านไปนานเท่าไหร่ตั้งแต่การเรียกครั้งก่อน แล้วเพิ่มตามจำนวนนั้น: tokens = min(B, tokens + elapsed * r) สองตัวเลขต่อคีย์ คำนวณในเวลาคงที่ ตรงกับเกณฑ์ต้นทุนต่ำเต็มที่
Leaky bucket — ถังที่มีรูรั่ว
ตรงนี้คำอุปมาจะกลับกัน: คำขอถูกเทลงในถัง ส่วนที่รั่วออกจากรูตรงก้นออกมาด้วยความเร็วคงที่ r ถ้าถังล้น คำขอใหม่จะถูกปฏิเสธหรือต้องรอ เอาต์พุตออกมาสม่ำเสมอเสมอ: ไม่มีการระเบิดเลย แค่คำขอหนึ่งครั้งทุก 1/r วินาที ถ้าเซิร์ฟเวอร์ไม่ยอมรับการระเบิด หรือคุณต้องการโปรไฟล์ทราฟฟิกที่เรียบที่สุด นี่คือตัวเลือกของคุณ
มีสองการตีความ leaky bucket อยู่ การตีความแรก — เป็นคิว: คำขอถูกใส่ลงบัฟเฟอร์จริงๆ และโปรเซสแยกคอยปล่อยออกตามจังหวะ timer การตีความที่สอง — เป็นตัวนับ: เราแค่ตรวจสอบว่าถังสมมติจะล้นหรือไม่ แล้วปล่อยผ่านหรือไม่ผ่าน การตีความที่สองในโลกโทรคมนาคมเรียกว่า GCRA (Generic Cell Rate Algorithm) และทางคณิตศาสตร์เทียบเท่ากับ token bucket ที่กำหนดพารามิเตอร์ต่างกัน สังเกตการณ์นี้สำคัญ: ถ้าคุณเขียน token bucket ได้แล้ว คุณก็ทำ leaky bucket ได้ด้วย
GCRA: เวลาเพียงค่าเดียวแทนตัวนับ
GCRA เก็บแค่ค่าเดียว — TAT (theoretical arrival time คือเวลาการมาถึงตามทฤษฎี): ช่วงเวลาที่คำขอ "ในอุดมคติ" ถัดไปไม่ควรมาจากก่อนหน้านั้น พารามิเตอร์: ช่วงเวลาการปล่อย T = 1/r และค่าความคลาดเคลื่อน τ เท่ากับ (B − 1) * T อัลกอริทึม:
- ดึงเวลาปัจจุบัน now
- ถ้า TAT น้อยกว่า now ให้ถือว่า TAT เท่ากับ now (ถังว่างมานานแล้ว)
- ถ้า TAT − τ มากกว่า now — คำขอมาก่อนเกินไป เวลารอคือน TAT − τ − now
- ไม่งั้นปล่อยคำขอและเลื่อน TAT ไปข้างหน้าเป็น T
ตัวเลขเดียวต่อคีย์ ไม่มีตัวนับแบบจุดลอยตัวที่ค่อยๆ คลาดเคลื่อน ด้วยเหตุนี้ GCRA จึงเป็นอัลกอริทึมยอดนิยมสำหรับลิมิตเตอร์แบบกระจาย: สถานะของมันเก็บในฟิลด์เดียวของคีย์-แวลูและอัปเดตแบบอะตอมมิกได้ง่าย
ตารางเปรียบเทียบแบบคำต่อคำ
- Fixed window: หน่วยความจำต่ำสุด ความแม่นยำต่ำ มีการระเบิดที่ขอบ เหมาะแค่เป็นเกราะป้องกันหยาบๆ
- Sliding log: แม่นยำสมบูรณ์ หน่วยความจำเป็นเส้นตรงตามโควตา เหมาะกับไม่กี่คีย์ที่มีโควตาน้อย
- Sliding counter: หน่วยความจำสองตัวแปร ความแม่นยำประมาณการดี จำลองตรรกะเซิร์ฟเวอร์ได้ดี
- Token bucket: หน่วยความจำสองตัวแปร ควบคุมการระเบิดได้ชัดเจน มาตรฐานของ SDK ฝั่งไคลเอนต์
- Leaky bucket / GCRA: หน่วยความจำหนึ่งตัวแปร เอาต์พุตเรียบสมบูรณ์แบบ มาตรฐานของระบบกระจาย
เรื่องนาฬิกา: ความโมโนโทนิกและการคลาดเคลื่อน
ทุกอัลกอริทึมอาศัย "เวลาปัจจุบัน" ใช้ นาฬิกาโมโนโทนิก (monotonic clock) ไม่ใช่นาฬิกาของระบบ เวลาของระบบอาจกระโดดถอยหลังเมื่อซิงโครไนซ์ แล้วลิมิตเตอร์ของคุณจะคิดว่าผ่านไปเป็นเวลาติดลบ จะรีเซ็ตการเติมหรือไม่ก็ปล่อยการระเบิดมหาศาล นาฬิกาโมโนโทนิกการันตีว่าไม่ถอยหลัง ข้อยกเว้นเดียวคือลิมิตเตอร์แบบกระจายในที่จัดเก็บส่วนกลาง ซึ่งดึงเวลาจากฝั่งที่จัดเก็บ ไม่ใช่จากไคลเอนต์ เพื่อไม่ให้ขึ้นกับความคลาดเคลื่อนของนาฬิการะหว่างเครื่อง
วิธีที่ 1: token bucket ในทางปฏิบัติ — เขียนโดยไม่มีกับดัก
ขั้นที่ 1 เลือกพารามิเตอร์
แปลงนโยบายเซิร์ฟเวอร์เป็นคู่ (r, B) ถ้าเอกสารบอก "หนึ่งร้อยคำขอต่อนาที" ความเร็วฐาน r = 100/60 โทเคนต่อวินาที ความจุ B เป็นการตัดสินใจแยกต่างหาก ทางเลือกที่ปลอดภัยสำหรับ API ที่ไม่คุ้นเคยคือ B เท่ากับห้าถึงสิบเปอร์เซ็นต์ของโควตาหน้าต่าง นั่นคือห้าถึงสิบโทเคนเมื่อโควตาหนึ่งร้อย ช่วยให้จัดการกลุ่มเล็กๆ ได้เร็ว แต่ไม่สร้างยอดแหลมที่เซิร์ฟเวอร์แบบ sliding window จะมองว่าเป็นการละเมิด
ดียิ่งกว่านั้น — คำนวณ เผื่อเหลือ: ใช้ 80–90 เปอร์เซ็นต์ของความเร็วที่ประกาศไว้ ตัวนับฝั่งเซิร์ฟเวอร์ ความหน่วงเครือข่าย และการปัดเศษสองฝั่งย่อมสร้างความคลาดเคลื่อน และการเผื่อเหลือก็กลืนมันไป
ขั้นที่ 2 โครงสร้างสถานะ
ต่อคีย์ เก็บไว้: tokens (จำนวนจริง, จำนวนโทเคนปัจจุบัน), last (เวลาโมโนโทนิกของการคำนวณครั้งล่าสุด), rate, capacity ปกป้องสถานะด้วย mutex หรือในโค้ดอะซิงโครนัสด้วย_task_ผู้ตัดสินเพียงตัวเดียวที่ทุกคำขอที่ขอโทเคนต้องผ่าน
ขั้นที่ 3 อัลกอริทึม acquire(cost)
- จับล็อก
- now = monotonic(); elapsed = now − last; last = now
- tokens = min(capacity, tokens + elapsed * rate)
- ถ้า tokens ≥ cost: tokens −= cost; ปล่อยล็อก; คืนค่า "รอศูนย์"
- ไม่งั้น: wait = (cost − tokens) / rate; หักโทเคนติดลบ: tokens −= cost; ปล่อยล็อก; คืนค่า wait
- ฝ่ายที่เรียกนอน wait วินาทีแล้วส่งคำขอ
สังเกตจุดที่ห้า การหักติดลบคือ การจอง มันรับประกันความยุติธรรม: การเรียกครั้งถัดไปจะเห็นยอดเหลือติดลบและได้เวลารอนานขึ้น คือต่อคิวหลังตัวก่อนหน้า ถ้าไม่มีการจองจะเกิดข้อผิดพลาดคลาสสิก: สิบงานเห็นโทเคนศูนย์พร้อมกัน ทั้งหมดคำนวณเวลารอเท่ากัน ทั้งหมดตื่นพร้อมกันและสร้างการระเบิดที่ลิมิตเตอร์ควรจะป้องกันไว้
ขั้นที่ 4 จำกัดความลึกของการจอง
การจองติดลบอาจพุ่งไปไม่รู้จบ: ถ้างานเข้ามาเร็วกว่าโทเคนที่เติม คิวของผู้รอก็โตขึ้น และเวลารอของคนสุดท้ายพุ่งไปเป็นชั่วโมง กำหนด ความหน่วงสูงสุด (max_delay) ถ้า wait ที่คำนวณได้เกินเกณฑ์ ไม่ต้องจอง ให้คืนข้อผิดพลาด "ลิมิตเตอร์โอเวอร์โหลด" ปล่อยให้ตัวจัดตารางงานตัดสินใจว่าจะทำอะไร: เลื่อนออกไป ลดลำดับความสำคัญ สลับไปโฮสต์อื่น นี่คือจุดที่ลิมิตเตอร์ฝั่งไคลเอนต์เปลี่ยนจากเบรกแบบพาสซีฟเป็นเครื่องมือบริหารภาระ
ขั้นที่ 5 ต้นทุนแบบถ่วงน้ำหนัก
ให้คำขอมี cost ต่างกันได้ เอ็นด์พอยต์ค้นหา การดึงข้อมูลแบบกลุ่ม การเขียน มัก "แพงกว่า" สำหรับเซิร์ฟเวอร์ และหลาย API สะท้อนเรื่องนี้ในนโยบายของมัน ถ้าเอกสารไม่ระบุ ให้กำหนดน้ำหนักจากสิ่งที่คุณสังเกตเองเรื่องเวลาตอบสนอง: คำขอที่เซิร์ฟเวอร์ใช้เวลานานกว่าก็ควรถือว่าแพงกว่า สูตรการรอไม่เปลี่ยน — cost แค่คูณเข้าไป
ขั้นที่ 6 การอุ่นเครื่องและ cold start
ค่า tokens เริ่มต้นเป็นการตัดสินใจแยก ถังเต็มตอนเริ่มหมายถึงการระเบิด B คำขอทันทีที่โปรเซสเริ่มทำงาน ซึ่งอาจไม่พึงประสงค์ถ้าคุณมีหลายสิบโปรเซสที่เริ่มพร้อมกันหลังดีพลอย ปลอดภัยกว่าคือเริ่มจากศูนย์หรือครึ่งหนึ่งของความจุ และถ้ารู้ว่าเซิร์ฟเวอร์นับโควตาตามหน้าต่างที่ไม่ผูกกับการเริ่มต้นของคุณ การเริ่มจากศูนย์ยังซื่อสัตย์กว่าด้วย
เช็กลิสต์ token bucket
- ใช้นาฬิกาโมโนโทนิก
- การเติมขี้เกียจ คำนวณจากผลต่างเวลา ไม่มี timer พื้นหลัง
- จองติดลบเพื่อคิวที่ยุติธรรม
- มี max_delay และปฏิเสธชัดเจนเมื่อล้น
- ความเร็วตั้งเผื่อเมื่อเทียบกับเซิร์ฟเวอร์
- ความจุจำกัดเป็นสัดส่วนที่สมเหตุสมผลของโควตาหน้าต่าง
- รองรับ cost สำหรับคำขอแบบถ่วงน้ำหนัก
- สถานะเริ่มต้นไม่สร้างการระเบิดตอนดีพลอย
วิธีที่ 2: leaky bucket และ GCRA — เมื่อต้องการกระแสที่เรียบสม่ำเสมอ
เมื่อไหร่ควรเลือก leaky bucket
Token bucket อนุญาตการระเบิด สะดวกดี แต่มีสถานการณ์ที่การระเบิดเป็นอันตรายในตัวเอง: เซิร์ฟเวอร์ตอบสนองรุนแรงต่อยอดแหลมสั้นๆ, ช่องทางพร็อกซี่มีแบนด์วิดท์จำกัด, คุณต้องการให้รูปแบบทราฟฟิกดูเหมือนไคลเอนต์ธรรมดาที่ไม่รีบร้อน ในทุกกรณีนี้ต้องการเอาต์พุตที่มีช่วงเวลาคงที่ระหว่างคำขออย่างเคร่งครัด นี่คือ leaky bucket
ใช้งานแบบคิว
รูปแบบคลาสสิก: บัฟเฟอร์ความจุคงที่และผู้บริโภคเพียงตัวเดียวที่ดึงหนึ่งรายการทุก T วินาทีแล้วส่ง ข้อดี — ง่ายและเข้าใจง่าย ข้อเสีย — ต้องมีเธรดหรือ_task_แยก และถ้าผู้บริโภคหยุด บัฟเฟอร์ก็ "แช่แข็ง" วิธีนี้เหมาะเมื่อคุณมีไปป์ไลน์ชัดเจน: คิวงานที่ดึงคำขอออกมาทีละตัวอยู่แล้ว
ใช้งานแบบ GCRA
สำหรับสถานการณ์ฝั่งไคลเอนต์ส่วนใหญ่ การตีความแบบตัวนับสะดวกกว่า เราได้อธิบายอัลกอริทึมไว้ข้างบน มาดูวิธีการตั้งพารามิเตอร์ ถ้าต้องการช่วงเวลาที่เข้มงวด ให้ตั้ง τ = 0: ความคลาดเคลื่อนเป็นศูนย์ คำขอจะผ่านไม่บ่อยกว่าหนึ่งครั้งทุก T ถ้าต้องการอนุญาตการระเบิดเล็กน้อย ให้เพิ่ม τ การใช้งานsingleเดียวครอบคลุมทั้ง leaky bucket เข้มงวดและ token bucket ด้วยเหตุนี้ GCRA จึงเป็น "引擎เดียว" ที่ดีสำหรับไลบรารีจำกัดอัตรา
ขั้นตอน GCRA พร้อมการจอง
- อ่าน TAT สำหรับคีย์ ถ้าไม่มี ให้ถือ TAT = now
- new_TAT = max(TAT, now) + T * cost
- allow_at = new_TAT − τ − T * cost คือนาทีที่คำขอที่ต้นทุนเท่านี้จะส่งได้โดยไม่ต้องรอ
- ถ้า allow_at ≤ now: บันทึก new_TAT คืนค่า "รอศูนย์"
- ไม่งั้น: wait = allow_at − now; ถ้า wait เกิน max_delay — คืนการปฏิเสธโดยไม่บันทึก; ไม่งั้นบันทึก new_TAT และคืน wait
ในที่จัดเก็บแบบกระจาย ขั้นที่หนึ่งถึงห้าทำงานเป็นการดำเนินการอะตอมมิกครั้งเดียว — เช่น สคริปต์ฝั่งที่จัดเก็บ รับประกันว่าไคลเอนต์สองตัวจะไม่อ่าน TAT เดียวกันและ "ปล่อยผ่านซ้ำ"
ความเทียบเท่าและการเลือกตามลักษณะภาระ
มีประโยชน์ที่จะเข้าใจ: token bucket ด้วยพารามิเตอร์ (r, B) และ GCRA ด้วยพารามิเตอร์ (T = 1/r, τ = (B − 1)/r) ปล่อยผ่านลำดับคำขอเดียวกันทุกประการ ต่างกันแค่การนำเสนอสถานะ ดังนั้นคำถาม "อะไรดีกว่า" จริงๆ แล้วถามว่า: คุณต้องการการระเบิดไหม ต้องการ — ตั้ง B มากกว่าหนึ่ง ไม่ต้องการ — ตั้ง B = 1 (τ = 0) ที่เหลือเป็นเรื่องรสนิยมและความสะดวกในการจัดเก็บ
เช็กลิสต์ leaky bucket / GCRA
- ตัดสินใจแล้วว่าต้องการการระเบิดหรือกระแสเรียบสมบูรณ์
- สถานะ — ค่า TAT หนึ่งค่าต่อคีย์
- การดำเนินการอ่าน-ตรวจสอบ-เขียนเป็นอะตอมมิก
- มี max_delay และปฏิเสธชัดเจน
- เวลาในรูปแบบกระจายดึงจากฝั่งที่จัดเก็บ
วิธีที่ 3: ลิมิตแยกตามโฮสต์ — รีจิสทรี ลำดับชั้น และการประกอบ
ทำไม "ลิมิตเตอร์เดียวครอบจักรวาล" ใช้ไม่ได้
ถ้าไคลเอนต์ของคุณเข้าถึง API เดียว ถังเดียวก็พอ แต่ตัวรวมข้อมูล parser และบัสอินทิเกรชันติดต่อกับหลายสิบถึงหลายร้อยโฮสต์ แต่ละอันมีนโยบายของตัวเอง ลิมิตโลกระดับเดียวจะใช้โฮสต์เร็วๆ ได้ไม่เต็มที่หรือทำให้โฮสต์ช้าๆ เกินโหลด ต้องมี รีจิสทรีของลิมิตเตอร์: แมปปิ้ง "คีย์ลิมิต — สถานะของถัง" โดยคีย์สร้างจากลักษณะของคำขอ
คีย์ลิมิต: จากโฮสต์ถึงเอ็นด์พอยต์
คีย์ขั้นต่ำคือ สคีมาบวกโฮสต์บวกพอร์ต สองโดเมนของเจ้าของเดียวกันมักใช้โควตาร่วมกัน ส่วนโดเมนย่อยอาจนับแยกกัน เรื่องนี้ต้องรู้จากเอกสารหรือหาจากการสังเกต คีย์ที่ละเอียดกว่าคือ โฮสต์บวกแม่แบบพาธ: เช่น เอ็นด์พอยต์ค้นหาและเอ็นด์พอยต์การ์ดสินค้ามีโควตาต่างกัน ละเอียดยิ่งกว่าคือ โฮสต์บวกโทเคนการยืนยันตัวตน ถ้าเซิร์ฟเวอร์นับโควตาต่อคีย์ API และคุณมีหลายคีย์
หลักปฏิบัติ: สร้างคีย์จาก คุณลักษณะเดียวกับที่เซิร์ฟเวอร์ใช้ ถ้าเซิร์ฟเวอร์นับตาม IP คีย์ต้องมี IP ขาออกของคุณ ถ้านับตามโทเคน — โทเคน ถ้านับทั้งสองพร้อมกัน — คุณต้องมีลิมิตเตอร์สองตัว และคำขอต้องผ่านทั้งคู่
ลำดับชั้นของลิมิต
ระบบที่ออกแบบดีจะจัดลิมิตเตอร์เป็นระดับ:
- ระดับโลก — งบประมาณรวมของโปรเซส ปกป้องทรัพยากรของคุณเอง: ซ็อกเก็ต หน่วยความจำ แบนด์วิดท์ช่องทาง
- ตาม IP ขาออก — จำนวนคำขอที่ออกผ่านที่อยู่หนึ่งๆ ระดับสำคัญเมื่อทำงานผ่านพูลที่อยู่
- ตามโฮสต์ — นโยบายของเซิร์ฟเวอร์เป้าหมายโดยรวม
- ตามเอ็นด์พอยต์ — โควตาแยกสำหรับเมธอดที่แพง
- ตามข้อมูลบัญชี — โควตาต่อโทเคนหรือบัญชี
คำขอต้องได้รับอนุญาตในทุกระดับ นี่คือ การประกอบ ของลิมิตเตอร์
การประกอบโดยไม่เกิดการบล็อกกัน
วิธีไร้เดียงสาคือเรียก acquire ในแต่ละลิมิตเตอร์ตามลำดับแล้วรวมเวลารอ วิธีนี้ผิด: ลิมิตเตอร์ตัวแรกหักโทเคนไปแล้ว แต่ตัวที่สองบังคับให้รอสิบวินาที ซึ่งโทเคนของตัวแรก "หมดอายุ" ไปแล้วในแง่ความยุติธรรม แย่กว่านั้น งานสองงานที่จับลิมิตเตอร์ในลำดับต่างกันอาจขัดขวางกันไม่รู้จบ
ขั้นตอนที่ถูกต้อง:
- สำหรับแต่ละลิมิตเตอร์คำนวณเวลารอ โดยไม่หักโทเคน (ปฏิบัติการ peek)
- ใช้ค่าสูงสุดของเวลารอ — นั่นคือ wait รวม
- ถ้า wait เกิน max_delay — ปฏิเสธ
- ไม่งั้นดำเนินการหักโทเคนในทุกตัวลิมิตเตอร์ โดยส่งเวลา now + wait เดียวกัน เพื่อให้แต่ละตัวจองทรัพยากร ณ เวลาเดียวกัน
- นอน wait แล้วส่ง
วนผ่านลิมิตเตอร์ในลำดับคงที่เสมอ (เช่น จากโลกลงไปถึงแคบสุด) เพื่อไม่ให้เกิดการบล็อกกันเมื่อเข้าถึงแบบแข่งขัน
การตั้งค่าและค่าเริ่มต้น
รีจิสทรีต้องสามารถสร้างลิมิตเตอร์สำหรับโฮสต์ที่ไม่เคยเห็นมาก่อนได้ ตั้ง ค่าเริ่มต้นที่อนุรักษ์นิยม: ความเร็วต่ำ การระเบิดน้อยสุด สำหรับโฮสต์ที่รู้จัก — ตั้งค่าเริ่มต้นอย่างชัดเจน แนวปฏิบัติที่ดีคือเก็บนโยบายในรูปแบบประกาศ: โฮสต์หรือแม่แบบ, rate, burst, cost ตามแม่แบบพาธ, ธง "นับตาม IP" และ "นับตามโทเคน" แล้วเมื่อนโยบายเซิร์ฟเวอร์เปลี่ยน แก้ไฟล์เดียว ไม่ใช่โค้ด
การขับออกและการรั่วไหล
รีจิสทรีที่มีหลายพันโฮสต์คือผู้ต้องสงสัยเรื่องหน่วยความจำรั่ว โฮสต์ที่ไม่ได้ติดต่อมานานต้องถูกขับออก เพราะสถานะของถังหลังหยุดพักนานก็ "เต็ม" อยู่ดี (หรือ TAT อยู่ในอดีต) การขับออกไม่สูญเสียข้อมูล: ในการติดต่อครั้งถัดไป ลิมิตเตอร์จะสร้างใหม่ในสถานะเดียวกัน ใช้ LRU cache ที่มีขีดจำกัดขนาด หรือล้างรายการที่มี last เก่ากว่าหลายหน้าต่างเป็นระยะ
เช็กลิสต์ลิมิตแยกตามโฮสต์
- คีย์ลิมิตตรงกับคุณลักษณะที่เซิร์ฟเวอร์นับ
- มีระดับ: โลก, IP, โฮสต์, เอ็นด์พอยต์, ข้อมูลบัญชี
- การประกอบผ่าน peek — สูงสุด — หักโทเคนเดียว
- วนลิมิตเตอร์ในลำดับคงที่
- ค่าเริ่มต้นอนุรักษ์นิยมสำหรับโฮสต์ที่ไม่รู้จัก
- นโยบายแยกไว้ในการตั้งค่า
- รีจิสทรีจำกัดขนาดและขับคีย์ที่ไม่ใช้งาน
วิธีที่ 4: ลิมิตเตอร์กับการหมุน IP — จะนับการเปลี่ยนที่อยู่ในโมเดลอย่างไร
ทำไมการหมุนถึงทำลายลิมิตเตอร์แบบไร้เดียงสา
ถ้าเซิร์ฟเวอร์เป้าหมายนับโควตาตาม IP การเปลี่ยนที่อยู่ก็เปลี่ยนคีย์ลิมิตฝั่งเซิร์ฟเวอร์ ไคลเอนต์ไร้เดียงสาที่เก็บตัวนับเดียวต่อโฮสต์จะยังกระตุกอยู่หลังเปลี่ยน IP แม้ว่าเซิร์ฟเวอร์จะมองเห็น "ผู้มาใหม่" แล้ว ข้อผิดพลาดตรงข้ามอันตรายกว่า: ไคลเอนต์รีเซ็ตลิมิตทั้งหมดเมื่อเปลี่ยน IP รวมถึงตัวที่เซิร์ฟเวอร์นับตามโทเคนหรือบัญชี — แล้วโดนปฏิเสธโดยโควตาที่ไม่เกี่ยวข้องกับ IP เลย สรุป: การหมุนควรกระทบเฉพาะระดับ "ตาม IP ขาออก" ในลำดับชั้น ส่วนระดับอื่นๆ ใช้ชีวิตของมันเอง
สองโหมดของการเปลี่ยนที่อยู่
ในโครงสร้างพื้นฐาน Proxeon IP บนพอร์ตเปลี่ยนโดยใช้ตัวจับเวลาหรือเปลี่ยนตามลิงก์/API (ข้อมูล ณ 22.09.2026) นี่คือสองสถานการณ์ที่ต่างกันโดยพื้นฐานสำหรับลิมิตเตอร์ การเปลี่ยนตามตัวจับเวลา ไคลเอนต์ไม่ได้ควบคุมจังหวะ: ที่อยู่เปลี่ยน "จากภายนอก" และลิมิตเตอร์ตาม IP ต้องรู้ผ่านเหตุการณ์ การ poll ที่อยู่ปัจจุบัน หรือตามตารางถ้าทราบช่วงเวลา การเปลี่ยนตามลิงก์ ไคลเอนต์เป็นผู้เริ่มสลับเองและสามารถซิงโครไนซ์กับการสถานะของตัวมันเองได้: รอให้คำขอที่อยู่ในระหว่างดำเนินการเสร็จ บันทึกจังหวะ สร้างคีย์ใหม่ "โฮสต์บวกยุค IP"
แต่ละโหมดแพร่หลายแค่ไหน? ข้อมูล ณ 14.11.2026 สัดส่วนการเปลี่ยน IP ตามตัวจับเวลาคือ 51,1 % ที่เหลือเป็นการเปลี่ยนตามลิงก์/API นั่นคือ ทั้งสองกลยุทธ์พบพอๆ กัน และลิมิตเตอร์แบบสากลต้องรองรับทั้งคู่
ยุคของที่อยู่เป็นส่วนหนึ่งของคีย์
แทนที่จะเก็บ IP เองในคีย์ (ซึ่งอาจไม่รู้ล่วงหน้า) ให้ใช้ ยุค — ตัวนับที่เพิ่มขึ้นทุกครั้งที่เปลี่ยนที่อยู่ คีย์ระดับ "ตาม IP" กลายเป็นคู่ "พอร์ตบวกยุค" เมื่อยุคเปลี่ยน คีย์เก่าก็เลิกใช้และถูกขับออกจากรีจิสทรีในภายหลัง คีย์ใหม่ถูกสร้างในสถานะเริ่มต้น สังเกต: สถานะเริ่มต้นต้องอนุรักษ์นิยมอีกครั้ง ที่อยู่ใหม่สำหรับเซิร์ฟเวอร์คือคนแปลกหน้า สิ่งแรกที่มันจะเห็นคือรูปแบบทราฟฟิกของคุณ
จัดแนวหน้าต่างของลิมิตเตอร์กับจังหวะการหมุน
ข้อมูล ณ 14.11.2026 ช่วงเวลามัธยฐานระหว่างการเปลี่ยน IP ตามตัวจับเวลาคือ 120 วินาที และ 78,1 % ของช่วงเวลาตามตัวจับเวลาหารลงตัวด้วยหนึ่งนาทีพอดี สะดวกมากสำหรับการออกแบบ ถ้าคุณมีโควตาต่อโฮสต์ "N คำขอต่อนาทีต่อ IP" และที่อยู่มีอายุสองนาที งบประมาณของหนึ่งที่อยู่คือสองหน้าต่างนาทีพอดี ลิมิตเตอร์ตาม IP ทำงานเป็น token bucket ด้วยความเร็ว N/60 และความจุที่คำนวณให้ภายในอายุที่อยู่ไม่เกิน 2N สิ่งสำคัญคืออย่า "ตามเก็บ" ของที่พลาด: ถ้านาทีแรกส่งน้อย ในนาทีที่สองส่งเป็นสองเท่าไม่ได้ เพราะเซิร์ฟเวอร์นับตามหน้าต่างนาที ไม่ใช่ตามยุคของคุณ
หยุดชะงักระหว่างการสลับ
การเปลี่ยนที่อยู่ไม่ใช่ทันที ข้อมูล ณ 14.11.2026 ระยะเวลาการเปลี่ยนเอง — ตั้งแต่คำสั่งจนถึงที่อยู่ใหม่ — เฉลี่ย 4,56 วินาที และ 80,8 % ของการเปลี่ยนเสร็จภายใน 5 วินาที สำหรับลิมิตเตอร์แล้วหมายความว่าอะไร? ระหว่างสลับ คำขอจะออกผ่านที่อยู่เก่าหรือไม่ออกเลย กลยุทธ์ที่ถูกต้องคือถือการสลับเป็นช่วง "ระบาย" สั้นๆ: ก่อนคำสั่งสลับ ลิมิตเตอร์หยุดออกการอนุญาตใหม่ รอให้คำขอที่อยู่ในระหว่างดำเนินการเสร็จ ทำการสลับ แล้วเปิดยุคใหม่ เนื่องจากสี่ในห้าของการสลับเสร็จภายในห้าวินาที สมเหตุสมผลที่จะตั้ง timeout รอที่อยู่ใหม่สูงกว่าตัวเลขนี้เล็กน้อยและไปจัดการข้อยกเว้นถ้าเกิน
จำกัดความถี่ของคำสั่งสลับเอง
นี่คือข้อสังเกตที่มักถูกมองข้าม: คำสั่งสลับ IP ก็เป็นคำขอต่อ API เหมือนกัน และ它也ต้องถูกลิมิต ข้อมูล ณ 14.11.2026 สัดส่วนบันทึกซ้ำของการเปลี่ยนตามลิงก์ (ช่วงไม่เกิน 2 วินาที IP เดิม) คือ 1,2 % นี่คือร่องรอยของสถานการณ์ที่ไคลเอนต์ดึงลิงก์สองครั้งติดกัน: จากการแข่งขันระหว่าง worker จากการลองใหม่เมื่อ timeout จากการไม่มีจุดตัดสินใจเดียว ทางแก้คือถังแยกที่มีความจุหนึ่งและช่วงเวลาเข้มงวด (leaky bucket บริสุทธิ์ τ = 0) สำหรับคำสั่งหมุน บวกกับการกำจัดความซ้ำ: ถ้าการสลับเริ่มแล้ว worker อื่นรอผลลัพธ์แทนที่จะเริ่มใหม่ หลักการเดียวกับโฮสต์เป้าหมาย แค่ใช้กับโครงสร้างพื้นฐานของคุณเอง
ขนาดและการวางแผนงบประมาณ
เพื่อให้เห็นขนาด: ข้อมูล ณ 14.11.2026 ในหนึ่งวันทั่วทั้งเครือข่าย Proxeon มีการเปลี่ยน IP 2 196 242 ครั้ง มีพอร์ตพร็อกซี่ 7 924 พอร์ตเข้าร่วม และค่ามัธยฐานของ IP ที่ไม่ซ้ำต่อโมเด็มต่อวันคือ 95 สำหรับผู้ออกแบบลิมิตเตอร์ นั่นหมายถึงพอร์ตหนึ่งผ่านหลายสิบยุคของที่อยู่ในหนึ่งวัน และสถานะ "ตาม IP" ต้องเบาและขับออกได้เร็ว: การเก็บประวัติของทุกยุคไม่มีความหมายเลย แต่การรับประกันต้นทุนคงที่ในการสร้างยุคใหม่เป็นสิ่งจำเป็น
โปรโตคอลและการกำหนดพอร์ต
รายละเอียดเล็กๆ ที่ช่วยให้การตั้งค่าง่ายขึ้น: ใน Proxeon พอร์ต SOCKS5 เท่ากับพอร์ต HTTP บวกหนึ่ง (ข้อมูล ณ 22.09.2026) ถ้าคุณใช้ทั้งสองโปรโตคอลสำหรับช่องทางเดียวกัน ลิมิตเตอร์ตาม IP ต้องนับเป็นคีย์เดียว ไม่ใช่สอง: ที่อยู่ใช้ร่วมกัน งบประมาณจึงใช้ร่วมกัน บันทึกการปรับมาตรฐานในรีจิสทรี: คีย์สร้างจากพอร์ต HTTP ส่วนพอร์ต SOCKS5 ปรับมาเป็นค่านั้นด้วยการลบหนึ่ง
ลิมิตเตอร์แบบกระจายตาม IP
เมื่อมีหลายโปรเซสหรือหลายเครื่องใช้พอร์ตเดียวกัน ถังต้องเป็นแบบร่วม ใช้ที่จัดเก็บที่มีการดำเนินการอะตอมมิก เก็บ TAT (GCRA) ภายใต้คีย์ "พอร์ตบวกยุคบวกโฮสต์" อัปเดตด้วยสคริปต์ฝั่งที่จัดเก็บและดึงเวลาจากที่นั่นด้วย เก็บยุคแบบรวมศูนย์และเปลี่ยนแบบอะตอมมิกพร้อมคำสั่งหมุน — แล้วทุกโปรเซสจะเปลี่ยนไปยังคีย์ใหม่อย่างสอดคล้องกัน
เช็กลิสต์ลิมิตเตอร์เมื่อมีการหมุน
- การหมุนกระทบเฉพาะระดับ "ตาม IP" ระดับอื่นไม่ถูกรีเซ็ต
- รองรับทั้งสองโหมด: ตัวจับเวลาและการเปลี่ยนตามลิงก์/API
- คีย์ระดับ IP มียุคของที่อยู่
- ยุคใหม่เริ่มในสถานะอนุรักษ์นิยม
- ความเร็วตาม IP สอดคล้องกับหน้าต่างฝั่งเซิร์ฟเวอร์ ไม่ใช่ความยาวของยุค
- ระหว่างการสลับหยุดออกการอนุญาตชั่วคราว
- คำสั่งหมุนเองถูกลิมิตและกำจัดความซ้ำ
- พอร์ต HTTP และ SOCKS5 ของช่องทางเดียวกันปรับเป็นคีย์เดียว
- สำหรับสถานการณ์หลายโปรเซส สถานะถูกแยกไปที่จัดเก็บร่วม
ข้อผิดพลาดที่พบบ่อยในการออกแบบ rate limit ฝั่งไคลเอนต์
ข้อผิดพลาดที่ 1 sleep แทนลิมิตเตอร์
"ใส่วงหน่วงหนึ่งร้อยมิลลิวินาทีระหว่างคำขอ" — เป็นทางแก้นี้พบบ่อยที่สุดและเปราะบางที่สุด มันไม่คำนึงถึงเวลาของคำขอเอง ไม่ทำงานเมื่อมีหลาย worker ไม่ให้การระเบิดในที่ที่อนุญาต และไม่ป้องกันการเกิดในที่ที่ห้าม การหยุดชั่วคราวไม่ใช่ลิมิตเตอร์ แต่เป็นการเลียนแบบ
ข้อผิดพลาดที่ 2 นับตามหน้าต่างเมื่อเซิร์ฟเวอร์นับแบบเลื่อน
ปรากฏการณ์ขอบหน้าต่างอธิบายไว้ข้างบน ถ้าไม่แน่ใจว่าเซิร์ฟเวอร์นับอย่างไร ให้สมมติ Worst case — sliding window — และใช้ token bucket ที่มีความจุพอประมาณ
ข้อผิดพลาดที่ 3 การแข่งขันโดยไม่มีการจอง
หลายงานคำนวณเวลารอเท่ากันพร้อมกัน หลับและตื่นพร้อมกัน ผลลัพธ์คือการระเบิดที่ลิมิตเตอร์ควรจะป้องกันไว้พอดี แก้ด้วยการจอง (หักติดลบหรือเลื่อน TAT) ภายใต้ล็อก
ข้อผิดพลาดที่ 4 คิวรอไม่จำกัด
ถ้าไม่มี max_delay คิวโตไม่จำกัดและงานรอเป็นนาทีเป็นชั่วโมง กินหน่วยความจำและการเชื่อมต่อ ลิมิตเตอร์ต้องปฏิเสธเป็น
ข้อผิดพลาดที่ 5 นาฬิกาของระบบ
เวลาเกิดกระโดดหนึ่งครั้งตอนซิงโครไนซ์ ถังก็ล้นหรือ "ค้าง" ใช้นาฬิกาโมโนโทนิกฝั่งไคลเอนต์เท่านั้น และเวลาในที่จัดเก็บสำหรับรูปแบบกระจายเท่านั้น
ข้อผิดพลาดที่ 6 รีเซ็ตลิมิตทั้งหมดเมื่อเปลี่ยน IP
โควตาตามโทเคนและบัญชีไม่ขึ้นกับที่อยู่ รีเซ็ตมันแล้วคุณจะละเมิดนโยบายที่ไม่เกี่ยวกับคุณทันที
ข้อผิดพลาดที่ 7 ถังเต็มตอนเริ่ม
หลายสิบโปรเซสหลังดีพลอยเริ่มด้วยถังเต็มและปล่อยการระเบิดพร้อมกัน เริ่มจากถังว่างหรือเพิ่มความหน่วงสุ่มตอนเริ่ม
ข้อผิดพลาดที่ 8 รีจิสทรีที่ไม่มีการขับออก
ทุกโฮสต์ใหม่ — รายการใหม่ตลอดกาล ผ่านไปหลายสัปดาห์โปรเซสถือลิมิตเตอร์ของโฮสต์ที่ไม่มีวันได้ใช้ในหน่วยความจำ
ข้อผิดพลาดที่ 9 ไม่สนใจต้นทุนของคำขอ
ถ้าเซิร์ฟเวอร์นับการค้นหาเป็นสิบหน่วย但你ืนเป็นหนึ่ง ลิมิตเตอร์ของคุณจะปล่อยผ่านมากกว่าที่ควรสิบเท่าและจะประหลาดใจกับการปฏิเสธอย่างจริงใจ
ข้อผิดพลาดที่ 10 คำสั่งหมุนไม่จำกัด
การทำซ้ำคำสั่งเปลี่ยนที่อยู่เมื่อ timeout หรือจากหลาย worker นำไปสู่ความซ้ำและการสลับเกินจำเป็น คำสั่งก็เป็นทรัพยากร ให้ถัง它也ด้วย
เครื่องมือและแหล่งข้อมูลสำหรับการใช้งาน
ไลบรารีสำเร็จรูปตามระบบนิเวศ
- Go: แพ็กเกจ golang.org/x/time/rate — การใช้งาน token bucket ต้นแบบ พร้อมเมธอด Allow, Reserve และ Wait เมธอด Reserve คืนอ็อบเจ็กต์ที่มีเวลารอและความสามารถในการยกเลิก — ตรงกับความต้องการสำหรับการประกอบพอดี
- Python: ไลบรารี limits ให้ fixed window, sliding window และ GCRA พร้อมแบ็กเอนด์ต่างๆ; aiolimiter ใช้งาน leaky bucket สำหรับ asyncio; pyrate-limiter รองรับหลายหน้าต่างพร้อมกัน
- Java/Kotlin: Bucket4j — token bucket ที่โตเต็มที่มีการรองรับที่จัดเก็บกระจาย; Resilience4j RateLimiter — อีกรูปแบบที่มีรอบการรีเฟรชคงที่
- JavaScript/TypeScript: bottleneck จำกัดตามกลุ่มคีย์และจัดคลัสเตอร์ผ่านที่จัดเก็บร่วมได้; p-throttle — แบบเรียบง่ายสำหรับกรณีง่ายๆ
- Rust: governor — การใช้งาน GCRA ที่มีคีย์และไม่มี เหมาะกับโค้ดอะซิงโครนัส
- .NET: เนมสเปซ System.Threading.RateLimiting ในตัว พร้อม token bucket, sliding window และลิมิตเตอร์แบบ partitioned ตามคีย์
ที่จัดเก็บสำหรับสถานะกระจาย
Redis และที่จัดเก็บที่เข้ากันได้กับสคริปต์ฝั่งเซิร์ฟเวอร์เป็นมาตรฐานสำหรับ GCRA ร่วม: การดำเนินการอะตอมมิกครั้งเดียว เวลาดึงด้วยคำสั่งของที่จัดเก็บ คีย์ที่มี TTL ถูกขับออกอัตโนมัติ สำหรับสถานการณ์ภายในคลัสเตอร์แอปพลิเคชันเดียว กลไกในตัวเช่น distributed cache ที่มีการดำเนินการอะตอมมิกก็ใช้ได้
เครื่องมือสังเกตการณ์
ลิมิตเตอร์ที่ไม่มีเมตริกคือกล่องดำ ส่งออก: จำนวนการอนุญาตที่ไม่ต้องรอ การกระจายของเวลารอ จำนวนการปฏิเสธตาม max_delay ระดับการเติมของถังปัจจุบันตามคีย์ ความถี่ของการเปลี่ยนยุคที่อยู่ ฮิสโตแกรมเวลารอตามโฮสต์จะแสดงให้เห็นทันทีว่านโยบายไหนเข้มเกินไปและที่ไหนคุณอยู่ขีดจำกัด
โครงสร้างพื้นฐานที่อยู่
สำหรับสถานการณ์ที่มีการหมุน ต้องมีผู้ให้บริการที่ให้โหมดเปลี่ยนที่อยู่สองแบบ — ตามตัวจับเวลาและตามลิงก์/API — พร้อมการกำหนดพอร์ตที่คาดเดาได้ ใน Proxeon ทั้งสองโหมดมีให้ใช้ และพอร์ต SOCKS5 ห่างจากพอร์ต HTTP หนึ่งหน่วยพอดี (ข้อมูล ณ 22.09.2026) ซึ่งช่วยให้การปรับคีย์ในรีจิสทรีลิมิตเตอร์ง่ายขึ้น
สิ่งที่ควรอ่าน
- คำอธิบาย GCRA ในข้อกำหนดมาตรฐานโทรคมนาคม — ต้นฉบับของ leaky bucket ในฐานะตัวนับ
- เอกสารของแพ็กเกจ x/time/rate — การกำหนดความหมายของ Reserve และ Wait ที่เป็นแบบอย่าง
- ส่วนเกี่ยวกับลิมิตในเอกสารของ API สาธารณะขนาดใหญ่ — มีโมเดลการนับครบทุกแบบ และเป็นวิธีที่ดีที่สุดในการเรียนรู้ที่จะแปลงนโยบายเป็นพารามิเตอร์ของถัง
กรณีศึกษาและสถานการณ์การใช้งาน
สถานการณ์ที่ 1 ตัวรวมราคาบนหลายร้อยโฮสต์
งาน: ไล่ดูการ์ดสินค้าบนหลายแพลตฟอร์มเป็นประจำ แต่ละแห่งมีนโยบายของตัวเอง ทางแก้: รีจิสทรีลิมิตเตอร์ที่มีคีย์ "โฮสต์บวกแม่แบบพาธ" ค่าเริ่มต้นอนุรักษ์นิยมสำหรับแพลตฟอร์มใหม่ นโยบายชัดเจนสำหรับที่รู้จัก การประกอบกับลิมิตโลกระดับจำนวนซ็อกเก็ต ผลลัพธ์ที่ระบบเหล่านี้ต้องการ: ภาระที่สม่ำเสมอบนทุกโฮสต์ โดยไม่มีเวลาว่างบนโฮสต์เร็วและไม่มี overload บนโฮสต์ช้า; เมื่อนโยบายของแพลตฟอร์มเปลี่ยน แก้บรรทัดเดียวในการตั้งค่า บทเรียนสำคัญ — การเปลี่ยนจากลิมิตโลกระดับเดียวไปสู่ลำดับชั้นลดสัดส่วนคำขอที่ส่ง "เสียเปล่า" ได้อย่างรวดเร็ว
สถานการณ์ที่ 2 SDK สำหรับ API พาร์ทเนอร์ที่มีโควตาต่อโทเคนและต่อ IP
งาน: ไลบรารีสำหรับไคลเอนต์ที่มีหลายโทเคนและหลายที่อยู่ขาออก ทางแก้: ลิมิตเตอร์สองระดับ — ตามโทเคนและตามที่อยู่ — ประกอบผ่าน peek และเวลาถึงเดียว ตัวจัดตารางเลือกคู่ "โทเคนบวกที่อยู่" ที่เวลารอน้อยที่สุด บทเรียน — ลิมิตเตอร์กลายเป็นเครื่องมือกำหนดเส้นทาง: แทนที่จะ "รอ" มันบอกว่า "ส่งที่ไหนจึงไม่ต้องรอ"
สถานการณ์ที่ 3 parser บนที่อยู่มือถือที่มีการหมุนตามตัวจับเวลา
งาน: ไล่ดูหน้าเว็บสาธารณะผ่านพูลพอร์ต ที่อยู่เปลี่ยนตามตัวจับเวลา ทางแก้: ลิมิตเตอร์ตาม IP ที่มีคีย์ "พอร์ตบวกยุค" ความเร็วสอดคล้องกับหน้าต่างนาทีของโฮสต์เป้าหมาย ด้วยข้อมูล ณ 14.11.2026 ที่ช่วงเวลาตามตัวจับเวลามัธยฐาน — 120 วินาที และ 78,1 % ของช่วงเวลาหารลงตัวด้วยหนึ่งนาที งบประมาณต่อยุคคำนวณเป็นจำนวนเต็มของหน้าต่างนาที ระหว่างการสลับ — ซึ่ง 80,8 % ของการเปลี่ยนเสร็จภายใน 5 วินาที (ข้อมูล ณ 14.11.2026) — การออกการอนุญาตหยุดชั่วคราวด้วย timeout สูงกว่าเกณฑ์นี้เล็กน้อย บทเรียน — การจัดแนวหน้าต่างของลิมิตเตอร์กับจังหวะการหมุนขจัด "การตามเก็บ" ที่ระเบิดต้นยุคใหม่
สถานการณ์ที่ 4 worker ที่หมุนตามลิงก์และคำสั่งซ้ำ
งาน: worker หลายตัวใช้พอร์ตเดียวและแต่ละตัวเริ่มเปลี่ยนที่อยู่เมื่อจำเป็น อาการ — ร่องรอยของคำสั่งซ้ำในบันทึก ทางแก้: จุดหมุนเดียวด้วย leaky bucket (τ = 0) และการกำจัดความซ้ำ: ถ้าการสลับเริ่มแล้ว คนอื่นรอให้เสร็จ ข้อมูล ณ 14.11.2026 สัดส่วนบันทึกซ้ำของการเปลี่ยนตามลิงก์ทั่วเครือข่ายคือ 1,2 % ซึ่งเป็นสถานการณ์ที่จุดตัดสินใจเดียวขจัดออกไปพอดี บทเรียน — ต้องลิมิตไม่ใช่แค่คำขอไปยัง API ของคนอื่น แต่รวมถึงคำสั่งไปยังโครงสร้างพื้นฐานของคุณเองด้วย
สถานการณ์ที่ 5 引擎เดียวบน GCRA สำหรับทุกระดับ
งาน: ทำให้โค้ดเบสง่ายขึ้น ซึ่งเคยมีทั้ง fixed window, การหยุดชั่วคราว และตัวนับมือ coexist กัน ทางแก้: การใช้งาน GCRA เดียวด้วยพารามิเตอร์ (T, τ) ใช้ทุกระดับของลำดับชั้น โดยเก็บสถานะในที่จัดเก็บร่วมสำหรับคีย์กระจายและในหน่วยความจำสำหรับคีย์ lokal บทเรียน — สูตรเดียวแทนที่สวนสัตว์ของทางแก้และทำให้พฤติกรรมของระบบคาดเดาได้
FAQ: ตอบคำถามที่ยาก
token bucket ต่างจาก leaky bucket ตรงไหนถ้ามันเทียบเท่ากัน?
มันเทียบเท่ากันในฐานะวัตถุทางคณิตศาสตร์: ด้วยการจับคู่พารามิเตอร์ที่ถูกต้อง ปล่อยผ่านลำดับคำขอเดียวกันทุกประการ ความต่างอยู่ที่สัญชาตญาณและพารามิเตอร์ที่คุณควบคุมโดยตรง token bucket คิดในแง่ "ความเร็วและการระเบิด" leaky bucket คิดในแง่ "ช่วงเวลาและความคลาดเคลื่อน" สำหรับนโยบายแบบ "N ต่อนาที ไม่เกิน M ต่อครั้ง" แบบแรกสะดวกกว่า; สำหรับ "หนึ่งคำขอพอดีทุก T" — แบบหลัง GCRA รวมทั้งสองสัญชาตญาณไว้ในสถานะเดียว
จะเลือกความจุของถังอย่างไรถ้าเซิร์ฟเวอร์ไม่ประกาศการระเบิดที่อนุญาต?
เริ่มจากสัดส่วนเล็กๆ ของโควตาหน้าต่าง — ประมาณห้าถึงสิบเปอร์เซ็นต์ — แล้วสังเกต ถ้าไม่มีการปฏิเสธและเวลารอยาว ให้เพิ่มอย่างระมัดระวัง จำไว้ว่าเซิร์ฟเวอร์แบบ sliding window ไม่ยอมรับการระเบิดที่เกินโควตาในช่วงเวลาสั้นๆ ดังนั้นความจุไม่ควรใกล้เคียงโควตาเต็มเลย
ยังต้องมีลิมิตเตอร์ถ้ามีแค่เธรดเดียวไหม?
ต้อง เธรดเดียวที่คำขอสั้นย่อมเกินโควตาได้ง่าย: ถ้าตอบสนองภายในยี่สิบมิลลิวินาที คุณจะส่งห้าสิบคำขอต่อวินาทีโดยไม่รู้ตัว ลิมิตเตอร์จำเป็นไม่ว่าจะมีกี่เธรด; มันแก้ปัญหาคนละเรื่องกับ semaphore
จะลิมิตคำขอที่มีต้นทุนต่างกันเมื่อเซิร์ฟเวอร์นับต่างกันได้อย่างไร?
ส่ง cost เข้า acquire โทเคนถูกหักตามสัดส่วน เวลารอคำนวณด้วยสูตรเดิม ถ้าต้นทุนไม่รู้ ให้ประมาณจากเวลาตอบสนองหรือขนาดการตอบสนองและปรับตามการสังเกต ดีกว่าประมาณเกินกว่าประมาณต่ำ
ถ้าคำขอเดียวต้องผ่านห้าลิมิตเตอร์และแต่ละตัวให้เวลารอต่างกัน ทำอย่างไร?
ก่อนอื่นถามทุกตัวเวลารอโดยไม่หักโทเคน ใช้ค่าสูงสุด แล้วหักโทเคนทุกตัว ณ เวลาถึงเดียวกัน วนลิมิตเตอร์ในลำดับเดียวเสมอ ถ้าค่าสูงสุดเกินเกณฑ์ — ปฏิเสธโดยไม่หักโทเคน ไม่งั้นทรัพยากรจะถูกจอง "เสียเปล่า"
ลิมิตเตอร์ควรตอบสนองต่อการเปลี่ยน IP ตามตัวจับเวลาอย่างไรถ้าไม่รู้จังหวะที่แน่นอน?
ใช้เหตุการณ์หรือการ poll ที่อยู่ปัจจุบัน และถ้าทราบช่วงเวลา — ตารางที่มีการเผื่อ ใน Proxeon การเปลี่ยนตามตัวจับเวลาและตามลิงก์/API เป็นทั้งสองโหมดมาตรฐาน (ข้อมูล ณ 22.09.2026) และถ้าต้องการซิงโครไนซ์ที่แม่นยำ ควรเลือกโหมดตามลิงก์: แล้วคุณเป็นผู้กำหนดจังหวะการเปลี่ยนและเปิดยุคใหม่ในรีจิสทรีของคุณพอดีเมื่อการสลับได้รับการยืนยัน
ทำไมถึงรีเซ็ตลิมิตทั้งหมดหลังเปลี่ยนที่อยู่ไม่ได้?
เพราะเซิร์ฟเวอร์อาจนับโควตาตามหลายคุณลักษณะพร้อมกัน ที่อยู่เปลี่ยน — โควตาตาม IP เริ่มใหม่ แต่โควตาตามโทเคน บัญชี หรือเซสชันยังนับต่อ รีเซ็ตทั้งหมดแล้วคุณจะละเมิดนโยบายที่ไม่ขึ้นกับที่อยู่ การหมุนควรกระทบเฉพาะระดับ "ตาม IP" ในลำดับชั้น
สำหรับลิมิตเตอร์กระจาย token bucket หรือ GCRA ดีกว่ากัน?
GCRA มันมีค่าสถานะเดียว อัปเดตแบบอะตอมมิกได้ง่ายกว่าและเก็บพร้อม TTL ได้ง่ายกว่า Token bucket ต้องสองค่าและตรรกะการเติมที่ซับซ้อนกว่า ซึ่งทำให้สคริปต์อะตอมมิกซับซ้อนขึ้น ในเชิงความหมายทั้งคู่ให้ผลลัพธ์เหมือนกัน
จะตรวจสอบว่าลิมิตเตอร์ทำงานถูกก่อนขึ้นโปรดักชันได้อย่างไร?
เขียนเทสต์ที่แทนที่นาฬิกาได้: ป้อนคำขอ ณ เวลาที่กำหนดและเปรียบเทียบการตัดสินใจกับลำดับอ้างอิง ตรวจสอบกรณีขอบ: เวลาศูนย์ การหยุดพักนาน คำขอมาพร้อมกันหลายรายการ ต้นทุนมากกว่าความจุ (ต้องปฏิเสธชัดเจน ไม่ใช่รอไม่รู้จบ) ทดสอบการประกอบแยก: ลิมิตเตอร์สองตัวที่มีความเร็วต่างกันและตรวจว่าไม่มีตัวไหนปล่อยผ่านเกินโควตาของตัวเอง
บทสรุป: ก้าวต่อไป
rate limit ฝั่งไคลเอนต์ไม่ใช่เบรก แต่เป็นระบบควบคุม ลิมิตเตอร์ที่สร้างอย่างถูกต้องทำสามอย่าง: ไม่ยอมให้ถึงจุดปฏิเสธ ใช้budget ที่มีอย่างสม่ำเสมอ และบอกตัวจัดตารางว่าควรส่งคำขอถัดไปที่ไหนเมื่อไหร่ พื้นฐานคือสูตรเดียว ไม่ว่าจะเป็น token bucket หรือ GCRA แต่ต้องล้อมด้วยวินัย: นาฬิกาโมโนโทนิก การจองภายใต้ล็อก ความหน่วงสูงสุด ลำดับชั้นของคีย์ และการขับออก
สรุปสั้นๆ:
- Fixed window ง่ายแต่มีกับดักที่ขอบ ให้เลือก token bucket หรือ GCRA
- Token bucket ให้การควบคุมความเร็วและการระเบิดแยกกัน; GCRA — เหมือนกันในตัวเลขสถานะเดียว
- คีย์ลิมิตตรงกับคุณลักษณะที่เซิร์ฟเวอร์นับ; ลิมิตเตอร์จัดเป็นลำดับชั้นและประกอบผ่าน peek — สูงสุด — หักโทเคนเดียว
- การหมุนที่อยู่เปลี่ยนเฉพาะระดับ "ตาม IP"; คำสั่งหมุนเองก็สมควรมีถังของตัวเอง
- เมตริกเวลารอและการปฏิเสธเป็นวิธีเดียวที่ซื่อสัตย์ในการรู้ว่านโยบายของคุณตรงกับเซิร์ฟเวอร์แค่ไหน
ก้าวต่อไปสำหรับคุณ: เลือก引擎เดียว (เราแนะนำ GCRA) อธิบายนโยบายของโฮสต์ที่รู้จักในการตั้งค่า เพิ่มค่าเริ่มต้นอนุรักษ์นิยม เปิดเมตริก และรันเทสต์ที่แทนที่นาฬิกาได้ ถ้าทำงานผ่านพูลที่อยู่ ให้เพิ่มยุคในคีย์และถังแยกสำหรับคำสั่งเปลี่ยน หลังจากนั้นไคลเอนต์ของคุณจะดูเหมือนแขกที่สุภาพที่สุดในสายตาของเซิร์ฟเวอร์ใดๆ — คนที่ไม่มีวันถูกปฏิเสธ