Einleitung: Warum die Bandbreite am Proxy mehr entscheidet, als man denkt

Die meisten Gespräche über Proxys drehen sich um Anonymität, Geolokalisierung und die Frage „werde ich gebannt?“. Die Bandbreite bleibt dabei im Schatten. Dabei bestimmt genau sie, wie viele Stunden dein Parser braucht, wie viele Accounts ein Kanal verkraftet und warum ein Skript, das auf dem Testsystem perfekt lief, in der Produktion plötzlich alle zehn Minuten Timeouts spuckt.

Wir schauen uns hier ein Thema an, über das selten systematisch geschrieben wird: wie die Bandbreitenbegrenzung am Proxy aufgebaut ist, was Shaping und Policing bedeuten, wie sich das Kanal-Limit in echten Zahlen zeigt und vor allem, wie sich dein Client-Code verhält, wenn er dieses Limit berührt. Wir erzählen hier bewusst nicht die üblichen Methoden zur Bewertung der Proxy-Qualität nach. Es geht nur um die Bandbreite, ihr Limit und darum, was mit der Anwendung im Moment der Sättigung passiert.

Warum ist das gerade jetzt relevant? Bis 2026 ist die durchschnittliche Größe einer Webseite samt Ressourcen über drei Megabyte gestiegen, APIs liefern immer schwerere JSON-Antworten, und die mobilen Kanäle, auf denen mobile Proxys aufbauen, teilen sich den Funkressourcen der Funkzelle mit normalen Nutzern. Gleichzeitig setzen Betreiber und Proxy-Anbieter verstärkt Shaping auf Sitzungsebene ein, damit ein Client nicht den ganzen Kanal für sich beansprucht. Wer die Mechanik des Begrenzers nicht versteht, ist dazu verdammt, seinen Code nach Versuch und Irrtum zu schreiben.

Aus dieser Anleitung erfährst du: wie man einen Shaper anhand der Kurvenform von einem Policer unterscheidet, wie man das Limit eines einzelnen Streams und des Aggregats korrekt misst, wie man die Größe des „Eimers“ und die Tiefe der Warteschlange einschätzt, warum bei Sättigung die Latenz steigt und die Effizienz sinkt, wie man einen Client mit Backpressure und adaptiver Parallelität schreibt und wie man das Traffic-Budget statt der Anzahl der Anfragen plant. Am Ende warten Checklisten, Tools, drei ausführliche Fallbeispiele mit Zahlen und ein FAQ zu den kniffligsten Fragen.

Grundlagen: das Vokabular, ohne das es nicht weitergeht

Bandbreite, Durchsatz und Nutzgeschwindigkeit

Die Begriffe werden oft verwechselt, aber der Unterschied ist grundlegend. Bandbreite (bandwidth) ist das nominale Limit des Kanals, wie viele Bits pro Sekunde er im Idealfall durchlassen kann. Durchsatz (throughput) ist, wie viele Bits tatsächlich pro Zeiteinheit durchgehen, inklusive aller Overheads: TCP- und IP-Header, Neuübertragungen, Verschlüsselung. Nutzgeschwindigkeit (goodput) sind nur die Bytes, die bei deiner Anwendung ankommen und von ihr genutzt werden. Wenn eine 100-Megabyte-Datei in 20 Sekunden heruntergeladen wird, ist dein Goodput 5 Megabyte pro Sekunde, obwohl der Kanal wegen der Steuerinformationen 8 bis 12 Prozent mehr hätte durchlassen können.

Für die Praxis ist wichtig: Begrenzer am Proxy zählen fast immer den Throughput auf Paketebene, du siehst aber den Goodput. Zwischen beiden wird es immer eine Lücke geben.

Kanal-Limit und Begrenzungsebenen

Das Limit ist die maximale Geschwindigkeit, die der Begrenzer auf einer bestimmten Aggregationsebene erlaubt. Es gibt mehrere Ebenen, und sie stapeln sich wie Matrjoschka-Puppen:

  • pro TCP-Verbindung – jeder einzelne Stream darf zum Beispiel 2 Megabit pro Sekunde nicht überschreiten, aber zehn Streams ergeben zwanzig;
  • pro Sitzung oder Proxy-Port – alle Verbindungen über einen Port teilen sich ein gemeinsames Limit;
  • pro Account – die Summe über alle Ports des Clients;
  • pro Knoten – die physische Grenze von Modem, Server, Uplink;
  • pro Betreiberkanal – was die Funkzelle in dem Moment unter Berücksichtigung der Funknetzlast hergibt.

Das tatsächliche Limit ist das Minimum über alle Ebenen. Und dieses Minimum schwankt über den Tag, weil die unterste Ebene, der Funkkanal, davon abhängt, wie viele Nutzer sich gerade in der Nähe des Modems befinden.

Token Bucket: die Mechanik fast jedes Begrenzers

Stell dir einen Eimer vor, in den mit konstanter Geschwindigkeit Jetons tropfen. Jedes Byte, das den Begrenzer passiert, entnimmt einen Jeton. Ist der Eimer leer, wartet das Byte (Shaping) oder wird verworfen (Policing). Die Tropfgeschwindigkeit ist die Rate, die Zielgeschwindigkeit. Das Volumen des Eimers ist der Burst, der erlaubte Ausbruch nach oben. Solange der Eimer voll ist, kannst du einen Datenstoß schneller als nominell senden. Danach pegelt sich die Geschwindigkeit auf die Rate ein.

Dieses Modell erklärt erstaunlich viel. Warum laufen die ersten zwei Sekunden eines Downloads schneller als der Rest? Der Eimer war voll. Warum stoßen kurze Anfragen fast nie ans Limit? Sie passen in das Eimervolumen. Warum fällt ein langer Download plötzlich auf genau eine Zahl zurück? Der Eimer ist leer, es wirkt die reine Rate.

Shaping gegen Policing

Ein Shaper stellt überschüssige Pakete in eine Warteschlange und gibt sie mit der vorgegebenen Geschwindigkeit aus. Der Traffic wird geglättet, es gibt kaum Verluste, aber die Latenz steigt: Das Paket wartet auf seinen Platz in der Schlange. Ein Policer hält keine Warteschlange, er verwirft einfach alles, was das Limit überschreitet. Die Latenz steigt nicht, dafür sieht TCP Verluste, senkt das Fenster drastisch, beschleunigt dann wieder, und die Geschwindigkeitskurve wird zur Sägezahnkurve.

Analogie: Ein Shaper ist eine Ampel mit einstellbarer Grünphase, alle fahren durch, aber langsamer. Ein Policer ist der Abschleppwagen, der jedes Auto über der Norm entfernt. Der Verkehrsfluss ruckelt dabei. Für deinen Code ist der Unterschied gewaltig, und darauf kommen wir zurück.

Die Besonderheiten mobiler Kanäle

