# Gateway पर Rate Limiting — API Gateway और Service Mesh

Source: https://www.geekswithgeeks.com/hi/api-gateway-service-mesh/s-rate-limit

> Token-bucket शैली की सीमाओं से backends की रक्षा करें और clients के साथ निष्पक्ष रहें।

## दर और उफान

Gateways प्रति key, user या IP rate-limit करते हैं। **Token bucket** निरंतर दर और छोटा **उफान** (burst) अनुमत करता है: bucket में अधिकतम `burst` tokens रहते हैं, प्रति सेकंड `rate` से भरता है, और हर अनुरोध एक ख़र्च करता है। nginx में `limit_req_zone ... rate=5r/s` दर और `limit_req ... burst=5 nodelay` उफान तय करता है; अतिरिक्त अनुरोध `limit_req_status` से तय status (**429** रखें) के साथ अस्वीकार होते हैं। `Retry-After` और rate-limit headers लौटाएँ ताकि सुव्यवहारी clients पीछे हटें। Gateway instances के cluster में counters साझा store (जैसे Redis) में रखें या मानें कि हर instance अपना हिस्सा लागू करता है।

## Rate limit config

प्रति client IP प्रति सेकंड 5 अनुरोध, तुरंत 5 अतिरिक्त अनुरोधों के उफान की अनुमति के साथ। Gateway config का अंश।

```nginx
limit_req_zone $binary_remote_addr zone=perip:1m rate=5r/s;
limit_req_status 429;

location /public/ { limit_req zone=perip burst=5 nodelay; proxy_pass http://orders_stable/; }
```

## 20 तेज़ अनुरोध, चलाकर

मैंने यह Docker में असली nginx 1.27 gateway पर चलाया, upstreams के रूप में छोटी Node.js services के साथ (पूरा setup केस स्टडी में)। एक साथ 20 अनुरोध भेजने पर पहले 6 सफल होते हैं (दर से अनुमत 1 और 5 का उफान) और बाक़ी 14 `429` से अस्वीकार होते हैं।

```bash
# 20 concurrent calls to /public/x, tallying status codes
```

Output:

```
{"200":6,"429":14}
```

## Token bucket मॉडल, चलाकर

मैंने यह सादा-Python मॉडल चलाया। 5 क्षमता की bucket जो प्रति सेकंड 5 भरती है, 20 तात्कालिक अनुरोधों में से 5 अनुमत करती है, और भरने के बाद एक सेकंड बाद फिर 20 में से 5।

```python
import hashlib, bisect, math, random

class Bucket:
    def __init__(self, cap, rate): self.cap, self.rate, self.tokens, self.t = cap, rate, cap, 0.0
    def allow(self, now):
        self.tokens = min(self.cap, self.tokens + (now - self.t) * self.rate); self.t = now
        if self.tokens >= 1: self.tokens -= 1; return True
        return False
bk = Bucket(5, 5.0)
print(sum(bk.allow(0.0) for _ in range(20)), "allowed of 20 at t=0;", sum(bk.allow(1.0) for _ in range(20)), "of 20 one second later")

```

Output:

```
5 allowed of 20 at t=0; 5 of 20 one second later
```

**Quiz:** Burst setting क्या नियंत्रित करती है?

- [x] स्थिर दर से ऊपर कितने अनुरोध तुरंत स्वीकार हो सकते हैं
- [ ] Response bodies का आकार
- [ ] TLS version
- [ ] Log format

*Answer:* स्थिर दर से ऊपर कितने अनुरोध तुरंत स्वीकार हो सकते हैं. Burst छोटे उफान सोखता है जबकि दर लंबी अवधि का औसत सीमित करती है।