Cum să implementezi rate limiting pentru un API Python

In this tutorial, you'll learn about Cum să implementezi rate limiting pentru un API Python. We cover key concepts, practical examples, and best practices to help you understand and apply this topic effectively.

Rate Limiting limitează numărul de request-uri pe care un client le poate face într-un interval de timp. În acest ghid vei învăța cum să implementezi Rate Limiting pentru API-ul tău Python pentru a preveni abuzul și supraîncărcarea.

Problema

Fără Rate Limiting, un client poate trimite mii de request-uri pe secundă, suprasolicitând serverul, consumând resurse și afectând ceilalți utilizatori.

Soluția Rapidă

1. Rate Limiting cu FastAPI și slowapi

pip install slowapi

from fastapi import FastAPI
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)
app = FastAPI()
app.state.limiter = limiter
app.add_exception_handler(429, _rate_limit_exceeded_handler)

@app.get("/public")
@limiter.limit("10/minute")
def endpoint_public(request: Request):
    return {"mesaj": "Endpoint cu rate limit"}

2. Rate Limiting cu Flask-Limiter

pip install flask-limiter

from flask import Flask, jsonify
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)
limiter = Limiter(app=app, key_func=get_remote_address)

@app.route("/api")
@limiter.limit("5 per second")
def api():
    return jsonify({"mesaj": "Rate limitat"})

3. Rate Limiting distribuit cu Redis

pip install slowapi redis

from slowapi import Limiter
from slowapi.storage import RedisStorage
import redis

redis_client = redis.Redis(host="localhost", port=6379)
storage = RedisStorage(redis_client)

limiter = Limiter(
    key_func=get_remote_address,
    storage_uri="redis://localhost:6379"
)

4. Limite diferite pe rute

@app.get("/free")
@limiter.limit("100/zi")
def gratuit(request: Request):
    return {"plan": "gratuit"}

@app.get("/premium")
@limiter.limit("10000/zi")
def premium(request: Request):
    return {"plan": "premium"}

Testare:

for i in {1..12}; do curl -s http://localhost:8000/public; echo; done

După al 10-lea request, vei primi 429 Too Many Requests.

Prevenție

• Alege limite realiste bazate pe planurile de tarifare și capacitatea serverului
• Folosește Redis pentru Rate Limiting distribuit în medii multi-container
• Adaugă header-ele X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset în response
• Combină Rate Limiting pe IP și pe API key pentru mai multă precizie

Greșeli Comune

1. Rate Limiting doar pe IP -- utilizatorii din aceeași rețea (birou, școală) sunt afectați incorect
2. Limite prea stricte -- o limită de 1 request pe minut pentru un API public este nerezonabilă
3. Fără informare în response -- clientul nu știe când poate reîncerca fără header-ele de rate limit
4. Resetarea limitelor la restart -- fără Redis sau un storage persistent, limitele se pierd
5. Lipsa Rate Limiting pe rute critice -- endpoint-urile de login și înregistrare sunt cele mai vizate

Exercițiu Practic

Implementează un API cu trei niveluri de rate limit: gratuit (10/min), standard (100/min) și premium (1000/min). Folosește un API key pentru identificarea planului.

FAQ