Ein mobiler Proxy sitzt auf einem Mobilfunkkanal. Hier wird das Limit nicht nur durch Servereinstellungen bestimmt, sondern auch durch Physik: Modemkategorie, Frequenzband, Anzahl der Nutzer in der Funkzelle, Signalqualität. Dazu kommt, dass der Betreiber selbst eine Priorisierung des Traffics auf Ebene der Serviceklassen vornimmt. Das Ergebnis: Die Bandbreite eines mobilen Kanals ist um eine Größenordnung instabiler als bei einem Serverkanal, und jede Messmethode muss den Zeitfaktor berücksichtigen.

Deep Dive: Was im Moment der Sättigung passiert

Der Moment der Wahrheit: Die Warteschlange wächst

Solange dein Traffic unter dem Limit bleibt, ist der Begrenzer praktisch unsichtbar. Die Probleme beginnen, wenn die Summe der Streams die Rate überschreitet. Beim Shaper beginnt die Warteschlange zu wachsen. Jedes Paket wartet vor dem Weiterversand im Puffer. Ist der Puffer tief – und solche Puffer werden gerne auf billiger Netzwerktechnik und in Softwarebegrenzern mit großzügigen Einstellungen verbaut –, kann die Latenz von 60 Millisekunden auf eineinhalb Sekunden steigen. Dieses Phänomen heißt Bufferbloat: Ein aufgeblähter Puffer verwandelt einen schnellen Kanal in einen langsamen, zähen.

Für die Anwendung sieht das so aus: Die Downloadgeschwindigkeit scheint normal, aber jede neue Anfrage startet mit einer enormen Verzögerung. Kleine API-Aufrufe, die früher 100 Millisekunden brauchten, dauern jetzt eine Sekunde. Großzügig eingestellte Timeouts greifen plötzlich. Und das Tückischste: Du siehst keine Paketverluste, alles wird einfach nur langsam.

Die TCP-Reaktion: Warum der Congestion-Control-Algorithmus wichtig ist

TCP versucht selbst, das Kanal-Limit zu ertasten. Der klassische CUBIC-Algorithmus beschleunigt das Sendefenster, bis er einen Verlust sieht, setzt die Geschwindigkeit dann zurück und beschleunigt erneut. Mit einem Policer arbeitet CUBIC schlecht: Die Verluste sind häufig und abrupt, die Durchschnittsgeschwindigkeit kann 30 bis 40 Prozent unter dem Limit liegen. Mit einem Shaper füllt CUBIC die Warteschlange bis zum Anschlag, weil es lange keine Verluste gibt, und genau er wird zum Hauptverursacher von Bufferbloat.

Der Algorithmus BBR, der immer breiter auf Servern eingesetzt wird, verhält sich anders: Er schätzt Durchsatz und minimale RTT und versucht, die Warteschlange nicht zu überfüllen. Durch einen Shaper liefert BBR eine gleichmäßige Geschwindigkeit und moderate Latenz. Aber denk daran: Der Algorithmus auf der Seite deines Clients steuert nur den ausgehenden Stream. Der eingehende Stream vom Proxy zu dir wird von den Einstellungen des Proxy-Servers und der Zielseite bestimmt, und darauf hast du keinen Einfluss.

Ein Tunnel, viele Streams: Head-of-Line-Blocking

Wenn du über einen HTTP-Proxy per CONNECT-Methode oder über SOCKS5 arbeitest, wird jede deiner TCP-Verbindungen zur Zielseite in eine separate Verbindung zum Proxy verpackt. Wenn du HTTP/2 zur Zielseite innerhalb eines Tunnels nutzt, werden alle Anfragen in einem TCP-Stream gemultiplext. Bei Sättigung entsteht daraus Head-of-Line-Blocking: Eine schwere Antwort belegt das Fenster, und leichte Anfragen warten dahinter. Bei einer Begrenzung pro Verbindung ist das besonders schmerzhaft: Das gesamte Multiplexing teilt sich ein einziges Limit.

Die praktische Schlussfolgerung, die viele zu spät ziehen: Parallelität über einen Proxy muss auf mehreren TCP-Verbindungen aufgebaut werden, nicht auf Multiplexing innerhalb einer einzigen. Wir berücksichtigen das im Code-Abschnitt.

Fairness zwischen den Streams

Wie teilt der Begrenzer die Bandbreite zwischen deinen zehn Verbindungen auf? Ist das Limit gemeinsam und die Warteschlange eine, dann reißen die aggressiveren Streams die Bandbreite an sich, also die mit mehr Daten in der Leitung. Kleine Anfragen verlieren systematisch gegen große. Steht am Begrenzer eine faire Warteschlange, bekommt jeder Stream etwa den gleichen Anteil. Welche Variante vor dir liegt, kannst du nur experimentell herausfinden, und davon hängt ab, ob du schwere Downloads und leichte API-Aufrufe auf verschiedene Verbindungen oder sogar Ports verteilen solltest.

Slow Start und kurze Anfragen

TCP beginnt mit einem kleinen Fenster und verdoppelt es mit jeder RTT. Über einen mobilen Kanal mit etwa 80 Millisekunden RTT dauert das Hochfahren auf sagen wir 20 Megabit mehrere hundert Millisekunden. Eine Anfrage über 50 Kilobyte ist beendet, bevor TCP überhaupt hochgefahren ist. Deshalb stoßen kurze Anfragen nie an das Bandbreitenlimit, sind aber extrem latenzempfindlich. Das teilt deinen Traffic in zwei Klassen mit unterschiedlichen Regeln: schwere Streams, bei denen die Rate zählt, und leichte, bei denen die RTT zählt. Eine einzige Begrenzung erwürgt die ersten, und der Bufferbloat der ersten tötet die zweiten.

Signaturen im Diagramm

Wenn du die Geschwindigkeit pro Sekunde aufträgst, verraten sich Begrenzer durch ihre Form:

  • gleichmäßiges Plateau mit sanftem Auslauf und steigender RTT – Shaper mit tiefer Warteschlange;
  • Plateau mit einem Buckel am Anfang – Shaper oder Policer mit deutlichem Burst-Eimer;
  • Sägezahn mit Einbrüchen um 30 bis 50 Prozent, stabiler RTT, es gibt Neuübertragungen – Policer;
  • chaotische Schwankungen ohne klares Plateau – du bist nicht an den Begrenzer gestoßen, sondern an den Funkkanal oder einen überlasteten Knoten.

Diese Signaturen lesen zu können, spart Stunden beim Debugging. Weiter unten: wie man sie korrekt gewinnt.

Methode 1: das Bandbreitenlimit korrekt messen

Warum eine Methodik nötig ist und nicht eine einzelne Prüfung

Einen Dateidownload starten und auf die Zahl schauen kann jeder. Das Problem: Eine einzelne Zahl bedeutet nichts, sie hängt von der Tageszeit, der Quelle, deinem eigenen Kanal und der Slow-Start-Phase ab. Wir brauchen ein reproduzierbares Protokoll, dessen Ergebnisse sich zwischen Kanälen und Tagen vergleichen lassen.

