Limitación de peticiones y prevención de abusos
En esta página
¿Por qué limitar las peticiones?
Las aplicaciones de IA son objetivos prioritarios para el abuso por una razón que no existía en las aplicaciones tradicionales: cada llamada al modelo cuesta dinero. Una API REST tradicional sometida a una avalancha de peticiones se ralentiza y finalmente se cae, pero no vacía una cuenta bancaria. Una aplicación de LLM, sin embargo, sigue respondiendo perfectamente mientras la factura se dispara. Sin limitación de tasa, un atacante puede arruinar tu presupuesto de API en minutos, lanzar ataques automatizados de inyección de instrucciones o usar tu infraestructura para generar spam a tu costa.
Dos formas de contar
La ventana deslizante es el mecanismo fundamental. Registra la marca de tiempo de cada petición, descarta las que han salido de la ventana y compara el resto con el límite máximo. Su superioridad frente a la ventana fija se reduce a un detalle que importa en la práctica: con una ventana fija que se reinicia cada minuto, un atacante puede colocar su cuota al final de un minuto y de nuevo al inicio del siguiente, duplicando efectivamente el rendimiento permitido en unos pocos segundos. La ventana deslizante no deja tal resquicio.
Además, la función no devuelve un simple booleano; devuelve un diccionario que indica las peticiones restantes y el tiempo hasta el reinicio. Estos valores rellenan las cabeceras de respuesta que tus clientes legítimos utilizarán para autorregularse: una integración bien diseñada espera en lugar de machacar el punto de acceso.
import time
from collections import defaultdict
class RateLimiter:
"""Limitador de tasa de ventana deslizante."""
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]:
"""Comprueba si se permite una petición para este identificador."""
maintenant = time.time()
seuil = maintenant - self.fenetre
# Limpiar peticiones antiguas
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),
}
# Configuración por rol
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),
}
Sin embargo, contar peticiones no es suficiente, porque no todas las peticiones son iguales. Diez preguntas cortas cuestan una fracción de lo que cuesta una única petición acompañada de un documento de cincuenta páginas. Un limitador por petición dejaría pasar esta última y bloquearía las primeras, lo cual es exactamente lo contrario de lo que dicta la economía del servicio. Un presupuesto de tokens restablece la proporcionalidad, con un reinicio diario y un registro del uso real a posteriori, ya que la estimación hecha antes de la llamada no conoce la longitud de la respuesta.
class TokenBudgetLimiter:
"""Limita el gasto de tokens por usuario."""
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]:
"""Comprueba si el usuario aún tiene presupuesto."""
from datetime import date
aujourd_hui = str(date.today())
# Reinicio diario
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):
"""Registra el uso real tras una llamada."""
self.usage[user_id]["tokens_in"] += tokens_in
self.usage[user_id]["tokens_out"] += tokens_out
# Ejemplo: 100K tokens/día para usuarios gratuitos
budget = TokenBudgetLimiter(
budget_tokens_jour=100_000,
cout_par_1k_input=0.005,
cout_par_1k_output=0.015,
)
Identificar un bot
Un atacante metódico se mantiene por debajo de tus techos: solo necesita ir más despacio. Detectar el abuso requiere, por tanto, observar la forma del tráfico en lugar de su volumen. Las cuatro señales implementadas a continuación se complementan bien entre sí. La repetición idéntica delata un script atascado en un bucle. Una ráfaga de peticiones en pocos segundos indica un ritmo que ningún humano puede mantener al teclado. Un mensaje de decenas de miles de caracteres señala un intento de inyección volumétrica. La cuarta es la más interesante: longitudes de mensaje rigurosamente idénticas durante diez peticiones consecutivas revelan un fuzzer que varía el contenido con una estructura constante, mientras que un usuario real escribe frases de longitudes irregulares.
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:
"""Detecta patrones de abuso automatizado."""
def __init__(self):
self.profils: dict[str, ProfilUtilisateur] = {}
def analyser(self, user_id: str, message: str) -> list[str]:
"""Analiza un mensaje para detectar patrones de abuso."""
if user_id not in self.profils:
self.profils[user_id] = ProfilUtilisateur(user_id=user_id)
profil = self.profils[user_id]
alertes = []
# Patrón 1: mensajes idénticos repetidos
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")
# Patrón 2: frecuencia anormal
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")
# Patrón 3: mensajes muy largos (intento de inyección volumétrica)
if len(message) > 10000:
alertes.append(f"VOLUME: message of {len(message)} characters")
# Patrón 4: variación sistemática (fuzzing automatizado)
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)")
# Registrar
profil.requetes_recentes.append({
"message": message,
"timestamp": maintenant,
"alertes": alertes,
})
return alertes
detecteur = DetecteurAbus()
Sanciones escalonadas
Prohibir el acceso ante la primera alerta sería un error costoso, porque ninguna de estas señales es infalible: un usuario que actualiza nerviosamente una página activa el detector de ráfagas sin ser malicioso. La prohibición progresiva acumula una puntuación y activa respuestas proporcionales: una advertencia, luego una limitación de velocidad, después un bloqueo temporal de una hora y finalmente de veinticuatro horas. Cada nivel da al usuario legítimo la oportunidad de salir de esa trayectoria, mientras que el script automatizado la sigue hasta el final.
class GestionBannissement:
"""Prohibición progresiva: advertencia, limitación, bloqueo."""
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:
"""Notifica el abuso y aplica la sanción adecuada."""
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" # Límite de tasa reducido
else:
return "AVERTIR"
def est_banni(self, user_id: str) -> bool:
"""Comprueba si un usuario está prohibido actualmente."""
if user_id in self.bans:
if time.time() < self.bans[user_id]:
return True
del self.bans[user_id]
return False
El orden de las comprobaciones importa
El ensamblaje final encadena los cuatro mecanismos antes de llamar al modelo, y este orden obedece a una regla simple: de lo menos costoso a lo más costoso. La comprobación de prohibición es una búsqueda en diccionario, la limitación de tasa escanea una lista corta, la detección de abusos analiza el historial y el control de presupuesto llega justo antes de la llamada facturada. Invertir esta secuencia implicaría pagar por el análisis de comportamiento de un usuario que ya está prohibido. El último paso es el que se olvida con más frecuencia: registrar el uso real a partir del campo usage de la respuesta, sin lo cual tu presupuesto se desviaría de la estimación hecha antes de la llamada.
from openai import OpenAI
class APISecurisee:
"""API con limitación de tasa y detección de abusos integradas."""
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:
# Paso 1: comprobar estado de prohibición
if self.bans.est_banni(user_id):
return "Your access is temporarily suspended."
# Paso 2: limitación de tasa
autorise, info = self.rate_limiter.autoriser(user_id)
if not autorise:
return f"Too many requests. Try again in {info['reset_dans']}s."
# Paso 3: detección de abusos
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."
# Paso 4: comprobar presupuesto de tokens
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."
# Paso 5: llamar al modelo
response = self.client.chat.completions.create(
model="gpt-5.6-sol",
messages=[{"role": "user", "content": message}],
)
# Registrar uso real
usage = response.usage
self.budget.enregistrer_usage(user_id, usage.prompt_tokens, usage.completion_tokens)
return response.choices[0].message.content
Puntos clave
- La limitación de tasa protege tu presupuesto de API y previene ataques automatizados
- Combina límites por petición (ventana deslizante) y límites por coste (tokens)
- La detección de abusos identifica patrones: spam, inundación, fuzzing, volumen
- La prohibición progresiva (advertir, limitar, bloquear) evita falsos positivos permanentes
- Cada respuesta debe incluir cabeceras de límite de tasa para informar al usuario