Wann sollten Sie die Drosselung in Ihren Code implementieren?

Für große Projekte ist es normalerweise am besten, Tools wie Cloudflare Rate Limiting oder HAProxy zu verwenden. Diese sind leistungsstark, zuverlässig und nehmen Ihnen das schwere Heben ab.

Aber für kleinere Projekte – oder wenn Sie lernen möchten, wie die Dinge funktionieren – können Sie Ihren eigenen Ratenbegrenzer direkt in Ihrem Code erstellen. Warum?

• Es ist ganz einfach: Sie erstellen etwas Einfaches, das leicht zu verstehen ist.
• Es ist budgetfreundlich: Keine zusätzlichen Kosten außer dem Hosten Ihres Servers.
• Es funktioniert für kleine Projekte: Solange der Datenverkehr gering ist, bleiben die Dinge schnell und effizient.
• Es ist wiederverwendbar: Sie können es in andere Projekte kopieren, ohne neue Tools oder Dienste einzurichten.

Was Sie lernen werden

Am Ende dieser Anleitung wissen Sie, wie Sie einen einfachen Throttler in TypeScript erstellen, um Ihre APIs vor einer Überlastung zu schützen. Folgendes werden wir behandeln:

• Konfigurierbare Zeitlimits: Jeder blockierte Versuch erhöht die Sperrdauer, um Missbrauch zu verhindern.
• Anfrageobergrenzen: Legen Sie eine maximale Anzahl zulässiger Anfragen fest. Dies ist besonders nützlich für APIs, die kostenpflichtige Dienste beinhalten, wie OpenAI.
• In-Memory Storage: Eine einfache Lösung, die ohne externe Tools wie Redis funktioniert – ideal für kleine Projekte oder Prototypen.
• Pro-Benutzer-Limits: Verfolgen Sie Anfragen pro Benutzer anhand seiner IPv4-Adresse. Wir werden SvelteKit nutzen, um die Client-IP mit seiner integrierten Methode einfach abzurufen.

Dieser Leitfaden ist als praktischer Ausgangspunkt konzipiert und eignet sich perfekt für Entwickler, die die Grundlagen ohne unnötige Komplexität erlernen möchten. Aber es ist noch nicht produktionsbereit.

Bevor ich anfange, möchte ich Lucias Abschnitt „Ratenbegrenzung“ gebührend erwähnen.

Throttler-Implementierung

Lassen Sie uns die Throttler-Klasse definieren:

export class Throttler {
    private storage = new Map();

    constructor(private timeoutSeconds: number[]) {}
}

Der Throttler-Konstruktor akzeptiert eine Liste von Timeout-Dauern (timeoutSeconds). Jedes Mal, wenn ein Benutzer blockiert wird, erhöht sich die Dauer basierend auf dieser Liste schrittweise. Wenn das endgültige Zeitlimit erreicht ist, könnten Sie schließlich sogar einen Rückruf auslösen, um die IP des Benutzers dauerhaft zu sperren – obwohl dies den Rahmen dieser Anleitung sprengt.

Hier ist ein Beispiel für die Erstellung einer Drosselungsinstanz, die Benutzer für längere Zeiträume blockiert:

const throttler = new Throttler([1, 2, 4, 8, 16]);

Diese Instanz blockiert Benutzer beim ersten Mal für eine Sekunde. Das zweite Mal zu zweit und so weiter.

Wir verwenden eine Karte, um IP-Adressen und die entsprechenden Daten zu speichern. Eine Karte ist ideal, da sie häufige Hinzufügungen und Löschungen effizient verarbeitet.

Profi-Tipp: Verwenden Sie eine Karte für dynamische Daten, die sich häufig ändern. Für statische, unveränderliche Daten ist ein Objekt besser. (Kaninchenloch ¹)

Wenn Ihr Endpunkt eine Anfrage erhält, extrahiert er die IP-Adresse des Benutzers und konsultiert den Throttler, um zu bestimmen, ob die Anfrage zugelassen werden soll.

