Limitowanie liczby żądań i zapobieganie nadużyciom
Na tej stronie
Dlaczego ograniczać liczbę żądań?
Aplikacje AI są głównym celem nadużyć z powodu, który nie istniał w przypadku tradycyjnych aplikacji: każde wywołanie modelu kosztuje pieniądze. Tradycyjne API REST poddane powodzi żądań zwalnia, a ostatecznie ulega awarii, ale nie czyści konta bankowego. Aplikacja LLM natomiast nadal odpowiada idealnie, podczas gdy rachunek rośnie w geometricznym tempie. Bez limitowania przepustowości (rate limiting) atakujący może w kilka minut zrujnować Twój budżet na API, uruchomić zautomatyzowane ataki typu prompt injection lub wykorzystać Twoją infrastrukturę do generowania spamu na Twój koszt.
Dwa sposoby liczenia
Okno przesuwne (sliding window) to fundamentalny mechanizm. Rejestruje on znacznik czasu każdego żądania, odrzuca te, które wypadły poza okno, i porównuje pozostałe z ustalonym limitem. Jego przewaga nad oknem stałym sprowadza się do szczegółu, który ma znaczenie w praktyce: przy oknie stałym resetującym się co minutę, atakujący może wykorzystać swój limit na końcu jednej minuty i ponownie na początku następnej, skutecznie podwajając dozwoloną przepustowość w ciągu kilku sekund. Okno przesuwne nie pozostawia takiej luki.
Co więcej, funkcja nie zwraca prostej wartości logicznej; zwraca słownik wskazujący pozostałą liczbę żądań oraz czas do resetu. Wartości te wypełniają nagłówki odpowiedzi, z których będą korzystać Twoi legalni klienci, aby samoregulować się – dobrze zaprojektowana integracja poczeka, zamiast bombardować punkt końcowy.
import time
from collections import defaultdict
class RateLimiter:
"""Sliding window rate limiter."""
def __init__(self, max_requetes: int, fenetre_secondes: int):
self.max_requetes = max_requetes
self.fenetre = fenetre_secondes
self.requetes: dict[str, list[float]] = defaultdict(list)
def autoriser(self, identifiant: str) -> tuple[bool, dict]:
"""Checks if a request is allowed for this identifier."""
maintenant = time.time()
seuil = maintenant - self.fenetre
# Clean up old requests
self.requetes[identifiant] = [
t for t in self.requetes[identifiant] if t > seuil
]
nb_requetes = len(self.requetes[identifiant])
if nb_requetes >= self.max_requetes:
prochain_slot = self.requetes[identifiant][0] + self.fenetre
return False, {
"restantes": 0,
"reset_dans": round(prochain_slot - maintenant, 1),
}
self.requetes[identifiant].append(maintenant)
return True, {
"restantes": self.max_requetes - nb_requetes - 1,
"reset_dans": round(self.fenetre - (maintenant - self.requetes[identifiant][0]), 1),
}
# Configuration by role
limiteurs = {
"gratuit": RateLimiter(max_requetes=10, fenetre_secondes=60),
"premium": RateLimiter(max_requetes=60, fenetre_secondes=60),
"api": RateLimiter(max_requetes=200, fenetre_secondes=60),
}
Samo liczenie żądań jednak nie wystarczy, ponieważ nie wszystkie żądania są równe. Dziesięć krótkich pytań kosztuje ułamek tego, co kosztuje pojedyncze żądanie accompanied by pięćdziesięciostronicowym dokumentem. Limiter oparty wyłącznie na liczbie żądań przepuściłby to drugie i zablokował pierwsze, co jest dokładnie odwrotnością tego, co dyktuje ekonomia usługi. Budżet tokenów przywraca proporcjonalność, z dziennym resetem i rejestracją rzeczywistego zużycia post factum, ponieważ szacunek dokonany przed wywołaniem nie zna długości odpowiedzi.
class TokenBudgetLimiter:
"""Limits token spending per user."""
def __init__(self, budget_tokens_jour: int, cout_par_1k_input: float, cout_par_1k_output: float):
self.budget_jour = budget_tokens_jour
self.cout_input = cout_par_1k_input
self.cout_output = cout_par_1k_output
self.usage: dict[str, dict] = defaultdict(lambda: {"tokens_in": 0, "tokens_out": 0, "date": ""})
def verifier_budget(self, user_id: str, tokens_estimes: int) -> tuple[bool, dict]:
"""Checks if the user still has budget."""
from datetime import date
aujourd_hui = str(date.today())
# Daily reset
if self.usage[user_id]["date"] != aujourd_hui:
self.usage[user_id] = {"tokens_in": 0, "tokens_out": 0, "date": aujourd_hui}
total_utilise = self.usage[user_id]["tokens_in"] + self.usage[user_id]["tokens_out"]
restant = self.budget_jour - total_utilise
if tokens_estimes > restant:
return False, {"restant": restant, "demande": tokens_estimes}
return True, {"restant": restant - tokens_estimes}
def enregistrer_usage(self, user_id: str, tokens_in: int, tokens_out: int):
"""Records actual usage after a call."""
self.usage[user_id]["tokens_in"] += tokens_in
self.usage[user_id]["tokens_out"] += tokens_out
# Example: 100K tokens/day for free users
budget = TokenBudgetLimiter(
budget_tokens_jour=100_000,
cout_par_1k_input=0.005,
cout_par_1k_output=0.015,
)
Rozpoznawanie bota
Metodyczny atakujący mieści się w Twoich limitach: musi jedynie zwolnić. Wykrycie nadużyć wymaga więc spojrzenia na kształt ruchu, a nie tylko jego objętość. Cztery poniższe sygnały dobrze się uzupełniają. Identyczne powtórzenia zdradzają skrypt utknęty w pętli. Seria żądań w ciągu kilku sekund wskazuje na tempo, którego żaden człowiek nie jest w stanie utrzymać przy klawiaturze. Wiadomość licząca dziesiątki tysięcy znaków sygnalizuje próbę ataku wolumetrycznego. Czwarty sygnał jest najbardziej interesujący: rygorystycznie identyczne długości wiadomości w ciągu dziesięciu kolejnych żądań ujawniają fuzzer zmieniający treść przy stałej strukturze, podczas gdy prawdziwy użytkownik pisze zdania o nieregularnej długości.
from dataclasses import dataclass, field
from datetime import datetime
@dataclass
class ProfilUtilisateur:
user_id: str
requetes_recentes: list[dict] = field(default_factory=list)
alertes: list[str] = field(default_factory=list)
class DetecteurAbus:
"""Detects automated abuse patterns."""
def __init__(self):
self.profils: dict[str, ProfilUtilisateur] = {}
def analyser(self, user_id: str, message: str) -> list[str]:
"""Analyzes a message to detect abuse patterns."""
if user_id not in self.profils:
self.profils[user_id] = ProfilUtilisateur(user_id=user_id)
profil = self.profils[user_id]
alertes = []
# Pattern 1: repeated identical messages
if profil.requetes_recentes:
derniers_messages = [r["message"] for r in profil.requetes_recentes[-5:]]
if derniers_messages.count(message) >= 3:
alertes.append("SPAM: identical message repeated 3+ times")
# Pattern 2: abnormal frequency
maintenant = datetime.now()
recentes = [
r for r in profil.requetes_recentes
if (maintenant - r["timestamp"]).seconds < 10
]
if len(recentes) > 5:
alertes.append("FLOOD: 5+ requests in 10 seconds")
# Pattern 3: very long messages (volumetric injection attempt)
if len(message) > 10000:
alertes.append(f"VOLUME: message of {len(message)} characters")
# Pattern 4: systematic variation (automated fuzzing)
if len(profil.requetes_recentes) >= 10:
longueurs = [len(r["message"]) for r in profil.requetes_recentes[-10:]]
if max(longueurs) - min(longueurs) < 5 and len(set(longueurs)) == 1:
alertes.append("FUZZING: identical message length (bot)")
# Record
profil.requetes_recentes.append({
"message": message,
"timestamp": maintenant,
"alertes": alertes,
})
return alertes
detecteur = DetecteurAbus()
Stopniowane sankcje
Blokowanie przy pierwszym alarmie byłoby kosztownym błędem, ponieważ żaden z tych sygnałów nie jest nieomylny: użytkownik nerwowo odświeżający stronę uruchomi detektor serii żądań, nie będąc złośliwym. Progresywne banowanie akumuluję wynik i uruchamia proporcjonalne reakcje – ostrzeżenie, następnie ograniczenie przepustowości (throttling), potem tymczasowa blokada na godzinę, a na końcu na dwadzieścia cztery godziny. Każdy poziom daje legalnemu użytkownikowi szansę na zejście z tej ścieżki, podczas gdy zautomatyzowany skrypt podąża nią aż do końca.
class GestionBannissement:
"""Progressive banning: warning, throttling, blocking."""
def __init__(self):
self.compteurs: dict[str, int] = defaultdict(int)
self.bans: dict[str, float] = {}
def signaler(self, user_id: str, severite: int = 1) -> str:
"""Reports abuse and applies the appropriate sanction."""
self.compteurs[user_id] += severite
score = self.compteurs[user_id]
if score >= 10:
self.bans[user_id] = time.time() + 86400 # Ban 24h
return "BAN_24H"
elif score >= 5:
self.bans[user_id] = time.time() + 3600 # Ban 1h
return "BAN_1H"
elif score >= 3:
return "RALENTIR" # Reduced rate limit
else:
return "AVERTIR"
def est_banni(self, user_id: str) -> bool:
"""Checks if a user is currently banned."""
if user_id in self.bans:
if time.time() < self.bans[user_id]:
return True
del self.bans[user_id]
return False
Kolejność sprawdzania ma znaczenie
Ostateczna implementacja łączy cztery mechanizmy przed wywołaniem modelu, a kolejność ta podlega prostej regule: od najmniej kosztownego do najbardziej kosztownego. Sprawdzenie bana to odwołanie do słownika, limitowanie przepustowości skanuje krótką listę, wykrywanie nadużyć analizuje historię, a kontrola budżetu następuje tuż przed płatnym wywołaniem. Odwrócenie tej sekwencji oznaczałoby płacenie za analizę behawioralną dla użytkownika, który jest już zbanowany. Ostatnim krokiem, o którym najczęściej się zapomina, jest rejestrowanie rzeczywistego zużycia z pola usage odpowiedzi, bez czego Twój budżet zacząłby odbiegać od szacunku dokonanego przed wywołaniem.
from openai import OpenAI
class APISecurisee:
"""API with integrated rate limiting and abuse detection."""
def __init__(self):
self.client = OpenAI()
self.rate_limiter = RateLimiter(max_requetes=20, fenetre_secondes=60)
self.budget = TokenBudgetLimiter(100_000, 0.005, 0.015)
self.detecteur = DetecteurAbus()
self.bans = GestionBannissement()
def traiter(self, user_id: str, message: str) -> str:
# Step 1: check ban status
if self.bans.est_banni(user_id):
return "Your access is temporarily suspended."
# Step 2: rate limiting
autorise, info = self.rate_limiter.autoriser(user_id)
if not autorise:
return f"Too many requests. Try again in {info['reset_dans']}s."
# Step 3: abuse detection
alertes = self.detecteur.analyser(user_id, message)
if alertes:
action = self.bans.signaler(user_id, severite=len(alertes))
if action.startswith("BAN"):
return "Abusive behavior detected. Access suspended."
# Step 4: check token budget
tokens_estimes = len(message) // 4 + 500
ok, budget_info = self.budget.verifier_budget(user_id, tokens_estimes)
if not ok:
return "Daily token budget exhausted."
# Step 5: call the model
response = self.client.chat.completions.create(
model="gpt-5.6-sol",
messages=[{"role": "user", "content": message}],
)
# Record actual usage
usage = response.usage
self.budget.enregistrer_usage(user_id, usage.prompt_tokens, usage.completion_tokens)
return response.choices[0].message.content
Kluczowe wnioski
- Limitowanie przepustowości chroni Twój budżet API i zapobiega zautomatyzowanym atakom
- Łącz limity na liczbę żądań (okno przesuwne) i limity na koszt (tokeny)
- Wykrywanie nadużyć identyfikuje wzorce: spam, flood, fuzzing, wolumen
- Progresywne banowanie (ostrzeż, ogranicz, zablokuj) unika trwałych fałszywych pozytywów
- Każda odpowiedź powinna zawierać nagłówki limitu przepustowości, aby informować użytkownika