Einleitung: Warum der Client sein eigenes Rate Limit braucht

Stell dir vor, du stehst in einer Bank mit nur einem Schalter, und hinter dir hat sich eine Schlange von tausend Leuten gebildet. Du kannst drängeln, du kannst schreien — aber der Durchsatz des Schalters wird dadurch nicht größer. Du kannst nur entweder in vernünftigem Tempo herangehen oder abgewiesen werden. Das serverseitige Rate Limit (die Begrenzung der Anfragefrequenz) ist genau dieser Sachbearbeiter, der dich irgendwann einfach nicht mehr bedient. Und ein clientseitiges Rate Limit ist deine eigene Entscheidung, nicht häufiger an den Schalter zu treten, als er physisch bedienen kann.

Dieser Artikel widmet sich voll und ganz den Algorithmen. Wir wiederholen bewusst nicht die Themen, wie man den Code 429 behandelt und einen exponentiellen Backoff aufbaut, und wir diskutieren nicht, wie viele Threads man starten soll. Der Fokus liegt woanders: Wie berechnest du schon vor dem Senden einer Anfrage, ob du sie jetzt abschicken darfst, und wenn nicht, wie lange du warten musst. Genau diese Mathematik unterscheidet einen Client, der „manchmal abgelehnt wird“, von einem Client, der jahrelang mit ein und derselben API arbeitet, ohne bei deren Betreibern Ärger auszulösen.

Das erfährst du in diesem Artikel:

  • wie die vier Algorithmusfamilien aufgebaut sind — Fixed Window, Sliding Window, Token Bucket und Leaky Bucket — und worin sie sich auf Verhaltensebene unterscheiden, nicht nur im Namen;
  • warum Token Bucket und GCRA (eine Variante des Leaky Bucket) zum De-facto-Standard geworden sind und wie du sie an einem Abend ohne Rundungsfehler implementierst;
  • wie du eine Limit-Hierarchie aufbaust: globales Budget, Budget pro Host, pro Endpoint, pro Autorisierungsschlüssel und pro ausgehender IP-Adresse;
  • wie du die IP-Rotation in das Limiter-Modell einbindest, ohne weder serverseitige Quoten noch deine eigene Telemetrie zu brechen;
  • welche Designfehler harmlos aussehen, aber zu endlosem Warten, „Explosionen“ am Anfang jeder Minute und Speicherlecks führen.

Wir sprechen die Sprache eines Ingenieurs, der erklärt: mit Formeln, aber ohne Überheblichkeit, mit Beispielen, aber ohne Füllwerk. Wenn du Parser, SDKs für fremde APIs, Integrationen mit Marktplätzen oder Aggregatoren baust, die hunderte Hosts ansprechen — dann solltest du diesen Leitfaden als Lesezeichen speichern.

Grundlagen: Was ist ein Rate Limit auf Clientseite und warum reicht der Server nicht

Zwei Blickwinkel auf ein Problem

Ein serverseitiges Rate Limit schützt die Infrastruktur des API-Betreibers: Er zählt deine Anfragen und antwortet mit einer Ablehnung, wenn die Quote erschöpft ist. Ein clientseitiges Rate Limit löst eine andere Aufgabe — es gar nicht erst zur Ablehnung kommen zu lassen. Der Unterschied ist grundlegend. Der Server reagiert im Nachhinein: Die Anfrage ist bereits raus, der Kanal belegt, das Log verstopft, die Reputation des Clients ein wenig beschädigt. Der Client handelt vorausschauend: Er kennt (oder schätzt) das Budget und gibt es sorgfältig aus.

Warum kann man sich nicht einfach auf serverseitige Ablehnungen verlassen und es wiederholen? Weil jede abgelehnte Anfrage eine verbrauchte Verbindung, ein verbrauchtes Autorisierungstoken, eine Zeile im fremden Sicherheitslog und in der Regel eine Verschlechterung deiner Position in adaptiven Schutzsystemen bedeutet. Ein Client, der selbst ein Tempo einhält, wirkt für den Server wie ein wohlerzogener Partner. Ein Client, der „probiert, bis man ihn reinlässt“, wirkt wie eine Problemquelle. Rate mal, wen man bei der nächsten Überarbeitung der Richtlinien strenger einschränkt.

Grundlegende Terminologie

  • Rate (Geschwindigkeit) — die eingependelte Anfragefrequenz, etwa „zehn Anfragen pro Sekunde“. Das ist, was der Server unendlich lange akzeptieren würde.
  • Burst (Ausbruch) — wie viele Anfragen man sofort hintereinander senden kann, ohne auf das Nachfüllen zu warten. Server erlauben oft kurze Ausbrüche, solange die Durchschnittsgeschwindigkeit nicht verletzt wird.
  • Fenster (window) — der Zeitabschnitt, über den die Anfragen gezählt werden: Sekunde, Minute, Stunde, Tag.
  • Quote (quota) — die maximale Anzahl Anfragen im Fenster. Die Quote geteilt durch die Fensterlänge ergibt die Durchschnittsgeschwindigkeit.
  • Limit-Schlüssel (limit key) — das Merkmal, nach dem der Server Anfragen gruppiert: IP-Adresse, Token, Account, das Paar „Host plus Endpoint“. Derselbe Client fällt fast immer gleichzeitig unter mehrere Schlüssel.
  • Kosten (cost) — das Gewicht einer Anfrage. Manche APIs zählen eine Suche als zehn Einheiten und das Lesen einer Karte als eine.

Der wichtigste Grundsatz: Der Limiter entscheidet „wann“, nicht „wie viele“

Ein verbreiteter Irrtum ist, den Limiter mit einem Semaphor zu verwechseln. Ein Semaphor begrenzt die Anzahl gleichzeitiger Operationen und beantwortet die Frage „wie viele sind gerade in der Luft“. Ein Limiter begrenzt die Frequenz und beantwortet die Frage „darf ich jetzt eine weitere Operation starten, und wenn nicht — in wie vielen Millisekunden ist es so weit“. Diese beiden Mechanismen ergänzen sich, sind aber nicht austauschbar. Man kann eine einzige Verbindung halten und trotzdem das Limit überschreiten, wenn die Anfragen kurz sind. Man kann hundert Verbindungen halten und das Limit einhalten, wenn die Anfragen langsam sind.

Drei Eigenschaften eines guten clientseitigen Limiters

  1. Vorhersagbarkeit. Bei gleicher Eingabe liefert er dieselbe Antwort. Kein „lässt manchmal ein bisschen mehr durch“.
  2. Kostengünstigkeit. Die Entscheidung fällt in konstanter Zeit und mit konstantem Speicherbedarf pro Schlüssel. Wenn du tausende Hosts hast, kann der Limiter nicht die Historie aller Anfragen speichern.
  3. Fairness. Wenn mehrere Aufgaben auf eine Freigabe warten, bekommen sie sie in der Reihenfolge der Warteschlange, nicht in der Reihenfolge „wer am besten aufwacht“.