Wie es funktioniert

• Fall A: Neuer oder inaktiver Benutzer
  
  Wenn die IP im Throttler nicht gefunden wird, handelt es sich entweder um die erste Anfrage des Benutzers oder er war lange genug inaktiv. In diesem Fall:

  • Aktion zulassen.
  • Verfolgen Sie den Benutzer, indem Sie seine IP mit einem anfänglichen Timeout speichern.

• Fall B: Aktiver Benutzer
  
  Wenn die IP gefunden wird, bedeutet dies, dass der Benutzer bereits frühere Anfragen gestellt hat. Hier:

  • Überprüfen Sie, ob die erforderliche Wartezeit (basierend auf dem timeoutSeconds-Array) seit dem letzten Block vergangen ist.
  • Wenn genügend Zeit vergangen ist:
  • Zeitstempel aktualisieren.
  • Erhöhen Sie den Timeout-Index (begrenzt auf den letzten Index, um einen Überlauf zu verhindern).
  • Wenn nicht, lehnen Sie die Anfrage ab.

Im letzteren Fall müssen wir prüfen, ob seit dem letzten Block genügend Zeit vergangen ist. Dank eines Index wissen wir, auf welche der timeoutSeconds wir uns beziehen sollten. Wenn nicht, springen Sie einfach zurück. Andernfalls aktualisieren Sie den Zeitstempel.

export class Throttler {
    // ...

    public consume(key: string): boolean {
        const counter = this.storage.get(key) ?? null;
        const now = Date.now();

        // Case A
        if (counter === null) {
            // At next request, will be found.
            // The index 0 of [1, 2, 4, 8, 16] returns 1.
            // That's the amount of seconds it will have to wait.
            this.storage.set(key, {
                index: 0,
                updatedAt: now
            });
            return true; // allowed
        }

        // Case B
        const timeoutMs = this.timeoutSeconds[counter.index] * 1000;
        const allowed = now - counter.updatedAt >= timeoutMs;
        if (!allowed) {
            return false; // denied
        }

        // Allow the call, but increment timeout for following requests.
        counter.updatedAt = now;
        counter.index = Math.min(counter.index   1, this.timeoutSeconds.length - 1);
        this.storage.set(key, counter);

        return true; // allowed
    }
}

Beim Aktualisieren des Index wird auf den letzten Index von timeoutSeconds begrenzt. Ohne ihn würde counter.index 1 überlaufen und der nächste Zugriff auf this.timeoutSeconds[counter.index] würde zu einem Laufzeitfehler führen.

Beispiel für einen Endpunkt

Dieses Beispiel zeigt, wie Sie mit dem Throttler begrenzen, wie oft ein Benutzer Ihre API aufrufen kann. Wenn der Benutzer zu viele Anfragen stellt, erhält er eine Fehlermeldung, anstatt die Hauptlogik auszuführen.

const throttler = new Throttler([1, 2, 4, 8, 16, 30, 60, 300]);

export async function GET({ getClientAddress }) {
    const IP = getClientAddress();

    if (!throttler.consume(IP)) {
        throw error(429, { message: 'Too Many Requests' });
    }

    // Read from DB, call OpenAI - do the thing.

    return new Response(null, { status: 200 });
}

Hinweis zur Authentifizierung

Bei der Verwendung von Ratenbegrenzung mit Anmeldesystemen kann dieses Problem auftreten:

1. Ein Benutzer meldet sich an und veranlasst den Throttler, seiner IP eine Zeitüberschreitung zuzuordnen.
2. Der Benutzer meldet sich ab oder seine Sitzung endet (z. B. meldet er sich sofort ab, das Cookie läuft mit der Sitzung ab und der Browser stürzt ab usw.).
3. Wenn sie kurz darauf erneut versuchen, sich anzumelden, blockiert der Throttler sie möglicherweise immer noch und gibt den Fehler 429 Too Many Requests zurück.