Eine Referenzquelle vorbereiten

Erste Regel: Die Bandbreite muss gegen eine Quelle gemessen werden, die selbst garantiert schneller ist als jeder Proxy. Sonst misst du nicht den Proxy, sondern die Quelle. Ideal ist ein eigener Server an einem Standort mit garantiertem Gigabit-Uplink, auf dem Testdateien mit 20, 100 und 500 Megabyte liegen, die aus Zufallsdaten generiert wurden. Zufallsdaten sind wichtig: Eine komprimierbare Datei könnte irgendwo auf dem Weg komprimiert werden, und du bekommst eine zu hohe Zahl.

Öffentliche Testdateien beliebter CDNs kann man verwenden, aber mit einer Einschränkung: Das CDN liefert vom nächstgelegenen Knoten zum Proxy, und du misst faktisch die Bandbreite „Proxy – CDN“, nicht „Proxy – beliebige Seite“. Für die Einschätzung des Limits ist das akzeptabel, für die Bewertung des echten Goodput zu deinen Zielressourcen nicht.

Den eigenen Engpass ausschließen

Die Maschine, von der aus du misst, muss einen Kanal haben, der mindestens dreimal breiter ist als das erwartete Proxy-Limit. Prüfe das mit einem separaten Download derselben Datei direkt. Schalte Hintergrund-Downloads, Cloud-Sync und Updates ab. Wenn du Messungen aus einem Container oder einer VM heraus startest, stelle sicher, dass das virtuelle Netz die Bandbreite nicht selbst begrenzt.

Protokoll für einen einzelnen Stream

  1. Starte einen Download einer 100-Megabyte-Datei über den Proxy mit einer einzigen Verbindung und erfasse die Geschwindigkeit jede Sekunde. Mit curl geht das über die Fortschritts-Schlüssel; bequemer ist ein kleines Skript, das den Body streamend liest und die Bytes pro Sekunde aufzeichnet.
  2. Verwirf die ersten drei Sekunden – dort sind Slow Start und das Leeren des Eimers.
  3. Beende die Messung nach 40 bis 60 Sekunden oder am Ende der Datei. Weniger als 20 Sekunden reichen nicht, um den eingeschwungenen Zustand zu sehen.
  4. Berechne aus den verbleibenden Sekunden den Median, das zehnte und neunzigste Perzentil sowie den Variationskoeffizienten (Standardabweichung geteilt durch den Mittelwert).
  5. Wiederhole dreimal mit einer Pause von einer Minute.

Der Median ist dein eingeschwungenes Limit eines einzelnen Streams. Der Abstand zwischen zehntem und neunzigstem Perzentil sagt etwas über die Stabilität. Ein Variationskoeffizient unter 0,15 bedeutet einen gleichmäßigen Kanal, über 0,4 entweder einen Policer oder ein überlastetes Funknetz.

Protokoll für das Aggregat

Jetzt dasselbe, aber mit 2, 4, 8 und 16 parallelen Verbindungen zur selben Datei oder zu mehreren Dateien. Du summierst die Geschwindigkeiten pro Sekunde. So bekommst du die Abhängigkeit der aggregierten Geschwindigkeit von der Anzahl der Streams. Sie hat drei Typen:

  • lineares Wachstum bis zum Plateau – Limit pro Verbindung, das Aggregat-Limit liegt höher; das Plateau zeigt die nächste Begrenzungsebene;
  • Plateau ab dem ersten Stream – das Limit gilt gemeinsam für die Sitzung, zusätzliche Streams bringen nichts, erhöhen nur die Latenz;
  • Wachstum, dann Abfall – bei vielen Streams steigen Verluste und Overhead, der Kanal degradiert. Das Optimum liegt dort, wo das Wachstum stoppt.

Ein einzelner curl zur schnellen Orientierung sieht so aus: curl -x http://user:pass@host:port -o /dev/null -w "%{speed_download} %{time_total}" https://your-server/100mb.bin. Er liefert die Durchschnittsgeschwindigkeit über die ganze Datei, was für eine erste Einschätzung reicht, für Signaturen aber braucht man eine sekundengenaue Aufzeichnung.

Zeitliche Auflösung

Für einen mobilen Kanal ist die Messung in vier Tagesfenstern Pflicht: Nacht, Morgen, Tag, Abend. Das Limit am Abend in einem Wohngebiet kann halb so hoch sein wie nachts. Wenn du eine Rund-um-die-Uhr-Last planst, muss dein Code mit dem Abendlimit leben, nicht mit dem Nachtlimit.

Checkliste zur Limitmessung

  • Referenzquelle garantiert schneller als der Proxy, Dateien aus Zufallsdaten.
  • Eigener Kanal separat geprüft und mindestens dreimal breiter.
  • Sekundengenaue Byte-Aufzeichnung, erste drei Sekunden verworfen.
  • Dauer des eingeschwungenen Zustands mindestens 20 Sekunden.
  • Drei Wiederholungen, Median und Perzentile, Variationskoeffizient.
  • Serie nach Stream-Anzahl: 1, 2, 4, 8, 16.
  • Vier Tagesfenster für mobile Kanäle.
  • Ergebnisse in einem einheitlichen Format mit Uhrzeit, Port und Quelle festgehalten.

Methode 2: Begrenzertyp und seine Parameter bestimmen

Warum man wissen muss, was vor einem liegt

Dasselbe Limit von 10 Megabit erfordert je nach Situation unterschiedlichen Code: ob es ein Shaper oder ein Policer ist, ob es einen Burst-Eimer gibt und wie groß er ist, ob die Latenz unter Last steigt. Diese Methode verwandelt das Geschwindigkeitsdiagramm in eine Reihe von Parametern, die später in die Konfiguration deines Clients einfließen.

Burst-Test: den Eimer messen

  1. Lass den Kanal 30 Sekunden ohne Traffic ruhen, damit sich der Eimer füllt.
  2. Starte einen Download und zeichne die Geschwindigkeit in den ersten fünf Sekunden mit einer Auflösung von 100 bis 200 Millisekunden auf.
  3. Finde den Moment, in dem die Geschwindigkeit auf den eingeschwungenen Wert aus Methode 1 fällt.
  4. Das Eimervolumen schätzt du als die bis zu diesem Moment insgesamt übertragenen Bytes abzüglich dessen, was in derselben Zeit bei der eingeschwungenen Geschwindigkeit durchgelaufen wäre.

Beispiel: Die ersten 1,5 Sekunden laufen mit 40 Megabit, danach genau 10. Der Eimer ist etwa 40 minus 10, multipliziert mit 1,5 Sekunden, geteilt durch 8 – rund 5,6 Megabyte. Das bedeutet, dass Anfragen mit einem Volumen bis 5 Megabyte, durch Pausen getrennt, mit „schneller“ Geschwindigkeit durchgehen. Ein hervorragendes Werkzeug für die Planung, wenn deine Last aus mittelgroßen Antworten besteht.