Halte diese drei Kriterien im Kopf: An ihnen vergleichen wir die Algorithmen im nächsten Abschnitt.

Tiefer eintauchen: Algorithmusfamilien und ihre Mathematik

Fixed Window — ehrlicher, aber tückischer Zähler

Die einfachste Variante: Wir teilen die Zeit in Fenster fester Länge auf, führen pro Fenster einen Zähler und warten bei erreichter Quote auf den Beginn des nächsten Fensters. Speicherbedarf: eine Zahl und ein Zeitstempel pro Schlüssel. Klingt ideal.

Das Problem heißt Effekt der Fenstergrenze. Wenn die Quote einhundert Anfragen pro Minute ist, kann der Client einhundert Anfragen in der letzten Sekunde eines Fensters und noch einmal einhundert in der ersten Sekunde des nächsten senden. Aus Sicht des Clients ist alles legal: in jedem Fenster genau einhundert. Aus Sicht des Servers kamen in zwei Sekunden zweihundert Anfragen an — doppelt so viel wie jede vernünftige Auslegung des Limits. Wenn der Server mit einem Sliding Window zählt (was die meisten modernen tun), bekommst du eine Ablehnung, während du dich völlig unschuldig fühlst.

Das zweite Übel ist die Synchronisierung von Ausbrüchen. Alle deine Worker „erwachen“ gleichzeitig am Anfang der Minute, weil genau dann der Zähler zurückgesetzt wird. Das erzeugt Lastspitzen auf dem Netzwerk, auf dem Proxy und auf dem Zielserver.

Sliding Window Log — genau, aber teuer

Wir speichern die Zeitstempel aller Anfragen des letzten Intervalls. Vor dem Senden verwerfen wir die veralteten und zählen die verbliebenen. Absolut präzise Abrechnung, kein Grenz-Effekt. Aber der Speicher wächst linear mit der Quote: Bei einer Quote von zehntausend Anfragen pro Stunde speicherst du zehntausend Zeitstempel pro Schlüssel. Für einen Host vertretbar, für tausend Hosts nicht.

Sliding Window Counter — der Kompromiss

Wir speichern zwei Zähler: den des aktuellen Fensters und den des vorherigen. Die Lastschätzung ist der aktuelle Zähler plus der vorherige, multipliziert mit dem Anteil des vorherigen Fensters, der noch im gleitenden Intervall liegt. Wenn 20 Prozent der aktuellen Minute vergangen sind, nehmen wir 80 Prozent des vorherigen Zählers. Das ist eine Näherung, aber sie glättet die Grenze hervorragend und braucht nur zwei Variablen. Viele serverseitige Implementierungen nutzen genau diese, also ist es eine gute Methode, auf Clientseite „wie der Server zu denken“.

Token Bucket — der Eimer mit den Jetons

Stell dir einen Eimer mit Fassungsvermögen B Jetons vor. Jede Sekunde tropfen r Jetons hinein, überzählige laufen über den Rand. Um eine Anfrage mit Kosten c zu senden, musst du c Jetons entnehmen. Sind keine da, musst du warten, bis genug nachgetropft sind.

Zwei Parameter ergeben zwei unabhängige Eigenschaften. Der Parameter r ist die eingependelte Geschwindigkeit: Egal wie lange du wartest, das langfristige Tempo überschreitet r Anfragen pro Sekunde nicht. Der Parameter B ist der maximale Ausbruch: Nach einer Ruhepause kannst du sofort B Anfragen senden. Das entspricht perfekt der Art, wie echte serverseitige Richtlinien formuliert werden: „nicht mehr als einhundert pro Minute, nicht mehr als zehn auf einmal“.

Das entscheidende Implementierungsdetail ist die lazy Nachfüllung. Es braucht keinen Hintergrundthread, der jede Sekunde Jetons hinzufügt. Es genügt, bei jedem Aufruf zu berechnen, wie viel Zeit seit dem letzten Aufruf vergangen ist, und entsprechend zu addieren: tokens = min(B, tokens + elapsed * r). Zwei Zahlen pro Schlüssel, Berechnung in konstanter Zeit. Erfüllt das Kriterium der Kostengünstigkeit vollständig.

Leaky Bucket — der Eimer mit dem Loch

Hier ist die Metapher umgekehrt: Anfragen fließen in den Eimer, und durch das Loch am Boden fließen sie mit konstanter Geschwindigkeit r heraus. Ist der Eimer voll — wird die neue Anfrage abgelehnt oder wartet. Der Ausgang ist immer gleichmäßig: keine Ausbrüche, strikt eine Anfrage alle 1/r Sekunden. Wenn der Server keine Ausbrüche toleriert oder du ein möglichst glattes Traffic-Profil willst, ist das deine Wahl.

Es gibt zwei Auslegungen des Leaky Bucket. Die erste — als Warteschlange: Anfragen werden tatsächlich in einen Puffer gelegt, und ein separater Prozess schickt sie per Timer raus. Die zweite — als Zähler: Wir prüfen nur, ob der gedachte Eimer überlaufen würde, und lassen entweder durch oder nicht. Die zweite Auslegung heißt in der Telekommunikation GCRA (Generic Cell Rate Algorithm) und ist mathematisch äquivalent zu einem Token Bucket mit anderer Parametrisierung. Das ist eine wichtige Erkenntnis: Wenn du bereits einen Token Bucket implementiert hast, beherrschst du auch den Leaky Bucket.

GCRA: ein einziger Zeitstempel statt Zähler

GCRA speichert einen einzigen Wert — TAT (theoretical arrival time, theoretische Ankunftszeit): den Moment, vor dem die nächste „ideale“ Anfrage nicht kommen sollte. Parameter: Emissionsintervall T = 1/r und Toleranz τ, gleich (B − 1) * T. Der Algorithmus:

  1. Wir holen die aktuelle Zeit now.
  2. Ist TAT kleiner als now, setzen wir TAT auf now (der Eimer ist längst leer).
  3. Ist TAT − τ größer als now — kam die Anfrage zu früh; die Wartezeit beträgt TAT − τ − now.
  4. Andernfalls erlauben wir die Anfrage und verschieben TAT um T nach vorne.

Eine Zahl pro Schlüssel, keine Zähler mit Gleitkomma, die mit der Zeit auseinanderdriften. Aus diesem Grund ist GCRA der Lieblingsalgorithmus für verteilte Limiter: Sein Zustand lässt sich leicht in einem einzigen Schlüssel-Wert-Feld speichern und atomar aktualisieren.