Um dies zu verhindern, verwenden Sie zur Ratenbegrenzung die eindeutige Benutzer-ID des Benutzers anstelle seiner IP. Außerdem müssen Sie den Throttler-Status nach einer erfolgreichen Anmeldung zurücksetzen, um unnötige Blockaden zu vermeiden.

Fügen Sie der Throttler-Klasse eine Reset-Methode hinzu:

export class Throttler {
    // ...

    public reset(key: string): void {
        this.storage.delete(key);
    }
}

Und verwenden Sie es nach einer erfolgreichen Anmeldung:

const user = db.get(email);

if (!throttler.consume(user.ID)) {
    throw error(429);
}

const validPassword = verifyPassword(user.password, providedPassword);
if (!validPassword) {
    throw error(401);
}

throttler.reset(user.id); // Clear throttling for the user

Verwalten veralteter IP-Datensätze mit regelmäßiger Bereinigung

Während Ihr Throttler IPs und Ratenlimits verfolgt, ist es wichtig, darüber nachzudenken, wie und wann IP-Einträge entfernt werden, die nicht mehr benötigt werden. Ohne einen Bereinigungsmechanismus speichert Ihr Drosselgerät weiterhin Datensätze im Speicher, was im Laufe der Zeit möglicherweise zu Leistungsproblemen führen kann, wenn die Daten wachsen.

Um dies zu verhindern, können Sie eine Bereinigungsfunktion implementieren, die nach einer bestimmten Zeit der Inaktivität regelmäßig alte Datensätze entfernt. Hier ist ein Beispiel dafür, wie man eine einfache Bereinigungsmethode hinzufügt, um veraltete Einträge aus dem Throttler zu entfernen.

export class Throttler {
    // ...

    public cleanup(): void {
        const now = Date.now()

        // Capture the keys first to avoid issues during iteration (we use .delete)
        const keys = Array.from(this.storage.keys())

        for (const key of keys) {
            const counter = this.storage.get(key)
            if (!counter) {
                // Skip if the counter is already deleted (handles concurrency issues)
                return
            }

            // If the IP is at the first timeout, remove it from storage
            if (counter.index == 0) {
                this.storage.delete(key)
                continue
            }

            // Otherwise, reduce the timeout index and update the timestamp
            counter.index -= 1
            counter.updatedAt = now
            this.storage.set(key, counter)
        }
    }
}

Eine sehr einfache (aber wahrscheinlich nicht die beste) Möglichkeit, die Bereinigung zu planen, ist mit setInterval:

const throttler = new Throttler([1, 2, 4, 8, 16, 30, 60, 300])
const oneMinute = 60_000
setInterval(() => throttler.cleanup(), oneMinute)

Dieser Bereinigungsmechanismus trägt dazu bei, dass Ihr Drosseler nicht auf unbestimmte Zeit an alten Datensätzen festhält, wodurch Ihre Anwendung effizient bleibt. Obwohl dieser Ansatz einfach und leicht zu implementieren ist, muss er für komplexere Anwendungsfälle möglicherweise weiter verfeinert werden (z. B. durch die Verwendung einer erweiterten Planung oder den Umgang mit hoher Parallelität).

Mit der regelmäßigen Bereinigung verhindern Sie ein Aufblähen des Arbeitsspeichers und stellen sicher, dass Benutzer, die längere Zeit keine Anfragen gestellt haben, nicht mehr verfolgt werden – dies ist ein erster Schritt, um Ihr ratenbegrenzendes System sowohl skalierbar als auch ressourceneffizient zu machen.

1. Wenn Sie abenteuerlustig sind, könnte es für Sie interessant sein, zu lesen, wie Eigenschaften zugewiesen werden und wie sie sich ändert. Warum nicht auch über VM-Optimierungen wie Inline-Caches, die besonders durch Monomorphismus begünstigt werden? Genießen. ↩