Wenn es keinen Burst gibt und die Geschwindigkeit sofort mit sanftem Anstieg auf ein Plateau geht, ist der Eimer klein oder nicht vorhanden, und der Begrenzer ist wahrscheinlich ein Shaper mit harter Rate.

Latenztest unter Last

Das ist der wichtigste Test zur Unterscheidung von Shaper und Policer. Parallel zu einem langen Download startest du eine Serie leichter Anfragen über denselben Proxy-Port: zum Beispiel alle 500 Millisekunden ein HEAD an deinen Server. Du zeichnest die Antwortzeit vor, während und nach der Last auf.

  • Die Latenz ist um ein Vielfaches gestiegen, auf Hunderte Millisekunden oder Sekunden, während die Geschwindigkeit gleichmäßig bleibt – Shaper mit tiefer Warteschlange. Notiere die Tiefe: Der Latenzanstieg multipliziert mit der Rate ergibt die ungefähre Puffergröße in Bytes.
  • Die Latenz hat sich kaum verändert, aber in der Verbindungsstatistik gibt es Neuübertragungen und die Geschwindigkeit ist sägezahnförmig – Policer.
  • Die Latenz ist moderat gestiegen, um 50 bis 150 Millisekunden, die Geschwindigkeit ist gleichmäßig – Shaper mit verwalteter Warteschlange, die angenehmste Variante.

Die Statistik der Neuübertragungen unter Linux kannst du mit dem Befehl ss -ti für die entsprechende Verbindung ansehen: dort stehen Zähler für retrans und die aktuelle RTT. Das ist eine kostenlose und präzise Methode zu sehen, ob Pakete verloren gehen.

Aggregationstest: pro Verbindung oder pro Sitzung

Du hast bereits die Kurve aus Methode 1. Verfeinere sie: Starte eine Verbindung auf Vollgas und eine zweite mit einer clientseitigen Begrenzung auf 10 Prozent des Limits. Wenn die erste kaum langsamer wird, gelten die Limits getrennt pro Verbindung. Wenn die erste genau so viel verliert, wie die zweite genommen hat, ist das Limit gemeinsam. Dieser Test ist günstiger als eine Serie aus 16 Streams und liefert eine eindeutige Antwort.

Begrenzer vom Funkkanal trennen

Wie erkennt man, dass das Plateau eine Einstellung ist und nicht die Physik der Funkzelle? Drei Anzeichen für eine Einstellung: Das Plateau hält sich zu verschiedenen Tageszeiten mit einer Genauigkeit von wenigen Prozent, die Zahl ist „rund“ (5, 10, 20, 50 Megabit), und die Form des Übergangs ins Plateau ist in jeder Wiederholung gleich. Der Funkkanal liefert „unrunde“ und schwankende Werte, die von der Zeit abhängen. Zusätzlich kannst du einen zweiten Port desselben Knotens im selben Moment messen: Wenn zwei Ports zusammen mehr ergeben als einer, sitzt das Limit am Port und nicht am Modem.

Klassifizierungs-Framework

Fasse die Ergebnisse in einer Kanalkarte zusammen:

  • Limit eines einzelnen Streams: Median, Variationskoeffizient.
  • Aggregat-Limit: Wert und Anzahl der Streams, bei der er erreicht wird.
  • Ebene des Limits: Verbindung, Sitzung, Knoten.
  • Typ: Shaper oder Policer.
  • Eimer: Volumen in Megabyte oder „keiner“.
  • Warteschlangentiefe: Latenzanstieg unter Last.
  • Tagesprofil: Limits über vier Fenster.

Eine solche Karte ist der direkte Input für die Client-Konfiguration. Ohne sie tastest du die Parameter im Blindflug ab.

Methode 3: einen Client schreiben, der sich mit dem Begrenzer abstimmt

Philosophie: nicht kämpfen, sondern verhandeln

Die wichtigste Erkenntnis, die nach einem Dutzend durchdebuggter Systeme kommt: Ein Begrenzer lässt sich nicht mit vielen Streams „durchbrechen“. Man kann nur seine Warteschlange füllen und Bufferbloat ernten oder einen Policer zu massenhaften Verlusten provozieren. Ein effektiver Client hält die Geschwindigkeit selbst etwas unter dem Limit, damit die Warteschlange des Begrenzers fast leer bleibt und die Latenz niedrig ist. Das Paradoxe, das Anfänger überrascht: Senkst du die Geschwindigkeit um 10 Prozent, erhöhst du oft den Goodput, weil Timeouts und Wiederholungen verschwinden.

Komponente 1: clientseitiger Token Bucket

Implementiere bei dir denselben Eimer wie am Begrenzer, aber mit einer Rate von 85 bis 90 Prozent des gemessenen eingeschwungenen Limits und mit einem Eimervolumen, das nicht größer als die Hälfte des gemessenen Proxy-Eimers ist. Der Begrenzer wird auf das Lesen des Antwort-Bodys angewendet: Bevor du den nächsten Chunk liest, forderst du beim Eimer so viele Jetons an, wie Bytes du lesen willst, und wartest, wenn keine da sind. Die Logik Schritt für Schritt:

  1. Speichere zwei Zahlen: den aktuellen Jeton-Vorrat und den Zeitpunkt der letzten Auffüllung.
  2. Bei der Anfrage von N Jetons füllst du zuerst auf: tokens = min(burst, tokens + (now - last) * rate).
  3. Reichen die Jetons, ziehst du sie ab und machst weiter. Reichen sie nicht, berechnest du die Wartezeit (N - tokens) / rate und schläfst asynchron.
  4. Ein Eimer pro Proxy-Port, gemeinsam für alle Verbindungen über diesen Port, wenn das Limit pro Sitzung gilt. Gilt das Limit pro Verbindung, dann ein Eimer pro Verbindung plus ein gemeinsamer pro Knoten.

Warum das Lesen begrenzen und nicht die Anfragen? Weil genau das Lesen bestimmt, mit welcher Geschwindigkeit Daten aus der Warteschlange des Begrenzers gezogen werden. Liest du langsamer, als der Proxy liefert, meldet TCP dem Sender von selbst, das Fenster zu verkleinern, und die Daten stauen sich nicht mehr in Zwischenpuffern. Das ist Backpressure in Reinform.

Komponente 2: Parallelitäts-Semaphor

Begrenze die Anzahl gleichzeitiger Verbindungen pro Port mit einem Semaphor. Als Startwert nimmst du aus der Aggregat-Kurve von Methode 1 die Anzahl der Streams, bei der das Wachstum stoppte, minus eins. Für einen typischen mobilen Kanal sind das 4 bis 8. Mehr erhöht nur die Latenz.

Komponente 3: Streaming-Lesen und Fortschritts-Timeout