Vergleichstabelle in Worten

  • Fixed Window: minimaler Speicher, geringe Genauigkeit, Ausbrüche an den Grenzen, taugt nur als grobe Absicherung.
  • Sliding Log: absolute Genauigkeit, Speicher linear zur Quote, geeignet für wenige Schlüssel mit kleinen Quoten.
  • Sliding Counter: Speicher zwei Variablen, annähernde Genauigkeit, ahmt serverseitige Logik gut nach.
  • Token Bucket: Speicher zwei Variablen, explizite Kontrolle des Ausbruchs, Standard für clientseitige SDKs.
  • Leaky Bucket / GCRA: Speicher eine Variable, ideal gleichmäßiger Ausgang, Standard für verteilte Systeme.

Zur Uhr: Monotonie und Drift

Alle Algorithmen stützen sich auf „die aktuelle Zeit“. Nutze die monotone Uhr, nicht die Systemzeit. Die Systemzeit kann bei der Synchronisierung zurückspringen, und dein Limiter glaubt dann, es sei eine negative Anzahl Sekunden vergangen, setzt die Nachfüllung auf null oder spuckt umgekehrt einen riesigen Ausbruch aus. Die monotone Uhr geht garantiert nicht rückwärts. Die einzige Ausnahme — ein verteilter Limiter in einem gemeinsamen Speicher, wo die Zeit auf der Seite des Speichers genommen wird, nicht auf den Clients, um nicht von der Uhrabweichung zwischen den Maschinen abzuhängen.

Methode 1: Token Bucket in der Praxis — Implementierung ohne Fallstricke

Schritt 1. Wahl der Parameter

Übersetze die serverseitige Richtlinie in das Paar (r, B). Wenn die Doku „einhundert Anfragen pro Minute“ sagt, ist die Basisgeschwindigkeit r = 100/60 Jetons pro Sekunde. Die Kapazität B ist eine separate Entscheidung. Eine sichere Wahl für eine unbekannte API — B gleich fünf bis zehn Prozent der Fensterquote, also fünf bis zehn Jetons bei einer Quote von einhundert. Das erlaubt, eine kleine Gruppe schnell abzuarbeiten, erzeugt aber keine Spitzen, die ein Server mit Sliding Window als Verletzung wahrnimmt.

Noch besser — mit Puffer rechnen: 80–90 Prozent der deklarierten Geschwindigkeit nutzen. Serverseitige Zähler, Netzwerklatenzen und Rundungen auf beiden Seiten verursachen unweigerlich Ungenauigkeit, und der Puffer absorbiert sie.

Schritt 2. Zustandsstruktur

Speichere pro Schlüssel: tokens (Gleitkommazahl, aktuelle Jeton-Anzahl), last (monotone Marke der letzten Neuberechnung), rate, capacity. Schütze den Zustand mit einem Mutex oder, im asynchronen Code, mit einem einzigen Arbiter-Task, durch den alle Anfragen auf Jetons laufen.

Schritt 3. Der Algorithmus acquire(cost)

  1. Wir nehmen die Sperre.
  2. now = monotonic(); elapsed = now − last; last = now.
  3. tokens = min(capacity, tokens + elapsed * rate).
  4. Ist tokens ≥ cost: tokens −= cost; wir geben die Sperre frei; wir geben „null Wartezeit“ zurück.
  5. Andernfalls: wait = (cost − tokens) / rate; wir schreiben die Jetons ins Minus: tokens −= cost; wir geben die Sperre frei; wir geben wait zurück.
  6. Der Aufrufer schläft wait Sekunden und sendet dann die Anfrage.

Achte auf Punkt fünf. Das Minusschreiben ist eine Reservierung. Sie garantiert Fairness: Der nächste Aufruf sieht einen negativen Rest und bekommt eine noch längere Wartezeit, also stellt er sich hinter den vorherigen in die Warteschlange. Ohne Reservierung entsteht der klassische Fehler: Zehn Aufgaben sehen gleichzeitig null Jetons, alle berechnen dieselbe Wartezeit, alle erwachen gleichzeitig und erzeugen einen Ausbruch, den der Limiter gerade verhindern sollte.

Schritt 4. Begrenzung der Reservierungstiefe

Die Reservierung ins Minus kann ins Unendliche laufen: Wenn Aufgaben schneller ankommen, als Jetons nachgefüllt werden, wächst die Warteschlange, und die Wartezeit des letzten nähert sich Stunden. Führe eine maximale Verzögerung ein (max_delay). Ist die berechnete wait größer als der Schwellwert, reserviere nicht, sondern gib einen Fehler „Limiter überlastet“ zurück. Der Scheduler entscheidet dann, was zu tun ist: verschieben, Priorität senken, auf einen anderen Host wechseln. Das ist genau der Punkt, an dem der clientseitige Limiter aus einer passiven Bremse ein Werkzeug zur Laststeuerung wird.

Schritt 5. Gewichtete Kosten

Lass Anfragen unterschiedliche cost haben. Such-Endpoints, Massenabrufe, Schreiboperationen sind für den Server meist „teurer“, und viele APIs spiegeln das in ihren Richtlinien wider. Schweigt die Doku, setze das Gewicht nach eigenen Beobachtungen über die Antwortzeit: Eine Anfrage, die der Server länger verarbeitet, ist vernünftigerweise teurer. Die Wartezeitformel ändert sich dadurch nicht — cost geht nur als Faktor ein.

Schritt 6. Warmlaufen und Kaltstart

Der Anfangswert von tokens ist eine eigene Entscheidung. Ein voller Eimer beim Start bedeutet einen sofortigen Ausbruch von B Anfragen, sobald der Prozess startet. Das kann unerwünscht sein, wenn dutzende Prozesse nach einem Deploy gleichzeitig starten. Sicherer ist, mit null oder mit der halben Kapazität zu beginnen. Und wenn bekannt ist, dass der Server die Quote über ein Fenster zählt, das nicht an deinem Start liegt, ist ein Nullstart auch ehrlicher.

Checkliste Token Bucket

  • Es werden monotone Uhren verwendet.
  • Die Nachfüllung ist lazy, über die Zeitdifferenz, ohne Hintergrund-Timer.
  • Reservierung ins Minus für eine faire Warteschlange.
  • Es gibt max_delay und eine explizite Ablehnung bei Überlauf.
  • Die Geschwindigkeit ist mit Puffer relativ zum Server gesetzt.
  • Die Kapazität ist auf einen sinnvollen Anteil der Fensterquote begrenzt.
  • cost für gewichtete Anfragen wird unterstützt.
  • Der Anfangszustand erzeugt beim Deploy keinen Ausbruch.

Methode 2: Leaky Bucket und GCRA — wenn man einen gleichmäßigen Strom braucht

Wann Leaky Bucket bevorzugen

Token Bucket erlaubt Ausbrüche. Das ist bequem, aber es gibt Situationen, in denen der Ausbruch an sich schädlich ist: Der Server reagiert aggressiv auf kurzzeitige Spitzen, der Proxy-Kanal hat begrenzte Bandbreite, du willst, dass das Traffic-Muster wie bei einem gewöhnlichen, gemächlichen Client aussieht. In all diesen Fällen brauchst du einen Ausgang mit strikt konstantem Intervall zwischen Anfragen. Genau das ist der Leaky Bucket.

