Ir al contenido principal
Español— Elegir un idioma
Menú

Limitación de peticiones y prevención de abusos

Lección 8 de 14 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. ¿Por qué limitar las peticiones?
  2. Dos formas de contar
  3. Identificar un bot
  4. Sanciones escalonadas
  5. El orden de las comprobaciones importa
  6. Puntos clave

¿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