Setze niemals einen einzigen Timeout für die ganze Anfrage. Eine 50-Megabyte-Datei bei einem Limit von 5 Megabit lädt ehrlich 80 Sekunden, und ein Timeout von 30 Sekunden tötet sie mitten im Prozess und verschwendet die halbe Bandbreite. Der richtige Ansatz: ein Timeout für den Verbindungsaufbau (5 bis 10 Sekunden), ein Timeout für das erste Byte (10 bis 20 Sekunden unter Berücksichtigung möglichen Bufferbloats) und ein Fortschritts-Timeout – das maximale Intervall zwischen zwei erfolgreich gelesenen Chunks, üblicherweise 15 bis 30 Sekunden. Du liest den Body in Chunks von 32 bis 64 Kilobyte und aktualisierst nach jedem Chunk den Fortschritts-Marker.

Komponente 4: adaptive Parallelität nach dem AIMD-Schema

Das Limit eines mobilen Kanals schwankt, und ein statischer Semaphor folgt ihm nicht. Die Lösung: die Parallelität dynamisch nach dem Prinzip der additiven Erhöhung und multiplikativen Verringerung steuern, genau wie TCP es macht:

  1. Alle 10 Sekunden berechnest du den Goodput im Fenster und den Median der Latenz bis zum ersten Byte.
  2. Ist die Latenz niedriger als das Anderthalbfache der Basis und gibt es keine Fehler, erhöhst du das Semaphor-Limit um eins, bis zur Obergrenze.
  3. Ist die Latenz auf mehr als das Doppelte der Basis gestiegen oder sind Fortschritts-Timeouts aufgetreten, halbierst du das Limit, aber nicht unter eins.
  4. Die Basis-Latenz misst du zu Beginn bei einer Verbindung und berechnest sie einmal pro Stunde neu.

Ein solcher Controller findet in ein paar Minuten den komfortablen Punkt und hält sich dort, zieht sich abends automatisch zusammen und dehnt sich nachts aus. Wir haben gesehen, dass er den Tages-Goodput um 20 bis 35 Prozent steigerte, ohne dass sich das Limit änderte.

Komponente 5: Wiederholungen mit exponentiellem Backoff und Jitter

Ein Timeout ist ein Überlastsignal, keine Einladung zur sofortigen Wiederholung. Eine sofortige Wiederholung verschlimmert die Warteschlange. Die Regel: erste Wiederholung nach 1 bis 2 Sekunden, jede weitere doppelt so lang, maximal 5 Versuche, zu jeder Verzögerung ein zufälliger Jitter von bis zu 50 Prozent, damit zehn Streams nicht gleichzeitig aufwachen. Bei einem Fortschritts-Timeout an einer großen Datei ist es sinnvoll, mit einer Anfrage mit dem Header Range fortzufahren, wenn der Server ihn unterstützt: Die für die erste Hälfte verbrauchte Bandbreite geht dann nicht verloren.

Komponente 6: Prioritäts-Warteschlangen

Teile die Aufgaben in Klassen ein: interaktiv (leichte API-Aufrufe, bei denen die Latenz zählt) und Hintergrund (schwere Downloads). Die Hintergrundaufgaben bekommen einen Anteil am Eimer, sagen wir 70 Prozent, die interaktiven eine garantierte Reserve. Gilt das Limit pro Verbindung statt pro Sitzung, verteilst du die Klassen auf verschiedene Verbindungen. Wenn möglich, auf verschiedene Proxy-Ports. So blockiert eine schwere Datei nicht hundert kleine Anfragen.

Komponente 7: Bytes zählen, nicht Anfragen

Zähle jedes gelesene Byte pro Port, pro Klasse und pro Ziel-Domain. Exportiere das in Metriken. Genau diese Zahlen zeigen, wohin die Bandbreite fließt, und ermöglichen die Budgetplanung, um die es im nächsten Abschnitt geht.

Mini-Gerüst in Python

Das Implementierungsschema mit asyncio und einem beliebigen asynchronen HTTP-Client sieht so aus:

  1. Klasse TokenBucket mit der Methode async def take(n) nach der Logik aus Komponente 1.
  2. Klasse Channel: Proxy-Adresse, Eimer, Semaphor, Zähler, AIMD-Controller.
  3. Funktion async def fetch(channel, url): öffnet unter dem Semaphor die Anfrage über den Proxy, wartet auf die Header mit dem First-Byte-Timeout, liest dann in einer Schleife chunk = await resp.content.read(65536), ruft davor await channel.bucket.take(len(chunk)) auf, aktualisiert den Fortschritts-Marker und die Byte-Zähler.
  4. Hintergrund-Task async def tune(channel): liest alle 10 Sekunden die Metriken und passt die Größe des Semaphors an.
  5. Wrapper für Wiederholungen mit exponentiellem Backoff und Range-Unterstützung.

Wichtiges Detail für Python: Standard-Clients puffern die Antwort standardmäßig vollständig im Speicher. Stelle sicher, dass du den Streaming-Modus verwendest, sonst gibt es keine Backpressure, und der Begrenzer beim Lesen ist nutzlos. In Go baut man das Analogon auf io.Reader mit einem Limiter-Wrapper und golang.org/x/time/rate; in Node.js über Pausieren und Fortsetzen des Antwort-Streams.

Checkliste für den Client

  • Clientseitiger Eimer mit Rate 85 bis 90 Prozent des Limits.
  • Streaming-Lesen in Chunks, Limiter beim Lesen.
  • Drei getrennte Timeouts: Verbindung, erstes Byte, Fortschritt.
  • Semaphor mit adaptiver Steuerung über die Latenz.
  • Wiederholungen mit exponentiellem Backoff, Jitter und Range.
  • Trennung von interaktiven und Hintergrund-Aufgaben.
  • Parallelität über mehrere TCP-Verbindungen, nicht über Multiplexing innerhalb eines Tunnels.
  • Byte-Zählung pro Port, Klasse und Domain.

Methode 4: Traffic-Budget und Last-Architektur

In Bytes denken

Die meisten Systeme planen die Last in Anfragen pro Sekunde. Aber der Bandbreitenbegrenzer zählt Bytes. Eine Anfrage an eine API mit 4 Kilobyte und das Laden einer Seite mit 3 Megabyte unterscheiden sich um den Faktor 750. Der erste Schritt der Methode ist, deinen Plan in Bytes zu übersetzen: Wie viele Antworten welcher Größe bekommst du pro Stunde, und reicht dafür das Tagesprofil des Limits aus der Kanalkarte.

Eine einfache Formel: Die Tageskapazität des Kanals in Bytes ist die Summe über die vier Fenster des Produkts aus Limit und Dauer des Fensters, multipliziert mit dem Faktor 0,8 für Overhead und Reserve. Für einen Kanal mit einem Nachtlimit von 20 Megabit und einem Abendlimit von 8 Megabit ergibt das eine Tageskapazität von etwa 120 bis 130 Gigabyte. Wenn dein Plan 300 verlangt, hilft keine Code-Optimierung, du brauchst mehr Kanäle.