Implementierung als Warteschlange

Die klassische Variante: ein Puffer fester Kapazität und ein einziger Konsument, der alle T Sekunden ein Element entnimmt und sendet. Vorteil — Einfachheit und Anschaulichkeit. Nachteile — ein separater Thread oder Task wird gebraucht, und bei Stillstand des Konsumenten „friert“ der Puffer ein. Dieser Ansatz ist passend, wenn du eine explizite Pipeline hast: eine Aufgaben-Warteschlange, aus der die Anfragen ohnehin einzeln entnommen werden.

Implementierung als GCRA

Für die meisten clientseitigen Szenarien ist die Zähler-Auslegung bequemer. Den Algorithmus haben wir oben beschrieben; gehen wir darauf ein, wie man die Parameter setzt. Wird ein striktes Intervall verlangt, setze τ = 0: Dann ist die Toleranz null, und Anfragen gehen nicht häufiger als alle T durch. Willst du einen kleinen Ausbruch erlauben, erhöhe τ. So deckt eine Implementierung sowohl den strengen Leaky Bucket als auch den Token Bucket ab. Deshalb ist GCRA eine gute „einheitliche Engine“ für eine Bibliothek zur Ratenbegrenzung.

Schritt-für-Schritt-Verfahren GCRA mit Reservierung

  1. TAT für den Schlüssel lesen; fehlt er, TAT = now annehmen.
  2. new_TAT = max(TAT, now) + T * cost.
  3. allow_at = new_TAT − τ − T * cost; das ist der Moment, zu dem eine Anfrage mit dieser Kostenhöhe ohne Warten hätte gesendet werden können.
  4. Ist allow_at ≤ now: new_TAT schreiben, „null Wartezeit“ zurückgeben.
  5. Andernfalls: wait = allow_at − now; ist wait größer als max_delay — Ablehnung ohne Schreiben zurückgeben; sonst new_TAT schreiben und wait zurückgeben.

In einem verteilten Speicher werden die Schritte eins bis fünf in einer einzigen atomaren Operation ausgeführt — etwa durch ein Skript auf der Seite des Speichers. So wird garantiert, dass zwei Clients nicht denselben TAT lesen und die Freigabe „verdoppeln“.

Äquivalenz und Wahl nach Lastcharakter

Es ist nützlich zu verstehen: Token Bucket mit Parametern (r, B) und GCRA mit Parametern (T = 1/r, τ = (B − 1)/r) lassen genau dieselben Sequenzen von Anfragen durch. Der Unterschied liegt nur in der Darstellung des Zustands. Deshalb klingt die Frage „was ist besser“ eigentlich anders: Brauchst du einen Ausbruch. Ja — setze B größer als eins. Nein — setze B = 1 (τ = 0). Der Rest ist Geschmack und Bequemlichkeit der Speicherung.

Checkliste Leaky Bucket / GCRA

  • Es ist entschieden, ob Ausbruch oder strikt gleichmäßiger Strom.
  • Der Zustand — ein TAT-Wert pro Schlüssel.
  • Die Operation Lesen-Prüfen-Schreiben ist atomar.
  • Es gibt max_delay und eine explizite Ablehnung.
  • Die Zeit wird in der verteilten Variante auf der Seite des Speichers genommen.

Methode 3: Limits pro Host — Registry, Hierarchie und Komposition

Warum „ein Limiter für alles“ nicht funktioniert

Wenn dein Client nur eine API anspricht, reicht ein einziger Eimer. Aber Aggregatoren, Parser und Integrationsbusse sprechen dutzende und hunderte Hosts an, jeder mit eigener Richtlinie. Ein einheitliches globales Limit nutzt entweder schnelle Hosts nicht aus oder überlastet langsame. Man braucht eine Limiter-Registry: eine Abbildung von „Limit-Schlüssel — Eimer-Zustand“, wobei der Schlüssel aus den Merkmalen der Anfrage gebildet wird.

Der Limit-Schlüssel: vom Host zum Endpoint

Der minimale Schlüssel — Schema plus Host plus Port. Zwei Domains eines Eigentümers teilen oft eine Quote, während Subdomains separat gezählt werden können; das musst du aus der Doku wissen oder durch Beobachtung herausfinden. Ein feinerer Schlüssel — Host plus Pfadmuster: zum Beispiel haben der Such-Endpoint und der Produktkarten-Endpoint unterschiedliche Quoten. Noch feiner — Host plus Autorisierungstoken, wenn der Server die Quote pro API-Schlüssel zählt und du mehrere hast.

Die praktische Regel: Baue den Schlüssel aus denselben Merkmalen, nach denen der Server zählt. Zählt der Server nach IP, gehört deine ausgehende IP in den Schlüssel. Nach Token — der Token. Nach beidem gleichzeitig — brauchst du zwei Limiter, und die Anfrage muss beide passieren.

Hierarchie der Limits

Ein gut entworfenes System baut die Limiter in Ebenen auf:

  1. Global — das gemeinsame Budget des Prozesses. Schützt deine eigenen Ressourcen: Sockets, Speicher, Kanalbandbreite.
  2. Pro ausgehender IP — wie viele Anfragen über eine bestimmte Adresse rausgehen. Die entscheidende Ebene bei Arbeit über einen Adresspool.
  3. Pro Host — die Richtlinie des Zielservers insgesamt.
  4. Pro Endpoint — separate Quoten für teure Methoden.
  5. Pro Zugangsdaten — Quoten pro Token oder Account.

Eine Anfrage muss auf jeder Ebene eine Freigabe erhalten. Das ist die Komposition von Limitern.

Komposition ohne gegenseitige Blockade

Der naive Ansatz — nacheinander acquire bei jedem Limiter aufrufen und die Wartezeiten summieren. Er ist falsch: Der erste Limiter hat schon einen Jeton abgebucht, und der zweite zwingt zehn Sekunden zu warten, in denen der Jeton des ersten aus Fairness-Sicht „verfällt“. Schlimmer noch, zwei Aufgaben, die die Limiter in unterschiedlicher Reihenfolge belegen, können sich endlos gegenseitig behindern.

Die korrekte Prozedur:

  1. Für jeden Limiter die Wartezeit ohne Abbuchung berechnen (Operation peek).
  2. Das Maximum der Wartezeiten nehmen — das ist die Gesamt-wait.
  3. Überschreitet wait das max_delay — Ablehnung.
  4. Andernfalls in allen Limitern abbuchen und ihnen die einheitliche Ankunftszeit now + wait übergeben, damit jeder die Ressource auf denselben Moment reserviert.
  5. wait schlafen und senden.

Durchlaufe die Limiter immer in einer festen Reihenfolge (etwa vom globalen zum engsten). Das schließt wechselseitige Blockaden bei konkurrentem Zugriff aus.

