Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Begränsning av förfrågningar och skydd mot missbruk

Lektion 8 av 14 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Varför begränsa förfrågningar?
  2. Två sätt att räkna
  3. Att känna igen en bot
  4. Trappvisa sanktioner
  5. Ordningen på kontrollerna spelar roll
  6. Viktiga punkter

Varför begränsa förfrågningar?

AI-applikationer är primära mål för missbruk av en anledning som inte fanns hos traditionella appar: varje modellanrop kostar pengar. Ett traditionellt REST-API som utsätts för en flod av förfrågningar blir långsamt och kraschar så småningom, men det tömmer inget bankkonto. En LLM-applikation fortsätter däremot att svara perfekt medan fakturan skenar. Utan begränsning av förfrågningsfrekvens kan en angripare förstöra din API-budget på några minuter, lansera automatiserade prompt injection-attacker eller använda din infrastruktur för att generera spam på din bekostnad.

Två sätt att räkna

Det glidande fönstret är den grundläggande mekanismen. Det registrerar tidsstämpeln för varje förfrågan, kasserar de som har fallit utanför fönstret och jämför resten mot taket. Dess överlägsenhet jämfört med det fasta fönstret handlar om en detalj som är viktig i praktiken: med ett fast fönster som återställs varje minut kan en angripare placera sin kvot i slutet av en minut och igen i början av nästa, vilket effektivt fördubblar den tillåtna genomströmningen över några sekunder. Det glidande fönstret lämnar inget sådant utrymme.

Dessutom returnerar funktionen inte en enkel boolean; den returnerar en ordbok som anger återstående förfrågningar och tiden tills återställning. Dessa värden fyller svarsheaderna som dina legitima klienter använder för att självreglera – en väl designad integration väntar istället för att hamra på slutpunkten.

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

Att räkna förfrågningar räcker dock inte, eftersom alla förfrågningar inte är lika värda. Tio korta frågor kostar en bråkdel av vad en enda förfrågan åtföljd av ett femtio sidor långt dokument kostar. En begränsare per förfrågan skulle släppa igenom den senare och blockera den förra, vilket är exakt motsatsen till vad tjänstens ekonomi dikterar. En token-budget återställer proportionaliteten, med en daglig återställning och registrering av faktisk användning i efterhand, eftersom uppskattningen som görs före anropet inte känner till längden på svaret.

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

Att känna igen en bot

En metodisk angripare håller sig under dina tak: de behöver bara sakta ner. Att upptäcka missbruk kräver därför att man tittar på trafikens form snarare än dess volym. De fyra signalerna som implementeras nedan kompletterar varandra väl. Identisk upprepning avslöjar ett skript som fastnat i en loop. En burst av förfrågningar inom några sekunder indikerar en takt som ingen människa kan hålla vid tangentbordet. Ett meddelande på tiotusentals tecken signalerar ett försök till volumetrisk injection. Den fjärde är den mest intressanta: strikt identiska meddelandelängder över tio på varandra följande förfrågningar avslöjar en fuzzare som varierar innehåll med konstant struktur, medan en riktig användare skriver meningar av oregelbundna längder.

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

Trappvisa sanktioner

Att bannlysa vid första varningen skulle vara ett dyrt misstag, eftersom ingen av dessa signaler är ofelbar: en användare som nervöst uppdaterar en sida utlöser burst-detektorn utan att vara illvillig. Progressiv bannlysning ackumulerar en poäng och utlöser proportionerliga svar – en varning, sedan strypning, sedan ett tillfälligt block på en timme och slutligen tjugofyra timmar. Varje nivå ger den legitima användaren en chans att komma ur spåret, medan det automatiserade skriptet följer det ända till slutet.

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

Ordningen på kontrollerna spelar roll

Den slutgiltiga sammansättningen kedjar de fyra mekanismerna innan modellen anropas, och denna ordning lyder en enkel regel: från minst kostsam till mest kostsam. Kontrollen av bannlysning är en uppslagsoperation i en ordbok, begränsning av förfrågningsfrekvens skannar en kort lista, detektering av missbruk analyserar historik och budgetkontroll kommer precis före det fakturerade anropet. Att vända på denna sekvens skulle innebära att man betalar för beteendeanalys för en användare som redan är bannlyst. Det sista steget är det som oftast glöms: att registrera faktisk användning från fältet usage i svaret, utan vilket din budget skulle driva iväg från uppskattningen som gjordes före anropet.

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

Viktiga punkter

  • Begränsning av förfrågningsfrekvens skyddar din API-budget och förhindrar automatiserade attacker
  • Kombinera gränser per förfrågan (glidande fönster) och gränser per kostnad (tokens)
  • Detektering av missbruk identifierar mönster: spam, flood, fuzzing, volym
  • Progressiv bannlysning (varna, stryp, blockera) undviker permanenta falska positiva träffar
  • Varje svar bör inkludera headrar för begränsning av förfrågningsfrekvens för att informera användaren