Das Volumen pro Anfrage senken

  • Komprimierung: Sende immer den Accept-Encoding-Header mit gzip und br. Textantworten schrumpfen um den Faktor 4 bis 8. Wenn dein Client die Antworten nicht automatisch entpackt, schalte das ein.
  • Überflüssige Ressourcen weglassen: Bei Browser-Automatisierung blockiere das Laden von Bildern, Schriften und Medien, wenn sie für die Aufgabe nicht nötig sind. Das spart 60 bis 80 Prozent des Seiten-Traffics.
  • Bedingte Anfragen: Speichere ETag und Last-Modified, sende If-None-Match. Eine 304-Antwort wiegt Hunderte Bytes statt Megabyte.
  • HEAD vor GET: Wenn du das Vorhandensein oder die Größe einer Ressource prüfen willst, lade sie nicht herunter.
  • Range-Anfragen: Wenn du nur einen Teil der Datei brauchst, etwa die Metadaten am Anfang, fordere den Bereich an.
  • API-Felder: Viele APIs unterstützen die Auswahl der Antwortfelder. Fordere nur die nötigen an.

Verteilung über die Kanäle

Wenn es mehrere Kanäle gibt, teile die Aufgaben nicht gleichmäßig auf. Teile sie proportional zum aktuellen Limit auf, das du laufend über den Goodput jedes Kanals misst. Der Scheduler hält eine Aufgabenwarteschlange und gibt die nächste an den Kanal, dessen Eimer leerer und dessen Latenz niedriger ist. Ein Kanal, der in die Degradation gerät, bekommt automatisch weniger Arbeit, ohne manuelles Eingreifen.

Zeitliche Planung

Verlege umfangreiche Hintergrundaufgaben in die Nachtfenster, wenn das Limit höher ist. Interaktive und dringende Aufgaben verteile gleichmäßig, aber mit Bandbreitenreserve. Das klingt banal, aber in der Praxis baut kaum jemand einen Scheduler mit Blick auf das Tagesprofil des Kanals. Der Unterschied im Tages-Goodput bei einer solchen Planung liegt bei bis zu 40 Prozent bei derselben Kanalmenge.

Eine Sicherung

Baue in den Client eine harte Sicherung ein: Wenn der Goodput eines Kanals in den letzten zwei Minuten unter 20 Prozent des Medians der Karte fällt und die Latenz um mehr als das Vierfache steigt, wird der Kanal für 5 Minuten aus der Rotation genommen. Das schützt davor, dass eine überlastete Funkzelle oder ein problematischer Knoten das ganze System in endlose Wiederholungen zieht.

Checkliste für das Budget

  • Der Plan ist in Bytes pro Aufgabenklasse übersetzt.
  • Die Tageskapazität der Kanäle ist nach dem Profil mit 20 Prozent Reserve berechnet.
  • Komprimierung, Blockieren überflüssiger Ressourcen, bedingte Anfragen und Range sind angewendet.
  • Der Scheduler verteilt nach aktuellem Goodput, nicht gleichmäßig.
  • Umfangreiche Aufgaben sind in Fenster mit hohem Limit verschoben.
  • Die Sicherung nach Goodput und Latenz ist eingerichtet.

Typische Fehler: was man auf keinen Fall tun sollte

Streams hinzufügen, bis es schneller wird

Der häufigste Fehler. Bei einem gemeinsamen Limit pro Sitzung verlängern zusätzliche Streams nur die Warteschlange des Shapers. Die Geschwindigkeit steigt nicht, die Latenz steigt, die Timeouts prasseln. Beim Policer steigen die Verluste, und das Aggregat kann sogar fallen. Wachsende Parallelität ist nur bis zu dem Punkt gerechtfertigt, an dem die Aggregat-Kurve auf ein Plateau geht.

Ein Timeout für die ganze Anfrage

Tötet ehrlich laufende große Downloads mitten im Prozess und verschwendet Bandbreite. Nutze das Fortschritts-Timeout.

Sofortige Wiederholungen

Bei Überlast verdoppelt eine Wiederholung ohne Pause die Last auf die Warteschlange. Zehn Streams, die gleichzeitig wiederholen, veranstalten einen kleinen Sturm. Exponentieller Backoff und Jitter sind Pflicht.

Das Limit mit einer einzigen Messung bestimmen

Eine Zahl um 14 Uhr am Dienstag sagt nichts über das Verhalten des Kanals um 20 Uhr am Freitag aus. Ohne Tagesprofil überlastest du den Kanal entweder nicht oder baust das System auf nicht vorhandener Bandbreite.

Gegen eine langsame Quelle messen

Ein öffentlicher Server mit ausgelastetem Uplink zeigt dir sein Limit, nicht das des Proxys. Prüfe die Quelle direkt.

Die Antwort komplett puffern

Ohne Streaming-Lesen gibt es keine Backpressure. Der Client „schluckt“ alles, was der Proxy liefert, und der Limiter im Client funktioniert nicht. Dazu kommt Speicher für große Antworten.

Alles in einen Tunnel multiplexen

HTTP/2 innerhalb eines CONNECT teilt bei einem Limit pro Verbindung die Bandbreite zwischen allen Anfragen und erzeugt Head-of-Line-Blocking. Mehrere TCP-Verbindungen sind über einen Proxy fast immer effizienter.

Komprimierung ignorieren

Ein abgeschaltetes Accept-Encoding bedeutet, dass du mit Bandbreite für unkomprimierten Text bezahlst. Ein Faktor fünf an einer leeren Stelle.

Bandbreite mit Latenz verwechseln

Ein Kanal mit 50 Megabit und 400 Millisekunden RTT ist für hundert kleine API-Aufrufe langsamer als ein Kanal mit 10 Megabit und 60 Millisekunden RTT. Bewerte beide Parameter für dein Traffic-Profil.

Anfragen zählen statt Bytes

Die Planung in Anfragen pro Sekunde berücksichtigt die Antwortgrößen nicht und führt zu einem unerwarteten Anschlag ans Limit.

Tools und Ressourcen

Zum Messen

  • curl – das universelle Werkzeug für schnelle Messungen über einen Proxy. Der Ausgabe-Schlüssel für Zeitvariablen liefert Durchschnittsgeschwindigkeit, Zeit bis zum ersten Byte, Verbindungszeit. Für die sekundengenaue Aufzeichnung schreibt man leichter zehn Zeilen Python.
  • iperf3 – zur Messung der reinen Bandbreite zwischen deiner Maschine und deinem Server direkt, um den eigenen Engpass auszuschließen. Über einen HTTP-Proxy funktioniert es nicht, aber als Quellenkontrolle ist es unersetzlich.
  • ss mit dem Schlüssel -ti – Statistik der TCP-Verbindungen unter Linux: RTT, Congestion Window, Neuübertragungen, Congestion-Control-Algorithmus. Der wichtigste kostenlose Policer-Detektor.
  • tcpdump und Wireshark – wenn man genau sehen muss, was auf Paketebene passiert: Verlustmuster, Verzögerungen von Bestätigungen, Fensterverhalten.
  • mtr – Traceroute mit Verlusten pro Knoten, hilft zu verstehen, wo genau auf dem Weg zum Proxy Verluste entstehen.