Konfiguration und Standardwerte

Die Registry muss in der Lage sein, für einen zuvor unbekannten Host einen Limiter zu erstellen. Setze einen konservativen Standard: niedrige Geschwindigkeit, minimaler Ausbruch. Für bekannte Hosts — eine explizite Konfiguration. Eine gute Praxis ist, die Richtlinie deklarativ abzulegen: Host oder Muster, rate, burst, cost nach Pfadmustern, Kennzeichen „nach IP zählen“ und „nach Token zählen“. Dann ändert sich bei einer Richtlinienänderung des Servers eine Datei und nicht der Code.

Verdrängung und Lecks

Eine Registry mit tausenden Hosts ist ein Kandidat für Speicherlecks. Hosts, die lange nicht angesprochen wurden, müssen verdrängt werden. Da der Eimer-Zustand nach langer Ruhe ohnehin „voll“ ist (oder TAT in der Vergangenheit liegt), verliert die Verdrängung keine Information: Beim nächsten Zugriff wird der Limiter im selben Zustand neu erstellt. Nutze einen LRU-Cache mit Größenbegrenzung oder eine periodische Bereinigung von Einträgen, deren last älter als mehrere Fenster ist.

Checkliste Limits pro Host

  • Der Limit-Schlüssel wiederholt die Merkmale, nach denen der Server zählt.
  • Es gibt Ebenen: global, IP, Host, Endpoint, Zugangsdaten.
  • Komposition über peek — Maximum — einheitliche Abbuchung.
  • Limiter werden in fester Reihenfolge durchlaufen.
  • Konservative Standardwerte für unbekannte Hosts.
  • Richtlinien sind in die Konfiguration ausgelagert.
  • Die Registry ist größenbegrenzt und verdrängt inaktive Schlüssel.

Methode 4: Limiter und IP-Rotation — wie man den Adresswechsel ins Modell einbezieht

Warum die Rotation einen naiven Limiter bricht

Zählt der Zielserver die Quote nach IP, so ändert ein Adresswechsel den Limit-Schlüssel auf der Serverseite. Ein naiver Client, der einen Zähler pro Host führt, bremst nach einem IP-Wechsel weiter, obwohl der Server schon einen „neuen“ Besucher sieht. Der umgekehrte Fehler ist gefährlicher: Der Client setzt beim IP-Wechsel alle Limits zurück, auch die, die der Server nach Token oder Account zählt — und bekommt eine Ablehnung wegen einer Quote, die mit der IP rein gar nichts zu tun hat. Fazit: Die Rotation darf nur die Ebene „pro ausgehender IP“ in der Hierarchie beeinflussen, die übrigen Ebenen leben ihr eigenes Leben.

Zwei Modi des Adresswechsels

In der Infrastruktur von Proxeon ändert sich die IP am Port entweder per Timer oder per Link/API (Stand 22.09.2026). Das sind zwei grundlegend verschiedene Szenarien für den Limiter. Bei der Timer-S Rotation steuert der Client den Moment nicht: Die Adresse ändert sich „von außen“, und der IP-Limiter muss es erfahren — über ein Ereignis, über das Abfragen der aktuellen Adresse oder über einen Zeitplan, wenn das Intervall bekannt ist. Beim Wechsel per Link initiiert der Client selbst die Umschaltung und kann sie mit seinem Zustand synchronisieren: laufende Anfragen abwarten, den Moment festhalten, einen neuen Schlüssel „Host plus IP-Epoche“ anlegen.

Wie verbreitet ist jeder Modus? Nach Daten vom 14.11.2026 beträgt der Anteil der IP-Wechsel per Timer 51,1 %, der Rest entfällt auf Link/API. Beide Strategien kommen also etwa gleich häufig vor, und ein universeller Limiter muss beide unterstützen.

Die Adress-Epoche als Teil des Schlüssels

Statt die IP selbst in den Schlüssel zu legen (die man vorher vielleicht gar nicht kennt), nutze eine Epoche — einen Zähler, der bei jedem Wechsel erhöht wird. Der Schlüssel der Ebene „pro IP“ wird zum Paar „Port plus Epoche“. Bei einem Epochenwechsel wird der alte Schlüssel einfach nicht mehr genutzt und später von der Registry verdrängt, der neue im Anfangszustand erstellt. Beachte: Der Anfangszustand muss wieder konservativ sein. Die neue Adresse ist für den Server ein Fremder, und das Erste, was er sieht, ist dein Traffic-Muster.

Abstimmung des Limiter-Fensters mit dem Rotationstimer

Nach Daten vom 14.11.2026 beträgt das mediane Intervall zwischen Timer-IP-Wechseln 120 s, und 78,1 % der Timer-Intervalle sind exakte Vielfache einer Minute. Das ist sehr praktisch für die Auslegung. Wenn du eine Quote pro Host „N Anfragen pro Minute pro IP“ hast und die Adresse zwei Minuten lebt, dann ist das Budget einer Adresse genau zwei Minutenfenster. Der IP-Limiter kann als Token Bucket mit Geschwindigkeit N/60 und einer Kapazität arbeiten, die so berechnet ist, dass über die Lebensdauer der Adresse 2N nicht überschritten werden. Wichtig ist, Versäumtes nicht „nachzuholen“: Wenn du in der ersten Minute wenig gesendet hast, darfst du in der zweiten nicht doppelt so viel senden, weil der Server nach dem Minutenfenster zählt und nicht nach deiner Epoche.

Pause während des Umschaltens

Der Adresswechsel ist nicht momentan. Nach Daten vom 14.11.2026 beträgt die mittlere Dauer des Wechsels selbst — vom Befehl bis zur neuen Adresse — 4,56 s, und 80,8 % der Wechsel liegen innerhalb von 5 Sekunden. Was bedeutet das für den Limiter? Während des Umschaltens gehen Anfragen entweder über die alte Adresse raus oder gar nicht. Die richtige Strategie ist, den Wechsel als kurzes „Drainage“-Intervall zu behandeln: Vor dem Wechselbefehl gibt der Limiter keine neuen Freigaben mehr aus, wartet auf laufende Anfragen, führt den Wechsel durch und öffnet dann eine neue Epoche. Da vier von fünf Wechseln innerhalb von fünf Sekunden abgeschlossen sind, ist es sinnvoll, für das Warten auf die neue Adresse einen Timeout etwas über diesem Wert anzusetzen und bei Überschreitung zur Ausnahmebehandlung überzugehen.

Begrenze die Häufigkeit des Wechselbefehls selbst

