Come progetti il rate limiting?

Question

Accepted Answer

**Rate limiting** limita quanti richieste un client può effettuare in una finestra temporale — proteggendo i sistemi da abusi, sovraccarichi e garantendo un utilizzo equo. È un componente comune della progettazione di sistemi, con diversi algoritmi e considerazioni.

## Perché è importante

```text
✓ PROTECT against abuse → prevent attacks (brute force, scraping, DoS), excessive use
✓ PREVENT OVERLOAD → protect the system from being overwhelmed (stability)
✓ FAIR USAGE → ensure no single client monopolizes resources; tiered limits (free vs paid)
✓ COST control; protect downstream services
→ a common requirement for APIs and services.
```

## Algoritmi di rate limiting

```text
FIXED WINDOW → count requests per fixed time window (e.g. 100/minute); simple
  ✗ allows bursts at window boundaries (up to 2x at the edges)
SLIDING WINDOW → rolling time window → smoother, no boundary bursts (more accurate)
TOKEN BUCKET → tokens refill at a rate; each request takes a token → allows BURSTS up to
  the bucket size while limiting the average rate (popular, flexible)
LEAKY BUCKET → requests processed at a steady rate (smooths output)
```

## Considerazioni di implementazione

```text
✓ DISTRIBUTED → limits must be shared across servers → use a centralized store (REDIS is
  common: atomic counters, fast, shared across instances)
✓ Identify the client → by API key, user ID, IP
✓ Return clear responses → HTTP 429 (Too Many Requests); include limit/retry-after headers
✓ Where → at the API gateway, load balancer, or application layer
✓ Granularity → per user, per endpoint, global; different tiers/limits
```

## Perché è importante

Comprendere come progettare il rate limiting è prezioso perché è un **componente comune della progettazione di sistemi** per proteggere i sistemi e garantire un utilizzo equo, quindi è una conoscenza pratica importante.

Rate limiting — limitare quanti richieste un client può effettuare in una finestra temporale — affronta esigenze importanti: **protezione da abusi** (prevenire attacchi come brute force, scraping e DoS), **prevenzione del sovraccarico** (proteggere la stabilità del sistema), garantire un **utilizzo equo** (nessun client monopolizza le risorse, supportare limiti in tiers come gratuito vs a pagamento) e controllo dei costi.

Questi rendono il rate limiting un requisito comune per API e servizi.

Comprendere gli **algoritmi** e i loro trade-off — **finestra fissa** (semplice ma consente burst ai confini), **finestra scorrevole** (più uniforme e accurata), **token bucket** (consente burst controllati limitando il rate medio — popolare e flessibile) e leaky bucket (levigatura dell'output) — è la conoscenza di progettazione chiave, poiché la scelta dell'algoritmo giusto influenza il comportamento.

Comprendere le **considerazioni di implementazione** è particolarmente importante: gestire il **rate limiting distribuito** (limiti condivisi su più server, comunemente usando **Redis** per contatori atomici veloci condivisi tra istanze — poiché i limiti per-server non funzionano in sistemi distribuiti), identificare i client (per chiave API, utente o IP), restituire risposte chiare (HTTP 429 con header retry-after), scegliere dove applicarlo (gateway, load balancer o applicazione) e granularità (per utente, per endpoint, in tiers).

Questi riflettono la progettazione di rate limiting che funziona in veri sistemi distribuiti.

Rate limiting è un componente frequentemente necessario, che spesso compare nei colloqui e discussioni di progettazione di sistemi.

Poiché il rate limiting è un componente comune e importante per proteggere i sistemi (da abusi e sovraccarichi) e garantire un utilizzo equo, e poiché comprendere gli algoritmi, i loro trade-off e soprattutto l'implementazione distribuita (limiti condivisi via Redis) è importante per progettarlo bene, comprendere come progettare il rate limiting è una conoscenza di progettazione di sistemi preziosa e praticamente rilevante — un componente comune per proteggere i servizi e garantire un utilizzo equo, richiedendo la comprensione degli algoritmi e dell'implementazione distribuita, e un argomento frequentemente discusso nella progettazione di sistemi per costruire sistemi robusti e protetti.