Zur lokalen Emulation

Bevor du den Code an einem echten Proxy testest, baue einen Prüfstand. Unter Linux lassen sich mit dem Tool tc und den Disziplinen tbf (token bucket filter) und netem ein Shaper mit vorgegebener Rate und Burst, ein Policer, Latenz und Verluste emulieren. Du kannst die Kanalkarte lokal nachbilden und den Client beliebig oft dagegen laufen lassen, ohne Traffic zu verbrauchen und ohne von der Tageszeit abzuhängen. Entwickler, die so einen Prüfstand aufsetzen, debuggen ihren Client um ein Vielfaches schneller.

Für den Code

  • Python: asyncio, aiohttp oder httpx im Streaming-Modus, ein eigener Token Bucket in 20 Zeilen. Fertige Limiter-Bibliotheken gibt es, aber die meisten begrenzen Anfragen statt Bytes, deshalb ist eine eigene Implementierung zuverlässiger.
  • Go: das Paket rate aus der erweiterten Standardbibliothek, ein Wrapper über io.Reader zur Begrenzung des Lesens, Context mit Deadlines für Timeouts.
  • Node.js: Streaming-Antwort mit manueller Steuerung von Pause und Fortsetzen, Bibliotheken für Semaphore und Wiederholungen.

Für Observability

Exportiere Metriken für Goodput, First-Byte-Latenz, Anzahl aktiver Verbindungen, Timeouts und Wiederholungen pro Proxy-Port in ein Metrik-Sammelsystem und baue Panels. Die Signaturen des Begrenzers sind auf den Diagrammen innerhalb einer Minute sichtbar, und Anomalien des Kanals lange bevor sie die Aufgabe zum Absturz bringen. Ohne Observability lässt sich ein adaptiver Controller weder einstellen noch prüfen.

Was man lesen sollte

Die RFC-Spezifikationen zur TCP-Congestion-Control und zu Algorithmen des aktiven Queue-Managements vermitteln ein tiefes Verständnis dafür, warum Shaper sich genau so verhalten. Die Linux-Dokumentation zu den tc-Queue-Disziplinen ist ein praktisches Nachschlagewerk zur Emulation. Artikel zu Bufferbloat erklären, warum tiefe Puffer schaden und wie man auf Netzwerkebene dagegen vorgeht.

Fallbeispiele und Ergebnisse

Fall 1: Ein Katalog-Parser für einen Marktplatz, der abends „starb“

Aufgabe: täglicher Durchlauf eines Katalogs, etwa 400.000 Seiten, über acht mobile Kanäle. Symptome: Nachts erledigte das System die Arbeit in fünf Stunden, abends Timeouts bei jeder dritten Anfrage, der Tagesplan wurde nicht erfüllt.

Die Messung nach Methode 1 zeigte: Das Nachtlimit eines Kanals lag bei etwa 18 Megabit, das Abendlimit bei 6 bis 7. Methode 2: Shaper mit tiefer Warteschlange, die Latenz unter Last stieg von 90 auf 1400 Millisekunden, das Limit galt gemeinsam für die Sitzung. Der Client nutzte 32 Streams pro Kanal und einen einzigen Timeout von 20 Sekunden.

Was gemacht wurde: ein clientseitiger Eimer auf 85 Prozent des aktuellen Limits, die Start-Parallelität auf 6 mit adaptivem Controller gesenkt, der Timeout durch einen dreistufigen ersetzt, Komprimierung und Blockierung von Bildern aktiviert (Seiten wogen nun 180 Kilobyte statt 1,4 Megabyte). Ergebnis: Die Timeout-Quote am Abend fiel von 33 auf 0,4 Prozent, der Tages-Goodput stieg um 41 Prozent bei derselben Kanalmenge, der Durchlauf passt nun zu jeder Tageszeit in 7 Stunden. Am bezeichnendsten: Die Senkung der Parallelität von 32 auf 6 erhöhte die Nutzgeschwindigkeit, statt sie zu verringern.

Fall 2: Auslagerung von Mediendateien und ein Policer

Aufgabe: Herunterladen von Videos mit 40 bis 200 Megabyte von einem öffentlichen Hosting-Dienst über einen Proxy, etwa 2 Terabyte pro Monat. Symptome: ruckelige Geschwindigkeit, im Durchschnitt halb so hoch wie angegeben, häufige Abbrüche mitten in der Datei.

Die Messung zeigte einen klassischen Sägezahn: Einbrüche um 40 bis 50 Prozent alle paar Sekunden, stabile RTT, der Neuübertragungszähler stieg auf Dutzende pro Sekunde. Ein Policer mit einem Limit pro Verbindung von etwa 12 Megabit, das Aggregat wuchs bis zu 4 Streams fast linear.

Was gemacht wurde: jede Datei per Range in vier Teile zerlegt und parallel mit vier Verbindungen geladen, jede mit einem clientseitigen Eimer auf 10 Megabit, etwas unter dem Limit des Policers, um Verluste nicht zu provozieren. Dazu Nachladen per Range bei einem Fortschritts-Timeout. Ergebnis: Die durchschnittliche Geschwindigkeit pro Datei stieg von 5,5 auf 36 Megabit, Abbrüche führten nicht mehr zum Verlust des Geladenen, das Monatsvolumen wurde in 12 statt 30 Tagen bewältigt. Einen Policer kann man nicht überlisten, aber man kann ihm den Anlass zum Verwerfen von Paketen nehmen.

Fall 3: Gemischte Last aus API und Downloads

Aufgabe: gleichzeitige Arbeit mit der API einer sozialen Plattform (Tausende kleiner Anfragen) und Hintergrund-Auslagerung von Medieninhalten über dieselben Kanäle. Symptome: API-Aufrufe gerieten zeitweise in eine Verzögerung von 3 bis 5 Sekunden, die Plattform begann, den Client als langsam zu betrachten.

Diagnose: Shaper pro Sitzung, die Hintergrund-Downloads füllten die Warteschlange, die kleinen Anfragen stellten sich dahinter an. Klassischer Bufferbloat innerhalb einer Sitzung.

Was gemacht wurde: Die Klassen wurden auf verschiedene Proxy-Ports eines Knotens verteilt; auf den Ports für Hintergrund-Downloads ein Eimer auf 70 Prozent ihres Limits, auf den API-Ports eine Parallelität von höchstens 3 und Priorität auf Latenz. Ergebnis: Das neunzigste Perzentil der API-Latenz fiel von 3,8 Sekunden auf 210 Millisekunden, die Hintergrund-Downloads wurden um 12 Prozent langsamer, was akzeptabel war. Die Gesamteffizienz des Systems, gemessen in erfolgreichen Operationen pro Stunde, stieg um 27 Prozent.