Hier ist eine Einsicht, die oft übersehen wird: Der Befehl zum IP-Wechsel ist auch eine Anfrage an die API, und auch ihn muss man limitieren. Nach Daten vom 14.11.2026 beträgt der Anteil doppelter Einträge zu Wechseln per Link (Intervall höchstens 2 s, dieselbe IP) 1,2 %. Das sind Spuren von Situationen, in denen der Client den Link zweimal hintereinander gezogen hat: wegen eines Rennens zwischen Workern, wegen einer Wiederholung nach Timeout, wegen des Fehlens einer einheitlichen Entscheidungsinstanz. Die Lösung — ein separater Eimer mit Kapazität eins und strengem Intervall (reiner Leaky Bucket mit τ = 0) für den Rotationsbefehl, plus Deduplizierung: Wenn ein Wechsel bereits läuft, warten die übrigen Worker auf sein Ergebnis, statt einen neuen zu initiieren. Dasselbe Prinzip wie für die Ziel-Hosts, nur auf deine eigene Infrastruktur angewandt.

Maßstab und Budgetplanung

Um den Maßstab zu spüren: Nach Daten vom 14.11.2026 wurden pro Tag im gesamten Proxeon-Netz 2 196 242 IP-Wechsel durchgeführt, daran waren 7 924 Proxy-Ports beteiligt, und der Median der eindeutigen IPs pro Modem pro Tag liegt bei 95. Für den Limiter-Designer bedeutet das, dass ein Port pro Tag dutzende Adress-Epochen durchläuft, und der Zustand „pro IP“ muss leicht und schnell verdrängbar sein: Die Historie aller Epochen zu speichern macht keinen Sinn, aber konstante Kosten für die Erstellung einer neuen Epoche sicherzustellen ist Pflicht.

Protokolle und Port-Adressierung

Eine Kleinigkeit, die die Konfiguration vereinfacht: In Proxeon ist der SOCKS5-Port gleich dem HTTP-Port plus eins (Stand 22.09.2026). Wenn du beide Protokolle für denselben Kanal nutzt, muss der IP-Limiter sie als einen Schlüssel zählen, nicht als zwei: Die Adresse ist gemeinsam, also ist es auch das Budget. Trage in der Registry die Normalisierung ein: Der Schlüssel wird über den HTTP-Port gebildet, und der SOCKS5-Port wird durch Subtraktion von eins darauf abgebildet.

Verteilter Limiter pro IP

Wenn mehrere Prozesse oder Maschinen über einen Port gehen, muss der Eimer gemeinsam sein. Nutze einen Speicher mit atomaren Operationen, speichere TAT (GCRA) unter dem Schlüssel „Port plus Epoche plus Host“, aktualisiere per Skript auf der Speicherseite und nimm die Zeit von dort. Auch die Epoche speichere zentral und ändere sie atomar zusammen mit dem Rotationsbefehl — dann wechseln alle Prozesse konsistent auf den neuen Schlüssel.

Checkliste Limiter bei Rotation

  • Die Rotation beeinflusst nur die Ebene „pro IP“, die übrigen Ebenen werden nicht zurückgesetzt.
  • Beide Modi werden unterstützt: Timer und Wechsel per Link/API.
  • Der Schlüssel der IP-Ebene enthält die Adress-Epoche.
  • Eine neue Epoche startet in konservativem Zustand.
  • Die IP-Geschwindigkeit ist mit dem Serverfenster abgestimmt, nicht mit der Länge der Epoche.
  • Während des Umschaltens wird die Freigabeerteilung ausgesetzt.
  • Der Rotationsbefehl wird selbst limitiert und dedupliziert.
  • HTTP- und SOCKS5-Ports eines Kanals werden zu einem Schlüssel normalisiert.
  • Für Mehrprozess-Szenarien ist der Zustand in einen gemeinsamen Speicher ausgelagert.

Typische Designfehler beim clientseitigen Rate Limit

Fehler 1. Sleep statt Limiter

„Wir legen eine Pause von hundert Millisekunden zwischen die Anfragen“ — die häufigste Lösung und die zerbrechlichste. Sie berücksichtigt die Dauer der Anfrage selbst nicht, funktioniert bei mehreren Workern nicht, erlaubt keine Ausbrüche dort, wo sie erlaubt sind, und schützt nicht vor ihrer Entstehung dort, wo sie verboten sind. Eine Pause ist kein Limiter, sondern seine Imitation.

Fehler 2. Nach Fenster zählen, wenn der Server gleitend zählt

Der Effekt der Fenstergrenze wurde oben erklärt. Wenn du nicht sicher bist, wie der Server zählt, nimm das Schlimmste an — ein Sliding Window — und nutze einen Token Bucket mit bescheidener Kapazität.

Fehler 3. Rennen ohne Reservierung

Mehrere Aufgaben berechnen gleichzeitig dieselbe Wartezeit, schlafen ein und erwachen zusammen. Das Ergebnis ist genau der Ausbruch, den der Limiter verhindern sollte. Behandelt wird das mit Reservierung (Minusschreiben oder TAT-Verschiebung) unter einer Sperre.

Fehler 4. Endlose Warteschlange

Ohne max_delay wächst die Warteschlange unbegrenzt, und die Aufgaben warten Minuten und Stunden, während sie Speicher und Verbindungen belegen. Der Limiter muss ablehnen können.

Fehler 5. Systemuhren

Ein einziger Zeitsprung bei der Synchronisierung — und der Eimer läuft entweder über oder „friert ein“. Nur monotone Uhren auf dem Client; nur die Zeit des Speichers in der verteilten Variante.

Fehler 6. Zurücksetzen aller Limits beim IP-Wechsel

Quoten pro Token und Account hängen nicht von der Adresse ab. Setzt du sie zurück, verletzt du sofort eine Richtlinie, die dich gar nicht betraf.

Fehler 7. Voller Eimer beim Start

Dutzende Prozesse starten nach dem Deploy mit vollen Eimern und erzeugen gleichzeitig einen Ausbruch. Beginne mit einem leeren Eimer oder füge eine zufällige Startverzögerung hinzu.

Fehler 8. Registry ohne Verdrängung

Jeder neue Host — ein neuer Eintrag für immer. Nach Wochen des Betriebs hält der Prozess Limiter für Hosts im Speicher, die nie wieder gebraucht werden.

Fehler 9. Ignorieren der Anfragekosten

Wenn der Server eine Suche als zehn Einheiten zählt und du als eine, lässt dein Limiter zehnmal mehr durch als nötig und ist dann ehrlich überrascht von der Ablehnung.

Fehler 10. Unbegrenzter Rotationsbefehl

Die Wiederholung des Adresswechsel-Befehls nach Timeout oder aus mehreren Workern führt zu Duplikaten und überflüssigen Umschaltungen. Der Befehl ist auch eine Ressource; gib ihm einen Eimer.

Werkzeuge und Ressourcen für die Implementierung

