บทความ

บทนำ: ทำไมไคลเอนต์ถึงควรมี 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 จำกัดจำนวนการทำงานพร้อมกันและตอบคำถามว่า "ตอนนี้มีงานค้างอยู่ในระบบกี่งาน" ส่วนลิมิตเตอร์จำกัดความถี่และตอบคำถามว่า "ตอนนี้เริ่มงานอีกงานได้ไหม และถ้าไม่ได้ อีกกี่มิลลิวินาทีถึงจะได้" สองกลไกนี้เสริมกัน แต่แทนกันไม่ได้ คุณอาจถือการเชื่อมต่อเดียวและยังเกินลิมิตได้ถ้าคำขอสั้น คุณอาจถือการเชื่อมต่อร้อยอันและยังอยู่ในลิมิตได้ถ้าคำขอช้า

สามคุณสมบัติของลิมิตเตอร์ฝั่งไคลเอนต์ที่ดี

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

จำสามเกณฑ์นี้ไว้ เพราะเราจะใช้มันเปรียบเทียบอัลกอริทึมในหัวข้อถัดไป

เจาะลึก: ตระกูลของอัลกอริทึมและคณิตศาสตร์เบื้องหลัง

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 อัลกอริทึม:

  1. ดึงเวลาปัจจุบัน now
  2. ถ้า TAT น้อยกว่า now ให้ถือว่า TAT เท่ากับ now (ถังว่างมานานแล้ว)
  3. ถ้า TAT − τ มากกว่า now — คำขอมาก่อนเกินไป เวลารอคือน TAT − τ − now
  4. ไม่งั้นปล่อยคำขอและเลื่อน 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)

  1. จับล็อก
  2. now = monotonic(); elapsed = now − last; last = now
  3. tokens = min(capacity, tokens + elapsed * rate)
  4. ถ้า tokens ≥ cost: tokens −= cost; ปล่อยล็อก; คืนค่า "รอศูนย์"
  5. ไม่งั้น: wait = (cost − tokens) / rate; หักโทเคนติดลบ: tokens −= cost; ปล่อยล็อก; คืนค่า wait
  6. ฝ่ายที่เรียกนอน 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 พร้อมการจอง

  1. อ่าน TAT สำหรับคีย์ ถ้าไม่มี ให้ถือ TAT = now
  2. new_TAT = max(TAT, now) + T * cost
  3. allow_at = new_TAT − τ − T * cost คือนาทีที่คำขอที่ต้นทุนเท่านี้จะส่งได้โดยไม่ต้องรอ
  4. ถ้า allow_at ≤ now: บันทึก new_TAT คืนค่า "รอศูนย์"
  5. ไม่งั้น: 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 ขาออกของคุณ ถ้านับตามโทเคน — โทเคน ถ้านับทั้งสองพร้อมกัน — คุณต้องมีลิมิตเตอร์สองตัว และคำขอต้องผ่านทั้งคู่

ลำดับชั้นของลิมิต

ระบบที่ออกแบบดีจะจัดลิมิตเตอร์เป็นระดับ:

  1. ระดับโลก — งบประมาณรวมของโปรเซส ปกป้องทรัพยากรของคุณเอง: ซ็อกเก็ต หน่วยความจำ แบนด์วิดท์ช่องทาง
  2. ตาม IP ขาออก — จำนวนคำขอที่ออกผ่านที่อยู่หนึ่งๆ ระดับสำคัญเมื่อทำงานผ่านพูลที่อยู่
  3. ตามโฮสต์ — นโยบายของเซิร์ฟเวอร์เป้าหมายโดยรวม
  4. ตามเอ็นด์พอยต์ — โควตาแยกสำหรับเมธอดที่แพง
  5. ตามข้อมูลบัญชี — โควตาต่อโทเคนหรือบัญชี

คำขอต้องได้รับอนุญาตในทุกระดับ นี่คือ การประกอบ ของลิมิตเตอร์

การประกอบโดยไม่เกิดการบล็อกกัน

วิธีไร้เดียงสาคือเรียก acquire ในแต่ละลิมิตเตอร์ตามลำดับแล้วรวมเวลารอ วิธีนี้ผิด: ลิมิตเตอร์ตัวแรกหักโทเคนไปแล้ว แต่ตัวที่สองบังคับให้รอสิบวินาที ซึ่งโทเคนของตัวแรก "หมดอายุ" ไปแล้วในแง่ความยุติธรรม แย่กว่านั้น งานสองงานที่จับลิมิตเตอร์ในลำดับต่างกันอาจขัดขวางกันไม่รู้จบ

ขั้นตอนที่ถูกต้อง:

  1. สำหรับแต่ละลิมิตเตอร์คำนวณเวลารอ โดยไม่หักโทเคน (ปฏิบัติการ peek)
  2. ใช้ค่าสูงสุดของเวลารอ — นั่นคือ wait รวม
  3. ถ้า wait เกิน max_delay — ปฏิเสธ
  4. ไม่งั้นดำเนินการหักโทเคนในทุกตัวลิมิตเตอร์ โดยส่งเวลา now + wait เดียวกัน เพื่อให้แต่ละตัวจองทรัพยากร ณ เวลาเดียวกัน
  5. นอน 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) อธิบายนโยบายของโฮสต์ที่รู้จักในการตั้งค่า เพิ่มค่าเริ่มต้นอนุรักษ์นิยม เปิดเมตริก และรันเทสต์ที่แทนที่นาฬิกาได้ ถ้าทำงานผ่านพูลที่อยู่ ให้เพิ่มยุคในคีย์และถังแยกสำหรับคำสั่งเปลี่ยน หลังจากนั้นไคลเอนต์ของคุณจะดูเหมือนแขกที่สุภาพที่สุดในสายตาของเซิร์ฟเวอร์ใดๆ — คนที่ไม่มีวันถูกปฏิเสธ