Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Nopeusrajoitus ja väärinkäytösten ehkäisy

Oppitunti 8 / 14 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Miksi pyyntöjä pitää rajoittaa?
  2. Kaksi tapaa laskea
  3. Botin tunnistaminen
  4. Portaittainen sanktiointi
  5. Tarkistusten järjestyksellä on väliä
  6. Keskeiset asiat

Miksi pyyntöjä pitää rajoittaa?

Tekoälysovellukset ovat ensisijaisia väärinkäytösten kohteita syystä, jota perinteisissä sovelluksissa ei ollut: jokainen mallikutsu maksaa rahaa. Perinteinen REST-API hidastuu tulvapyynnöissä ja kaatuu lopulta, mutta se ei tyhjennä pankkitiliäsi. LLM-sovellus sen sijaan vastaa moitteettomasti samalla kun lasku kasvaa räjähdysmäisesti. Ilman nopeusrajoitusta hyökkääjä voi tuhota API-budjettisi minuuteissa, käynnistää automatisoituja kehotteiden injektiohyökkäyksiä tai käyttää infrastruktuuriasi roskapostin tuottamiseen kustannuksellasi.

Kaksi tapaa laskea

Liukuva ikkuna on perusmekanismi. Se tallentaa kunkin pyynnön aikaleiman, hylkää ikkunasta pudonneet ja vertaa jäljellä olevia kattoon. Sen ylivoima kiinteään ikkunaan nähden perustuu käytännössä tärkeään yksityiskohtaan: kiinteässä ikkunassa, joka nollautuu minuutin välein, hyökkääjä voi sijoittaa kiintiönsä yhden minuutin loppuun ja uudelleen seuraavan alkuun, mikä kaksinkertaistaa sallitun läpimenon muutamassa sekunnissa. Liukuva ikkuna ei jätä tällaista aukkoa.

Lisäksi funktio ei palauta pelkkää totuusarvoa; se palauttaa sanakirjan, joka ilmoittaa jäljellä olevat pyynnöt ja ajan nollautumiseen. Nämä arvot täyttävät vastausotsikot, joita lailliset asiakkaasi käyttävät itsesäätelyyn – hyvin suunniteltu integraatio odottaa sen sijaan, että hakkerointisi päätepistettä.

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

Pelkkä pyyntöjen laskeminen ei kuitenkaan riitä, sillä kaikki pyynnöt eivät ole samanarvoisia. Kymmenen lyhyttä kysymystä maksaa murto-osan siitä, mitä maksaa yksi pyyntö, jonka mukana on viisikymmensivuinen asiakirja. Pyyntökohtainen rajoitin päästäisi jälkimmäisen läpi ja estäisi edellisen, mikä on täysin vastoin palvelun taloutta. Token-budjetti palauttaa suhteellisuuden päivittäisellä nollauksella ja todellisen käytön kirjaamisella jälkikäteen, sillä ennen kutsua tehty arvio ei tiedä vastauksen pituutta.

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

Botin tunnistaminen

Metodinen hyökkääjä pysyy kattojesi alapuolella: hänen tarvitsee vain hidastaa vauhtia. Väärinkäytösten havaitseminen vaatii siksi liikenteen muodon tarkastelua sen tilavuuden sijaan. Alla toteutetut neljä signaalia täydentävät toisiaan hyvin. Identtinen toisto paljastaa silmukkaan juuttuneen skriptin. Pyyntöjen ryöpsähdys muutamassa sekunnissa kertoo tahdista, jota mikään ihminen ei pysty ylläpitämään näppäimistöllä. Kymmenien tuhansien merkkien mittainen viesti signaloi tilavuushyökkäystä. Neljäs on mielenkiintoisin: täysin identtiset viestinpituudet kymmenen peräkkäisen pyynnön aikana paljastavat fuzzerin, joka vaihtelee sisältöä vakiorakenteella, kun taas todellinen käyttäjä kirjoittaa epäsäännöllisen pituisia lauseita.

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

Portaittainen sanktiointi

Bannaaminen ensimmäisestä hälytyksestä olisi kallis virhe, sillä mikään näistä signaaleista ei ole erehtymätön: hermostuneesti sivua päivittävä käyttäjä laukaisee ryöpsähdysilmaisimen olematta pahantahtoinen. Progressiivinen bannaaminen kerryttää pistemäärää ja laukaisee suhteutetut vasteet – varoitus, sitten kuristus, sitten väliaikainen tunnin esto ja lopulta kaksikymmentäneljä tuntia. Jokainen taso antaa lailliselle käyttäjälle mahdollisuuden poistua radalta, kun taas automatisoitu skripti seuraa sitä loppuun asti.

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

Tarkistusten järjestyksellä on väliä

Lopullinen kokoonpano ketjuttaa neljä mekanismia ennen mallin kutsumista, ja tämä järjestys noudattaa yksinkertaista sääntöä: halvimmasta kalleimpaan. Ban-tarkistus on sanakirjahaku, nopeusrajoitus skannaa lyhyen listan, väärinkäytösten havaitseminen analysoi historiaa ja budjetin valvonta tulee juuri ennen laskutettavaa kutsua. Tämän sekvenssin kääntäminen tarkoittaisi, että maksaisit käyttäytymisanalyysistä käyttäjälle, joka on jo bannattu. Viimeinen vaihe on se, joka unohdetaan useimmiten: todellisen käytön kirjaaminen vastauksen usage-kentästä, ilman jota budjettisi ajautuisi pois ennen kutsua tehdystä arviosta.

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

Keskeiset asiat

  • Nopeusrajoitus suojaa API-budjettiasi ja estää automatisoidut hyökkäykset
  • Yhdistä pyyntökohtaiset rajat (liukuva ikkuna) ja kustannuskohtaiset rajat (tokenit)
  • Väärinkäytösten havaitseminen tunnistaa kuviot: roskaposti, tulva, fuzzing, tilavuus
  • Progressiivinen bannaaminen (varoita, kurista, estä) välttää pysyvät väärät hälytykset
  • Jokaisen vastauksen tulisi sisältää nopeusrajoitusotsikot käyttäjän informoimiseksi