Fertige Bibliotheken nach Ökosystemen

  • Go: das Paket golang.org/x/time/rate — die Referenzimplementierung eines Token Bucket mit Methoden Allow, Reserve und Wait. Reserve gibt ein Objekt mit Wartezeit und Abbruchmöglichkeit zurück — genau das, was man für die Komposition braucht.
  • Python: die Bibliothek limits bietet Fixed Window, Sliding Window und GCRA mit verschiedenen Backends; aiolimiter implementiert einen Leaky Bucket für asyncio; pyrate-limiter unterstützt mehrere Fenster gleichzeitig.
  • Java/Kotlin: Bucket4j — ein ausgereifter Token Bucket mit Unterstützung verteilter Speicher; Resilience4j RateLimiter — eine Variante mit festen Aktualisierungszyklen.
  • JavaScript/TypeScript: bottleneck kann nach Schlüsselgruppen limitieren und über einen gemeinsamen Speicher clustern; p-throttle — eine minimalistische Variante für einfache Fälle.
  • Rust: governor — eine GCRA-Implementierung mit und ohne Schlüssel, geeignet für asynchronen Code.
  • .NET: der eingebaute Namespace System.Threading.RateLimiting mit Token Bucket, Sliding Window und partitionierten Limitern nach Schlüsseln.

Speicher für verteilten Zustand

Redis und kompatible Speicher mit serverseitigen Skripten sind der Standard für gemeinsame GCRA: eine atomare Operation, die Zeit wird per Befehl des Speichers genommen, Schlüssel mit TTL werden automatisch verdrängt. Für Szenarien innerhalb eines Anwendungsclusters eignen sich auch eingebaute Mechanismen wie verteilte Caches mit atomaren Operationen.

Observability-Werkzeuge

Ein Limiter ohne Metriken ist eine Blackbox. Exportiere: Anzahl der Freigaben ohne Warten, Verteilung der Wartezeit, Anzahl der Ablehnungen wegen max_delay, aktuelle Füllstände der Eimer pro Schlüssel, Häufigkeit der Adress-Epochenwechsel. Ein Wartezeit-Histogramm pro Host zeigt sofort, wo die Richtlinie zu streng ist und wo du an der Grenze bist.

Adress-Infrastruktur

Für Szenarien mit Rotation brauchst du einen Anbieter, der zwei Modi des Adresswechsels bietet — per Timer und per Link/API — und eine vorhersagbare Port-Adressierung. In Proxeon sind beide Modi verfügbar, und der SOCKS5-Port liegt genau eins über dem HTTP-Port (Stand 22.09.2026), was die Normalisierung der Schlüssel in der Limiter-Registry vereinfacht.

Was lesen

  • Die Beschreibung von GCRA in den Spezifikationen der Telekommunikationsstandards — die Urquelle für den Leaky Bucket als Zähler.
  • Die Dokumentation des Pakets x/time/rate — eine vorbildliche Formulierung der Semantik von Reserve und Wait.
  • Die Abschnitte über Limits in der Dokumentation großer öffentlicher APIs — dort kommen alle Zählmodelle vor, und das ist der beste Weg zu lernen, eine Richtlinie in Eimer-Parameter zu übersetzen.

Anwendungsfälle und Szenarien

Szenario 1. Preis-Aggregator über hunderte Hosts

Aufgabe: regelmäßig Produktkarten auf vielen Plattformen durchlaufen, jede mit eigener Richtlinie. Lösung: eine Limiter-Registry mit Schlüssel „Host plus Pfadmuster“, konservativer Standard für neue Plattformen, explizite Richtlinien für bekannte. Komposition mit einem globalen Limit über die Socket-Anzahl. Das Ergebnis, das solche Systeme anstreben: gleichmäßige Auslastung aller Hosts ohne Leerlauf bei schnellen und ohne Überlastung bei langsamen; bei einer Richtlinienänderung der Plattform wird eine Konfigurationszeile geändert. Die zentrale Lehre — der Übergang von einem einzigen globalen Limit zu einer Hierarchie senkt den Anteil der „umsonst“ gesendeten Anfragen drastisch.

Szenario 2. SDK für eine Partner-API mit Quote pro Token und pro IP

Aufgabe: eine Bibliothek für Kunden, die mehrere Tokens und mehrere ausgehende Adressen haben. Lösung: zwei Limiter-Ebenen — pro Token und pro Adresse — mit Komposition über peek und einheitlicher Ankunftszeit. Der Scheduler wählt das Paar „Token plus Adresse“ mit der geringsten Wartezeit. Lehre — der Limiter wird zum Routing-Werkzeug: Statt „warten“ sagt er „wohin senden, um nicht zu warten“.

Szenario 3. Parser auf mobilen Adressen mit Timer-Rotation

Aufgabe: Durchlaufen offener Seiten über einen Portpool, Adressen wechseln per Timer. Lösung: ein IP-Limiter mit Schlüssel „Port plus Epoche“, Geschwindigkeit mit dem Minutenfenster des Ziel-Hosts abgestimmt. Da nach Daten vom 14.11.2026 das mediane Timer-Intervall 120 s beträgt und 78,1 % der Intervalle exakte Vielfache einer Minute sind, wird das Budget pro Epoche als ganze Anzahl Minutenfenster berechnet. Während des Umschaltens — und 80,8 % der Wechsel liegen innerhalb von 5 Sekunden (Stand 14.11.2026) — wird die Freigabeerteilung mit einem Timeout etwas über diesem Schwellwert pausiert. Lehre — die Abstimmung des Limiter-Fensters mit dem Rotationsrhythmus befreit von „nachholenden“ Ausbrüchen am Anfang einer neuen Epoche.

Szenario 4. Worker mit Rotation per Link und doppelten Befehlen

Aufgabe: mehrere Worker teilen sich einen Port, und jeder initiiert bei Bedarf einen Adresswechsel. Symptom — Spuren wiederholter Befehle in den Logs. Lösung: eine einheitliche Rotationsinstanz mit Leaky Bucket (τ = 0) und Deduplizierung: Wenn ein Wechsel bereits läuft, warten die übrigen auf sein Ende. Nach Daten vom 14.11.2026 beträgt der Anteil doppelter Einträge zu Wechseln per Link im Netz 1,2 %; das sind genau die Situationen, die eine einheitliche Entscheidungsinstanz beseitigt. Lehre — limitiert werden müssen nicht nur Anfragen an fremde APIs, sondern auch Befehle an die eigene Infrastruktur.

Szenario 5. Eine einheitliche GCRA-Engine für alle Ebenen

Aufgabe: eine Codebasis vereinfachen, in der historisch Fixed Window, Sleep-Pausen und manuelle Zähler nebeneinander existierten. Lösung: eine GCRA-Implementierung mit Parametern (T, τ), angewandt auf allen Ebenen der Hierarchie, mit Zustand im gemeinsamen Speicher für verteilte Schlüssel und im Speicher — für lokale. Lehre — eine Formel ersetzt den Zoo der Lösungen und macht das Systemverhalten vorhersagbar.

FAQ: Antworten auf knifflige Fragen

