Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Limitação de taxa e prevenção de abusos

Aula 8 de 14 Atualizada a 28 de julho de 2026 Avancado
Nesta página
  1. Por que limitar pedidos?
  2. Duas formas de contar
  3. Reconhecer um bot
  4. Sanções escalonadas
  5. A ordem das verificações importa
  6. Pontos-chave

Por que limitar pedidos?

As aplicações de IA são alvos privilegiados de abuso por uma razão que não existia nas aplicações tradicionais: cada chamada ao modelo custa dinheiro. Uma API REST tradicional sujeita a uma inundação de pedidos desacelera e eventualmente colapsa, mas não esvazia uma conta bancária. Uma aplicação LLM, no entanto, continua a responder perfeitamente enquanto a fatura dispara. Sem limitação de taxa, um atacante pode arruinar o seu orçamento de API em minutos, lançar ataques automatizados de injeção de prompts ou usar a sua infraestrutura para gerar spam à sua custa.

Duas formas de contar

A janela deslizante é o mecanismo fundamental. Regista o carimbo de data/hora de cada pedido, descarta os que saíram da janela e compara o remanescente com o teto. A sua superioridade face à janela fixa resume-se a um detalhe importante na prática: com uma janela fixa que reinicia a cada minuto, um atacante pode colocar a sua quota no final de um minuto e novamente no início do seguinte, efetivamente duplicando a taxa de transferência permitida ao longo de alguns segundos. A janela deslizante não deixa essa brecha.

Além disso, a função não devolve um simples booleano; devolve um dicionário que indica os pedidos restantes e o tempo até ao reinício. Estes valores preenchem os cabeçalhos da resposta que os seus clientes legítimos usarão para se autorregularem — uma integração bem desenhada espera em vez de bombardear o endpoint.

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),
}

Contar pedidos não é suficiente, pois nem todos os pedidos são iguais. Dez perguntas curtas custam uma fração do que custa um único pedido acompanhado de um documento de cinquenta páginas. Um limitador por pedido deixaria passar este último e bloquearia os primeiros, o que é exatamente o oposto do que dita a economia do serviço. Um orçamento de tokens restabelece a proporcionalidade, com reinício diário e registo do uso real após o facto, uma vez que a estimativa feita antes da chamada não conhece o comprimento da resposta.

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,
)

Reconhecer um bot

Um atacante metódico mantém-se abaixo dos seus tetos: basta-lhe abrandar. Detetar abusos exige, portanto, olhar para a forma do tráfego e não para o seu volume. Os quatro sinais implementados abaixo complementam-se bem. A repetição idêntica denuncia um script preso num ciclo. Uma explosão de pedidos em poucos segundos indica um ritmo que nenhum humano consegue manter ao teclado. Uma mensagem com dezenas de milhares de caracteres sinaliza uma tentativa de injeção volumétrica. O quarto é o mais interessante: comprimentos de mensagem rigorosamente idênticos ao longo de dez pedidos consecutivos revelam um fuzzer a variar o conteúdo com estrutura constante, enquanto um utilizador real escreve frases de comprimentos 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:
    """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()

Sanções escalonadas

Banir ao primeiro alerta seria um erro dispendioso, porque nenhum destes sinais é infalível: um utilizador que atualiza nervosamente uma página aciona o detetor de explosão sem ser malicioso. O banimento progressivo acumula uma pontuação e aciona respostas proporcionais — um aviso, depois estrangulamento, depois um bloqueio temporário de uma hora e, finalmente, vinte e quatro horas. Cada nível dá ao utilizador legítimo a hipótese de sair da trajetória, enquanto o script automatizado a segue até ao fim.

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

A ordem das verificações importa

A montagem final encadeia os quatro mecanismos antes de chamar o modelo, e esta ordem obedece a uma regra simples: do menos dispendioso para o mais dispendioso. A verificação de banimento é uma pesquisa num dicionário, a limitação de taxa varre uma lista curta, a deteção de abusos analisa o histórico e o controlo de orçamento vem imediatamente antes da chamada faturada. Inverter esta sequência significaria pagar pela análise comportamental de um utilizador que já está banido. O último passo é o mais frequentemente esquecido: registar o uso real a partir do campo usage da resposta, sem o qual o seu orçamento se desviaria da estimativa feita antes da chamada.

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

Pontos-chave

  • A limitação de taxa protege o seu orçamento de API e previne ataques automatizados
  • Combine limites por pedido (janela deslizante) e limites por custo (tokens)
  • A deteção de abusos identifica padrões: spam, inundação, fuzzing, volume
  • O banimento progressivo (avisar, estrangular, bloquear) evita falsos positivos permanentes
  • Cada resposta deve incluir cabeçalhos de limitação de taxa para informar o utilizador