Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Ograničavanje brzine i sprječavanje zlouporabe

Lekcija 8 od 14 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Zašto ograničiti zahtjeve?
  2. Dva načina brojanja
  3. Prepoznavanje bota
  4. Hijerarhijske sankcije
  5. Redoslijed provjera je bitan
  6. Ključne točke

Zašto ograničiti zahtjeve?

AI aplikacije su primarne mete zlouporabe iz razloga koji nije postojao kod tradicionalnih aplikacija: svaki poziv modelu košta novca. Tradicionalni REST API pod udarom poplave zahtjeva usporava i na kraju se ruši, ali ne ispražnjuje bankovni račun. LLM aplikacija, s druge strane, nastavlja savršeno odgovarati dok račun eksplodira. Bez ograničavanja brzine, napadač može uništiti tvoj proračun za API u nekoliko minuta, pokrenuti automatizirane napade ubrizgavanja promptova ili iskoristiti tvoju infrastrukturu za generiranje spama o tvom trošku.

Dva načina brojanja

Klizni prozor temeljni je mehanizam. On bilježi vremensku oznaku svakog zahtjeva, odbacuje one koji su ispali iz prozora i uspoređuje preostale s gornjom granicom. Njegova superiornost nad fiksnim prozorom svodi se na detalj koji je bitan u praksi: kod fiksnog prozora koji se resetira svake minute, napadač može iskoristiti svoju kvotu na kraju jedne minute i ponovno na početku sljedeće, čime efektivno udvostručuje dopušteni propusni tok u nekoliko sekundi. Klizni prozor ne ostavlja takav otvor.

Štoviše, funkcija ne vraća jednostavnu boolean vrijednost; vraća rječnik koji označava preostale zahtjeve i vrijeme do resetiranja. Te vrijednosti popunjavaju zaglavlja odgovora koja će tvoji legitimni klijenti koristiti za samoregulaciju – dobro dizajnirana integracija čeka umjesto da bombardira krajnju točku.

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 brojanje zahtjeva nije dovoljno jer nisu svi zahtjevi jednaki. Deset kratkih pitanja košta djelić onoga što košta jedan zahtjev popraćen dokumentom od pedeset stranica. Ograničivač po zahtjevu propustio bi potonje, a blokirao prve, što je točno suprotno od onoga što diktira ekonomija usluge. Proračun tokena vraća proporcionalnost, s dnevnim resetiranjem i bilježenjem stvarne potrošnje nakon činjenice, jer procjena napravljena prije poziva ne zna duljinu odgovora.

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

Prepoznavanje bota

Metodičan napadač ostaje ispod tvojih stropova: samo se treba usporiti. Otkrivanje zlouporabe stoga zahtijeva promatranje oblika prometa, a ne njegovog volumena. Četiri signala implementirana u nastavku dobro se nadopunjuju. Identično ponavljanje odaje skriptu zaglavljenu u petlji. Prasak zahtjeva unutar nekoliko sekundi ukazuje na tempo koji nijedan čovjek ne može održati na tipkovnici. Poruka duga desetke tisuća znakova signalizira pokušaj volumetrijskog ubrizgavanja. Četvrti je najzanimljiviji: rigorozno identične duljine poruka tijekom deset uzastopnih zahtjeva otkrivaju fuzzer koji varira sadržaj uz konstantnu strukturu, dok stvarni korisnik piše rečenice nepravilnih duljina.

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

Hijerarhijske sankcije

Blokiranje pri prvoj uzbuni bila bi skupa pogreška jer nijedan od ovih signala nije nepogrešiv: korisnik koji nervozno osvježava stranicu okida detektor praska, a da nije zlonamjeran. Progresivno blokiranje akumulira bodove i pokreće proporcionalne odgovore – upozorenje, zatim usporavanje, potom privremena blokada od sat vremena i na kraju dvadeset četiri sata. Svaka razina daje legitimnom korisniku priliku da siđe s tog puta, dok automatizirana skripta slijedi put do kraja.

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

Redoslijed provjera je bitan

Konačna sastavnica povezuje četiri mehanizma prije poziva modelu, a ovaj redoslijed poštuje jednostavno pravilo: od najjeftinijeg prema najskupljem. Provjera blokade je pretraživanje rječnika, ograničavanje brzine skenira kratki popis, otkrivanje zlouporabe analizira povijest, a kontrola proračuna dolazi neposredno prije naplaćenog poziva. Obrtanje ovog slijeda značilo bi plaćanje bihevioralne analize za korisnika koji je već blokiran. Posljednji korak je onaj koji se najčešće zaboravlja: bilježenje stvarne potrošnje iz polja usage odgovora, bez čega bi tvoj proračun odstupao od procjene napravljene prije poziva.

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

Ključne točke

  • Ograničavanje brzine štiti tvoj proračun za API i sprječava automatizirane napade
  • Kombiniraj ograničenja po zahtjevu (klizni prozor) i ograničenja po trošku (tokeni)
  • Otkrivanje zlouporabe identificira obrasce: spam, poplava, fuzzing, volumen
  • Progresivno blokiranje (upozori, uspori, blokiraj) izbjegava trajne lažno pozitivne rezultate
  • Svaki odgovor treba uključivati zaglavlja s ograničenjem brzine kako bi se informirao korisnik