Worin unterscheidet sich Token Bucket grundsätzlich vom Leaky Bucket, wenn sie äquivalent sind?

Als mathematische Objekte sind sie äquivalent: Bei richtiger Parameterentsprechung lassen sie dieselben Sequenzen durch. Der Unterschied liegt in der Intuition und darin, welchen Parameter du direkt steuerst. Token Bucket denkt in Begriffen von „Geschwindigkeit und Ausbruch“, Leaky Bucket in Begriffen von „Intervall und Toleranz“. Für Richtlinien der Form „N pro Minute, nicht mehr als M auf einmal“ ist der erste bequemer; für „genau eine Anfrage alle T“ der zweite. GCRA vereint beide Intuitionen in einem Zustand.

Wie wählt man die Eimer-Kapazität, wenn der Server den erlaubten Ausbruch nicht veröffentlicht?

Beginne mit einem kleinen Anteil der Fensterquote — etwa fünf bis zehn Prozent — und beobachte. Gibt es keine Ablehnungen und sind die Wartezeiten groß, erhöhe vorsichtig. Denk daran, dass ein Server mit Sliding Window keine Ausbrüche toleriert, die die Quote innerhalb eines kurzen Teilintervalls überschreiten; die Kapazität sollte sich daher nie der vollen Quote nähern.

Braucht man einen Limiter, wenn man nur einen Thread hat?

Ja. Ein Thread mit kurzen Anfragen überschreitet leicht die Quote: Kommt die Antwort in zwanzig Millisekunden, sendest du fünfzig Anfragen pro Sekunde, ohne darüber nachzudenken. Der Limiter wird unabhängig von der Thread-Anzahl gebraucht; er löst eine andere Frage als ein Semaphor.

Wie limitiert man Anfragen mit unterschiedlichen Kosten, wenn der Server sie unterschiedlich zählt?

Übergib cost an acquire. Die Jetons werden proportional abgebucht, die Wartezeit nach derselben Formel berechnet. Ist die Kostenhöhe unbekannt, schätze sie nach Antwortzeit oder Antwortgröße und verfeinere sie mit den Beobachtungen. Lieber überschätzen als unterschätzen.

Was tun, wenn eine Anfrage fünf Limiter passieren muss und jeder eine andere Wartezeit liefert?

Zuerst bei allen die Wartezeit ohne Abbuchung erfragen, das Maximum nehmen, dann bei allen auf denselben Ankunftsmoment abbuchen. Limiter immer in derselben Reihenfolge durchlaufen. Überschreitet das Maximum den Schwellwert — Ablehnung ohne Abbuchung, sonst würden Ressourcen „umsonst“ reserviert.

Wie soll der Limiter auf einen IP-Wechsel per Timer reagieren, wenn ich den genauen Moment nicht kenne?

Nutze ein Ereignis oder die Abfrage der aktuellen Adresse, und wenn das Intervall bekannt ist — einen Zeitplan mit Puffer. In Proxeon sind sowohl der Wechsel per Timer als auch per Link/API reguläre Modi (Stand 22.09.2026), und wenn du eine exakte Synchronisation brauchst, ist der Link-Modus vorzuziehen: Dann bestimmst du den Wechselmoment selbst und öffnest eine neue Epoche in deiner Registry genau dann, wenn die Umschaltung bestätigt ist.

Warum darf man nicht alle Limits nach einem Adresswechsel zurücksetzen?

Weil der Server die Quote nach mehreren Merkmalen gleichzeitig zählen kann. Die Adresse hat sich geändert — die Quote pro IP beginnt neu, aber die Quote pro Token, Account oder Session läuft weiter. Setzt du alles zurück, verletzt du die Richtlinien, die nicht von der Adresse abhängen. Die Rotation darf nur die Ebene „pro IP“ in der Hierarchie betreffen.

Was ist für einen verteilten Limiter besser — Token Bucket oder GCRA?

GCRA. Es hat einen einzigen Zustandswert, der leichter atomar zu aktualisieren und einfacher mit TTL zu speichern ist. Token Bucket braucht zwei Werte und etwas komplexere Nachfülllogik, was das atomare Skript erschwert. Semantisch liefern beide dasselbe Ergebnis.

Wie prüft man, dass der Limiter richtig funktioniert, bevor er in die Produktion geht?

Schreib einen Test mit austauschbaren Uhren: Gib Anfragen zu vordefinierten Momenten ein und vergleiche die Entscheidungen mit der Referenzsequenz. Prüfe Randfälle: Nullzeit, lange Ruhe, gleichzeitiges Eintreffen vieler Anfragen, Kosten größer als die Kapazität (muss eine explizite Ablehnung sein, kein endloses Warten). Teste separat die Komposition: zwei Limiter mit unterschiedlichen Geschwindigkeiten und die Prüfung, dass keiner mehr als seine Quote durchlässt.

Fazit: Was du als Nächstes tun solltest

Ein clientseitiges Rate Limit ist keine Bremse, sondern ein Steuerungssystem. Ein richtig gebauter Limiter tut drei Dinge: Er lässt es nicht zur Ablehnung kommen, nutzt das verfügbare Budget gleichmäßig und sagt dem Scheduler, wohin und wann die nächste Anfrage gehen soll. Im Kern steht nur eine Formel, ob Token Bucket oder GCRA, aber man muss sie mit Disziplin umgeben: monotone Uhren, Reservierung unter Sperre, maximale Verzögerung, Schlüssel-Hierarchie und Verdrängung.

Kurze Zusammenfassung:

  • Fixed Window ist einfach, aber an den Grenzen tückisch; bevorzuge Token Bucket oder GCRA.
  • Token Bucket gibt getrennte Kontrolle über Geschwindigkeit und Ausbruch; GCRA — dasselbe in einer einzigen Zustandszahl.
  • Der Limit-Schlüssel wiederholt die Merkmale, nach denen der Server zählt; Limiter werden in einer Hierarchie angeordnet und über peek — Maximum — einheitliche Abbuchung komponiert.
  • Die Adress-Rotation ändert nur die Ebene „pro IP“; der Rotationsbefehl verdient selbst einen eigenen Eimer.
  • Metriken von Wartezeit und Ablehnungen sind der einzige ehrliche Weg, um zu verstehen, wie stark deine Richtlinie mit der serverseitigen übereinstimmt.

Deine nächsten Schritte: Wähle eine einheitliche Engine (wir empfehlen GCRA), beschreibe die Richtlinien bekannter Hosts in der Konfiguration, füge einen konservativen Standard hinzu, schalte die Metriken ein und führe Tests mit austauschbaren Uhren durch. Arbeitest du über einen Adresspool, füge die Epoche in den Schlüssel ein und einen eigenen Eimer für den Wechselbefehl. Danach wirkt dein Client für jeden Server wie der höflichste Gast — derjenige, dem nie etwas abgelehnt wird.