FAQ: knifflige Fragen zu Bandbreite und Shaping

Warum ist die Geschwindigkeit bei einem Stream 8 Megabit, bei zehn sind es dieselben 8, aber alles ist langsamer?

Das Limit gilt für die Sitzung, nicht für die Verbindung. Zehn Streams teilen sich eine Rate und füllen die Warteschlange des Shapers. Die Bandbreite steigt nicht, die Latenz steigt proportional zur Warteschlangentiefe. Optimal sind 2 bis 4 Streams und eine Begrenzung des Lesens im Client.

Wie erkennt man, dass man an den Funkkanal gestoßen ist und nicht an eine Proxy-Einstellung?

Eine Einstellung liefert ein stabiles Plateau mit einer „runden“ Zahl zu verschiedenen Tageszeiten und einer gleichbleibenden Übergangsform. Der Funkkanal liefert schwankende unrunde Werte und einen hohen Variationskoeffizienten, besonders abends. Vergleiche zusätzlich zwei Ports desselben Knotens gleichzeitig: Ist die Summe höher als ein Port, sitzt das Limit am Port und nicht am Modem.

Sollte man BBR auf dem eigenen Server einsetzen, wenn man über einen Proxy arbeitet?

BBR beeinflusst den ausgehenden Stream von deinem Server. Wenn du Daten über einen Proxy auslieferst, hilft es, die Warteschlange des Shapers leer zu halten und die Latenz zu senken. Auf den eingehenden Stream von den Zielseiten zu dir hat es keinen Einfluss: dort steuert der Sender. Für die Client-Seite ist ein Limiter beim Lesen wichtiger.

Wie weit unter dem Limit sollte man den clientseitigen Eimer halten?

Für einen Shaper 85 bis 90 Prozent des eingeschwungenen Limits: Die Warteschlange ist fast leer, die Latenz niedrig, der Bandbreitenverlust minimal. Für einen Policer 80 bis 85 Prozent des Limits pro Verbindung, um kein Verwerfen zu provozieren. Bei einem instabilen Funkkanal überlässt man den Punkt besser dem adaptiven Controller und setzt den Eimer nach dem Abendprofil an.

Kann man HTTP/2 über einen Proxy zur Beschleunigung nutzen?

Über einen CONNECT-Tunnel funktioniert HTTP/2 zur Zielseite, aber alle Streams teilen sich eine TCP-Verbindung und ein Limit, wenn es pro Verbindung gilt. Dazu kommt Head-of-Line-Blocking bei Sättigung. Für schwere Aufgaben liefern mehrere HTTP/1.1-Verbindungen über einen Proxy meist einen besseren Goodput und eine vorhersagbare Latenz.

Wie misst man die Größe des Burst-Eimers genauer?

Lass den Kanal 30 bis 60 Sekunden pausieren, zeichne die Bytes mit einer Auflösung von 100 Millisekunden auf, finde den Knick zur eingeschwungenen Geschwindigkeit und berechne den Überschuss über der eingeschwungenen Linie. Wiederhole das fünfmal und nimm den Median. Eine Genauigkeit von etwa 15 Prozent reicht für die Planung.

Was tun, wenn Timeouts nur bei bestimmten Domains auftreten?

Wahrscheinlich liegt der Engpass nicht am Proxy, sondern auf dem Weg vom Proxy zu dieser Domain oder an der Domain selbst. Miss in dem Moment das Limit gegen deine Referenzquelle: Ist es in Ordnung, ist die Begrenzung extern. Weise einer solchen Domain im Code eine eigene Klasse mit geringerer Parallelität und längerem First-Byte-Timeout zu.

Wie erkennt man, dass der adaptive Controller richtig arbeitet?

Auf den Diagrammen sollte die Parallelität abends sanft sinken und nachts steigen, die First-Byte-Latenz innerhalb des Eineinhalb- bis Zweifachen der Basiswerte bleiben und die Timeout-Quote unter einem Prozent liegen. Schwankt die Parallelität jede Minute zwischen Minimum und Maximum, ist das Bewertungsfenster zu kurz oder die Reaktionsschwelle zu empfindlich.

Muss man die Verschlüsselung bei der Byte-Berechnung berücksichtigen?

TLS fügt 2 bis 5 Prozent Overhead für Record-Header und Handshakes hinzu. Für die Budgetplanung reicht der Faktor 0,8 für alles zusammen mit TCP/IP. Für eine genaue Zählung zählt man die Bytes auf Socket-Ebene, nicht auf Ebene des Antwort-Bodys.

Fazit: von Vermutungen zu verwalteter Bandbreite

Wir sind den Weg von den Grundbegriffen bis zur Architektur eines Clients gegangen, der nicht mit dem Begrenzer kämpft, sondern sich mit ihm abstimmt. Fassen wir das Wichtigste zusammen.

  • Das Limit ist das Minimum über mehrere Ebenen, und für mobile Kanäle schwankt es im Tagesverlauf. Eine einzelne Zahl bedeutet nichts, man braucht ein Profil.
  • Shaper und Policer erfordern unterschiedlichen Code. Der Shaper bestraft mit Latenz, der Policer mit Verlusten. Unterscheiden lassen sie sich in zehn Minuten mit einem Latenztest unter Last und der Neuübertragungsstatistik.
  • Sättigung ist keine Frage der Geschwindigkeit, sondern der Warteschlange. Bufferbloat verwandelt einen schnellen Kanal in einen zähen und tötet kleine Anfragen, bevor die Geschwindigkeit der großen fällt.
  • Der Client muss streamend lesen, das Lesen knapp unter dem Limit begrenzen, drei getrennte Timeouts nutzen, die Parallelität adaptiv steuern und mit Verzögerung wiederholen.
  • Plane Bytes, nicht Anfragen. Komprimierung, der Verzicht auf überflüssige Ressourcen und bedingte Anfragen bringen oft mehr als jede Raffinesse mit Streams.

Was ist als Nächstes zu tun? Heute: eine Referenzquelle aufsetzen und die Kanalkarte nach den Methoden 1 und 2 zumindest für einen Port erstellen. Diese Woche: einen lokalen Prüfstand mit tc aufbauen, die Karte nachbilden und den Client nach der Checkliste aus Methode 3 neu schreiben. Innerhalb eines Monats: die Byte-Zählung aktivieren, Panels bauen und den adaptiven Controller einstellen, dann das Traffic-Budget nach Methode 4 neu berechnen.

Die Bandbreite hört genau in dem Moment auf, eine Quelle von Überraschungen zu sein, in dem man beginnt, sie zu messen und zu respektieren. Code, der mit Verständnis für den Begrenzer geschrieben ist, arbeitet nicht nur schneller. Er arbeitet vorhersagbar, und in Infrastrukturaufgaben ist Vorhersagbarkeit die wichtigste Währung.