Einleitung: Warum Timeouts über Proxys eine eigene Betrachtung verdienen

Stellen Sie sich vor: Ihr Scraper läuft seit drei Tagen durch, verbraucht Traffic mobiler Proxys, und am Ende stehen zur Hälfte leere Datensätze im Ergebnis, während die Logs voll sind mit Wörtern wie timeout, connection reset und remote end closed connection. Kommt Ihnen bekannt vor? Wir haben dutzende solcher Systeme gesehen, und fast immer ist die Ursache dieselbe: Die Timeouts sind nach Gefühl gesetzt – eine magische Zahl wie 30 Sekunden für alles gleichzeitig. Über eine direkte Verbindung funktioniert das gerade noch. Über einen Proxy, besonders einen mobilen, nicht mehr.

Der Grund: Ein Proxy fügt der Kette ein weiteres Netzsegment, eine weitere Warteschlange und einen weiteren Knoten hinzu, der eigene Timeouts hat. Eine Anfrage durchläuft nicht eine Wartephase, sondern fünf bis sechs, und in jeder kann sie aus unterschiedlichen Gründen hängen bleiben. Ein einziger gemeinsamer Grenzwert unterscheidet nicht, wo genau es klemmt: beim TCP-Handshake mit dem Proxy, beim Aufbau des Tunnels zum Zielserver, beim langsamen ersten Byte der Antwort oder bei der Übertragung eines großen Bodys.

Dieser Artikel handelt von der Architektur des Wartens. Wir schlüsseln auf, aus welchen Phasen eine HTTP-Anfrage über einen Proxy besteht, welcher Timeout für welche Phase zuständig ist, was physisch passiert, wenn er ausgelöst wird, und wie Sie aus einzelnen Grenzwerten ein stimmiges Gesamtbudget zusammenstellen. Wichtig ist die Abgrenzung zu einem verwandten Thema: Hier geht es nicht um Statuscodes wie 429 oder 503 und um Retry-Strategien mit exponentiellem Backoff. Das ist eine eigene Ebene – die Reaktion darauf, dass der Server bereits geantwortet hat. Hier geht es um Situationen, in denen gar keine Antwort kommt, und darum, wie lange wir auf jeder Ebene bereit sind zu warten.

Nach der Lektüre können Sie: jede Anfrage in Phasen zerlegen und jeder Phase einen eigenen Grenzwert zuweisen; erklären, warum der Client einen Timeout gemeldet hat, der Server die Aktion aber trotzdem ausgeführt hat; die Timeouts von Client, Connection-Pool und Proxy korrekt aufeinander abstimmen; und vor allem aufhören, Daten und Geld durch nutzloses Warten zu verlieren.

Grundlagen: Was ein Timeout ist und aus welchen Phasen eine Anfrage besteht

Timeout als Vertrag über das Warten

Ein Timeout ist die maximale Zeit, die ein Client bereit ist auf ein bestimmtes Ereignis zu warten, bevor er den Versuch als gescheitert betrachtet und Ressourcen freigibt. Das Schlüsselwort ist bestimmtes. Es gibt kein Konzept wie „Timeout einer Anfrage allgemein". Es gibt einen Timeout für den Aufbau der TCP-Verbindung, einen für den TLS-Handshake, einen für das Warten auf Daten vom Socket, einen für das Schreiben in den Socket, einen für das Warten auf eine freie Verbindung im Pool und schließlich eine Gesamt-Deadline für die gesamte Operation.

Eine gute Analogie ist eine Reise mit Umstiegen. Sie haben Zeit für den Weg zum Bahnhof, Wartezeit auf den Zug, Fahrzeit, Umsteigezeit. Und es gibt ein Gesamtlimit: Um neun Uhr morgens müssen Sie beim Termin sein. Wenn Sie nur das Gesamtlimit kontrollieren, erfahren Sie vom Problem erst, wenn Sie bereits zu spät sind. Wenn Sie jede Etappe kontrollieren, können Sie früher entscheiden: zum Beispiel ein Taxi nehmen, weil der Bus zehn Minuten nicht gekommen ist.

Die Phasen einer HTTP-Anfrage über eine direkte Verbindung

Auch ohne Proxy ist eine Anfrage eine Abfolge von Schritten:

  1. Namensauflösung (DNS). Der Client wandelt den Domainnamen in eine IP-Adresse um. Normalerweise dauert das Millisekunden bis wenige hundert Millisekunden, bei einem Problem mit dem Resolver kann es aber Sekunden hängen.
  2. TCP-Verbindung. Drei-Wege-Handshake: SYN, SYN-ACK, ACK. Erfordert einen vollständigen Round Trip (RTT) zum Server.
  3. TLS-Handshake für HTTPS. Ein bis zwei weitere Round Trips, je nach Protokollversion.
  4. Senden der Anfrage (write). Header und Body werden in den Socket geschrieben. Bei kleinen Anfragen sofort, bei Datei-Uploads merklich langsam.
  5. Warten auf das erste Byte der Antwort (TTFB). Der Server denkt nach: führt Datenbankabfragen aus, rendert die Seite, ruft seine Microservices auf.
  6. Lesen des Antwort-Bodys (read). Die Daten kommen in Portionen an; zwischen den Portionen gibt es Pausen.

Was der Proxy hinzufügt

Der Proxy zerbricht diese Kette in zwei Teile. Der Client baut eine Verbindung zum Proxy-Server auf, und der Proxy baut selbst eine Verbindung zum Zielknoten auf. Für HTTPS über einen HTTP-Proxy wird die Methode CONNECT verwendet: Der Client bittet den Proxy, einen TCP-Tunnel zum Host und Port zu öffnen, der Proxy antwortet mit Status 200, und erst danach beginnt der Client den TLS-Handshake direkt mit dem Zielserver durch den Tunnel. Bei SOCKS5 ist die Logik analog: Es gibt eine Begrüßungs- und Authentifizierungsphase mit dem Proxy, dann den Befehl, eine Verbindung zum Ziel aufzubauen, dann das Warten auf die Bestätigung.

Daraus ergibt sich eine erweiterte Phasenliste:

  1. DNS-Auflösung der Adresse des Proxys (falls dieser als Domainname angegeben ist).
  2. TCP-Verbindung zum Proxy.
  3. Authentifizierung und Befehl zum Aufbau des Tunnels (CONNECT oder SOCKS-Anfrage).
  4. Warten, bis der Proxy den Zielhost auflöst und mit diesem eine TCP-Verbindung aufbaut – diese Phase läuft auf der Seite des Proxys, aber der Client wartet darauf.
  5. TLS-Handshake mit dem Zielserver durch den Tunnel.
  6. Senden der HTTP-Anfrage.
  7. Warten auf das erste Byte der Antwort.
  8. Lesen des Bodys.

Achten Sie auf Punkt vier. Genau hier liegt die größte Falle bei mobilen Proxys. Der Proxy-Server selbst steht meist im Rechenzentrum, und die TCP-Verbindung zu ihm steht in dutzenden Millisekunden. Aber danach geht der Traffic über ein Mobilfunkmodem, wo der RTT bei 40–120 Millisekunden liegt und bei überlasteter Basisstation auf eine halbe Sekunde und mehr springt. Namensauflösung und Handshake mit dem Ziel können in diesem Abschnitt leicht ein bis zwei Sekunden dauern. Ein Client, der seinen sogenannten Connect-Timeout nur bis zum Proxy rechnet, ist überzeugt, dass die Verbindung blitzschnell aufgebaut ist, und stößt dann auf unerklärliches Warten im nächsten Schritt.

Tiefe Analyse: Was physisch passiert, wenn jeder Timeout ausgelöst wird

Einen Wert einzustellen ist nur die halbe Miete. Wichtiger ist zu verstehen, in welchem Zustand das System bleibt, nachdem der Grenzwert ausgelöst wurde. Gehen wir die Phasen durch.

Auslösen des Connect-Timeouts

Der Client hat ein SYN gesendet und innerhalb der vorgegebenen Zeit kein SYN-ACK erhalten. Das Betriebssystem wiederholt das SYN dabei selbst nach einem exponentiellen Schema: 1, 2, 4, 8 Sekunden und so weiter, insgesamt je nach Kernel standardmäßig bis zu 60–120 Sekunden. Ihr Connect-Timeout bricht dieses Warten früher ab. Der Socket wird geschlossen, es sind keine Daten zum Server gegangen, der Zustand auf der Gegenseite hat sich nicht verändert. Das ist die sicherste Art von Timeout: Ein erneuter Versuch ist bedenkenlos möglich, ohne die Idempotenz zu gefährden.

Über einen Proxy ist das Bild etwas komplexer. Wenn TCP zum Proxy aufgebaut ist, aber die CONNECT-Phase hängt, hat der Client dem Proxy bereits den Befehl geschickt und wartet auf den Status. Beim Auslösen schließt der Client den Socket zum Proxy. Der Proxy bemerkt das Schließen und bricht in der Regel seinen eigenen Verbindungsversuch zum Ziel ab. Aber nicht immer sofort: Manche Implementierungen warten erst ihren eigenen Upstream-Timeout ab und geben erst dann Ressourcen frei. Für den Client ist das unsichtbar, aber auf dem Proxy-Server sammeln sich halb offene Verbindungen an, was bei massiver Last seinen Durchsatz senkt.

Ein wichtiger Punkt: In verschiedenen Client-Bibliotheken wird die CONNECT-Phase unterschiedlich behandelt. Bei den einen fällt sie unter den Connect-Timeout, bei den anderen ist sie durch nichts außer der Gesamt-Deadline der Anfrage abgedeckt. Haben Sie keine Gesamt-Deadline und hängt CONNECT, kann die Anfrage unbegrenzt lange hängen. Das lässt sich leicht prüfen: Richten Sie den Client auf einen Proxy, der TCP annimmt, aber nicht auf CONNECT antwortet (ein einfacher TCP-Server ohne Logik kann als Attrappe dienen), und schauen Sie, nach wie vielen Sekunden der Client aufgibt.

Auslösen des TLS-Handshake-Timeouts

Der TCP-Tunnel über den Proxy ist offen, der Client hat ClientHello gesendet, und ServerHello kommt nicht. Ursachen: langsamer Modemkanal, Paketverlust auf dem Mobilfunkabschnitt, überlasteter Zielserver, der TCP annimmt, aber den TLS-Handshake nicht schnell genug schafft. Beim Auslösen wird der Socket geschlossen, die HTTP-Anfrage wurde noch nicht gesendet, der Zustand auf dem Server hat sich nicht verändert. Für einen erneuten Versuch ebenfalls sicher.

Eine praktische Beobachtung: Über Mobilfunkkanäle ist der TLS-Handshake ein häufiger Punkt für Verzögerungen, weil er mehrere Round Trips hintereinander benötigt und jedes verlorene Paket eine Sekunde für die Neuübertragung hinzufügt. Mit dem Übergang zu TLS 1.3 hat sich die Zahl der Round Trips verringert, was den Anteil solcher Timeouts merklich reduziert hat.

Auslösen des Write-Timeouts

Der Client schreibt den Body der Anfrage in den Socket, aber der Sendepuffer ist voll und wird nicht geleert: Die Gegenseite liest nicht oder bestätigt den Empfang nicht. Beim Auslösen könnten Teile der Daten bereits zum Server gelangt sein. Wenn es sich um einen Datei-Upload oder das Absenden eines Formulars handelt, hat der Server möglicherweise ein Fragment erhalten. In der Regel führt ein unvollständiger Body auf Serverseite zu einem Parse-Fehler, aber bei Streaming-Protokollen und mehrteiligen Uploads hängen die Folgen von der Implementierung ab. Ein erneuter Versuch einer solchen Anfrage erfordert Vorsicht.

Auslösen des Read-Timeouts

Hier beginnt der interessanteste und gefährlichste Teil. Die Anfrage wurde vollständig gesendet. Der Client wartet auf Daten, und sie kommen nicht innerhalb des vorgegebenen Intervalls. Der Client schließt den Socket und wirft eine Exception. Aber was passiert am anderen Ende?

Der Proxy sieht, dass der Client die Verbindung geschlossen hat. Ein guter Proxy schließt in diesem Moment auch die Upstream-Verbindung zum Zielserver. Aber der Zielserver hat die Anfrage bereits erhalten und verarbeitet sie bereits. Wenn es sich um ein POST handelt, das eine Bestellung anlegt, ein Guthaben abbucht oder eine Nachricht sendet, wird die Aktion mit hoher Wahrscheinlichkeit ausgeführt. Der Server erfährt vom Verbindungsabbruch erst, wenn er versucht, die Antwort zu schreiben und einen Fehler bekommt. Zu diesem Zeitpunkt ist die Datenbanktransaktion längst abgeschlossen.

Das ist die fundamentale Eigenschaft des Read-Timeouts: Er sagt Ihnen, dass Sie nicht auf die Antwort gewartet haben, aber nichts darüber, ob die Aktion ausgeführt wurde. Genau deshalb muss ein Read-Timeout bei nicht-idempotenten Operationen anders behandelt werden als ein Connect-Timeout, und genau deshalb verlangen ernsthafte APIs Idempotenzschlüssel.

Ein weiterer Aspekt – wo genau Sie hängen geblieben sind. Der Read-Timeout löst sowohl beim Warten auf das erste Byte aus (der Server denkt nach) als auch bei einer Pause zwischen Body-Portionen (der Server liefert die Daten mit Verzögerungen als Stream). Viele Bibliotheken interpretieren den Read-Timeout als Leerlaufintervall zwischen zwei erfolgreichen Lesevorgängen aus dem Socket, nicht als Gesamtlesezeit. Das bedeutet, dass eine Antwort von hunderten Megabyte, die mit einem Kilobyte pro Sekunde ankommt, niemals einen Read-Timeout von 10 Sekunden auslöst – die Daten kommen ja regelmäßig. Ohne Gesamt-Deadline kann eine solche Anfrage stundenlang hängen.

Was der Proxy sieht und was er zurückgibt

Der Proxy hat eigene Timeouts, und diese erzeugen andere Symptome. Wenn der Proxy sich nicht innerhalb seines eigenen Limits mit dem Ziel verbinden konnte, gibt er dem Client eine Antwort auf CONNECT mit Status 502 oder 504 zurück – und aus Sicht des Clients ist das kein Timeout, sondern ein Proxy-Fehler. Wenn der Proxy auf eine Antwort vom Ziel gewartet hat und nicht bekommen hat, kann er ebenfalls 504 Gateway Timeout zurückgeben, diesmal innerhalb der HTTP-Antwort (bei einfachem HTTP ohne Tunnel). Und wenn der Proxy ein Idle-Limit für den Tunnel hat und dieses auslöst, sieht der Client einen plötzlichen Verbindungsabbruch – connection reset oder eine leere Antwort – ganz ohne einen Timeout auf seiner Seite.

Daher die Regel: Der Client-Timeout muss mit den Timeouts des Proxys abgestimmt sein. Wenn der Proxy den Tunnel nach 60 Sekunden Leerlauf schließt und Ihr Read-Timeout 90 Sekunden beträgt, werden Sie nie einen Timeout sehen – Sie werden rätselhafte Abbrüche sehen. Wenn der Proxy 30 Sekunden für die Verbindung zum Ziel erlaubt und Ihr Limit für diese Phase 10 Sekunden beträgt, geben Sie früher auf und erfahren nie, dass der Proxy es hätte schaffen können.

Methode 1: Connect-Timeout mit Berücksichtigung zweier Hops konfigurieren

Theorie: Was abgedeckt wird und was abgedeckt werden sollte

Der Connect-Timeout begrenzt den Aufbau der Transportverbindung. Über einen Proxy stellt sich die Frage: Verbindung mit wem? Formal – mit dem Proxy. Praktisch – uns ist wichtig, wann wir einen fertigen Tunnel zum Ziel haben. Deshalb empfehlen wir, mit zwei getrennten Limits zu denken, auch wenn die Bibliothek nur einen Parameter bietet.

Limit des ersten Hops – TCP zum Proxy-Server. Der Proxy steht im Rechenzentrum, der RTT zu ihm ist stabil. Richtwert: 5–8 RTT, aber mindestens 2 Sekunden und höchstens 5. Wenn der Proxy nicht innerhalb von 3 Sekunden auf das SYN antwortet, ist er entweder überlastet oder nicht erreichbar, und weiter zu warten ist sinnlos; besser auf eine andere Adresse aus dem Pool umschalten.

Limit des zweiten Hops – die Zeit vom Absenden von CONNECT bis zum Empfang des Status 200. Hier wirkt der Mobilfunkkanal. Der Richtwert hängt davon ab, wo das Ziel liegt und wie gut das Mobilfunknetz ist: typischerweise 3–10 Sekunden. Wir haben beobachtet, dass das 95. Perzentil der Tunnelaufbauzeit über LTE zu populären Websites bei 1,5–2,5 Sekunden liegt und das 99. Perzentil bei 4–6 Sekunden. Ein Limit unterhalb des 99. Perzentils zu setzen bedeutet, dass Sie jede hundertste Anfrage aus eigenem Antrieb verlieren.

So messen Sie Ihre Werte

  1. Sammeln Sie eine Stichprobe von mindestens 500 Anfragen über Ihren Proxy zu den Zielhosts zu verschiedenen Tageszeiten.
  2. Loggen Sie getrennt die Zeit bis zum Aufbau der TCP-Verbindung mit dem Proxy, die Zeit bis zur Antwort auf CONNECT und die Zeit des TLS-Handshakes. Die meisten Clients können solche Metriken liefern: bei curl sind es die Variablen time_connect und time_appconnect, bei Go die Hooks von httptrace, bei Python-Clients Trace-Events oder Messungen um die Phasen herum.
  3. Erstellen Sie die Verteilung. Sie interessieren p50, p95, p99 und das Maximum.
  4. Setzen Sie das Limit auf Höhe des p99 plus 30–50 Prozent Reserve. Nicht auf dem Maximum – Ausreißer gibt es immer, und sich nach ihnen zu richten bedeutet, Ressourcen für einzelne Anomalien vorzuhalten.
  5. Überprüfen Sie die Werte quartalsweise oder bei einem Wechsel von Anbieter, Region oder Proxy-Tarif.

Praxis in verschiedenen Clients

In der Python-Bibliothek requests wird der Timeout als Tupel angegeben, wobei der erste Wert für Connect und der zweite für Read steht. Über einen Proxy deckt der erste Wert das TCP zum Proxy und in der Regel auch das Warten auf die CONNECT-Antwort ab, da der Tunnel auf demselben Socket mit demselben Limit aufgebaut wird. Beispiel:

resp = session.get(url, proxies=proxies, timeout=(5, 20))

In httpx gibt es ein eigenes Timeout-Objekt mit vier Feldern: connect, read, write und pool. Das ist das klarste Modell unter den Python-Clients:

timeout = httpx.Timeout(connect=5.0, read=20.0, write=10.0, pool=3.0)

In curl gibt es zwei zentrale Flags: --connect-timeout setzt das Limit für den Verbindungsaufbau einschließlich CONNECT und TLS, und --max-time ist die Gesamtobergrenze. In Go wird der TCP-Verbindungs-Timeout über den Dialer im Transport gesetzt, TLS über TLSHandshakeTimeout, und die CONNECT-Phase wird durch den Kontext der Anfrage begrenzt. In Java wird connectTimeout am Builder des Clients konfiguriert, und das Limit der Anfrage an der Anfrage selbst. In Node.js gibt es über undici connectTimeout, headersTimeout und bodyTimeout, plus AbortSignal für eine Gesamt-Deadline.

Checkliste zum Connect-Timeout

  • Der Wert liegt nicht unter 2 und nicht über 10 Sekunden für datacenter- bzw. mobilen Proxy.
  • Sie wissen genau, ob Ihr Client die CONNECT-Phase mit diesem Limit abdeckt.
  • Beim Auslösen wechseln Sie auf einen anderen Proxy aus dem Pool und versuchen es nicht erneut mit demselben.
  • Es ist berücksichtigt, dass das Betriebssystem das SYN selbst wiederholt – Ihr Limit muss kürzer sein als das Systemlimit.
  • Für IPv6-Hosts ist ein Fallback auf IPv4 aktiviert (Happy Eyeballs), sonst frisst ein erfolgloser IPv6-Pfad das gesamte Limit.

Methode 2: Read-Timeout als Leerlaufintervall und Schutz des ersten Bytes

Zwei verschiedene Aufgaben unter einem Namen

Der Read-Timeout löst zwei Aufgaben, und es ist sinnvoll, sie gedanklich zu trennen, auch wenn die Bibliothek nur einen Parameter bietet.

Warten auf das erste Byte. Das ist die Arbeitszeit des Servers an Ihrer Anfrage. Bei statischen Seiten – dutzende Millisekunden. Bei Suchergebnissen eines Marktplatzes mit Filtern – von einer halben bis zu mehreren Sekunden. Bei schweren Reporting-APIs – dutzende Sekunden. Über einen mobilen Proxy kommt die Kanalverzögerung auf dem Rückweg hinzu.

Pause zwischen Body-Portionen. Der Server liefert bereits Daten, aber mit Unterbrechungen: Er generiert die Seite stückweise, streamt das Ergebnis oder stößt einfach an einen engen Kanal. Wichtig ist hier nicht die Gesamtgröße, sondern die maximale Stille.

Manche Clients haben getrennte Parameter. In Go ist es ResponseHeaderTimeout für das erste Byte der Header, plus separate Mechanismen für den Body. In undici sind es headersTimeout und bodyTimeout. In den meisten Python-Clients wirkt ein einzelner Read-Timeout als Leerlaufintervall in jeder Lesephase.

So wählen Sie den Wert

  1. Bestimmen Sie die Art der Zielantworten. Eine HTML-Seite und Streaming-JSON erfordern unterschiedliche Limits.
  2. Messen Sie die TTFB über Ihren Proxy. Nehmen Sie das p99 und multiplizieren Sie mit 1,5. Beim typischen Web-Scraping über einen mobilen Kanal kommen 8–15 Sekunden heraus.
  3. Messen Sie die maximale Pause zwischen Chunks in einer Stichprobe erfolgreicher Antworten. Sie ist normalerweise um ein Vielfaches kleiner als die TTFB: 1–3 Sekunden. Wenn der Client es erlaubt – setzen Sie bodyTimeout separat und strenger.
  4. Verlassen Sie sich niemals auf den Read-Timeout als Schutz vor langsamer Auslieferung. Dafür gibt es die Gesamt-Deadline (Methode 4).

Was bei Auslösung tun

Hier entsteht die zentrale Frage: Kann man es wiederholen? Die Antwort hängt von Methode und Semantik ab:

  • GET, HEAD, OPTIONS – wiederholbar, der Serverzustand hat sich nicht geändert (sofern die Website nicht die Protokollsemantik verletzt).
  • PUT mit vollständigem Body, DELETE – formal idempotent, Wiederholung sicher.
  • POST ohne Idempotenzschlüssel – eine Wiederholung kann Duplikate erzeugen. Die richtige Reaktion: nicht blind wiederholen, sondern zuerst den Zustand mit einer anderen Anfrage prüfen oder die Operation als „Ergebnis unbekannt" für eine spätere Abgleichung markieren.
  • POST mit Idempotenzschlüssel – sicher wiederholbar, der Server gibt das Ergebnis der ersten Ausführung zurück.

Wir empfehlen dringend, in Logs und Metriken Read-Timeout vor dem ersten Byte und Read-Timeout mitten im Body zu unterscheiden. Ersterer weist häufiger auf eine Überlastung des Zielservers oder des Proxys hin; letzterer auf Kanalprobleme. Die Behandlung ist unterschiedlich: Im ersten Fall hilft eine Reduzierung der Parallelität, im zweiten ein Proxy- oder Regionswechsel.

Besonderheit mobiler Kanäle

Das Mobilfunknetz arbeitet mit variabler Verzögerung. Das Modem kann ein bis zwei Sekunden „einfrieren", wenn es zwischen Sektoren der Basisstation wechselt oder aus dem Energiesparmodus kommt. Aus Sicht des Clients sieht das wie Stille im Socket aus. Wenn Ihr Read-Timeout 2 Sekunden beträgt, werden Sie mehrere falsche Auslösungen pro Stunde an jedem Modem fangen. Wir haben beobachtet, dass eine Anhebung des Limits von 3 auf 6 Sekunden den Anteil der Timeouts bei mobilen Proxys um das 4- bis 5-fache senkte, ohne die durchschnittliche Anfragezeit merklich zu erhöhen. Sekunden des Stillstands bei seltenen Anfragen sind billiger als wiederholte Anfragen und verlorener Traffic.

Checkliste zum Read-Timeout

  • Der Wert basiert auf der gemessenen p99-TTFB über Ihren Proxy, nicht auf Intuition.
  • Sie verstehen, dass das Limit ein Leerlaufintervall ist, nicht die Gesamtlesezeit.
  • Bei nicht-idempotenten Anfragen gibt es beim Auslösen keine automatische Wiederholung ohne Prüfung.
  • In den Metriken sind Timeouts vor dem ersten Byte und innerhalb des Bodys getrennt.
  • Der Wert ist kleiner als der Idle-Timeout des Tunnels auf der Seite des Proxys.

Methode 3: Write-Timeout und der Umgang mit großen Request-Bodys

Wann das Schreiben überhaupt hängen kann

Bei den meisten Anfragen passt der Body in ein TCP-Segment und geht sofort raus – das Schreiben ist abgeschlossen, noch bevor die Daten physisch die Maschine verlassen. Der Write-Timeout wird in drei Fällen relevant: bei Datei-Uploads, beim Senden großer JSON-Arrays und bei jeder Übertragung über einen engen Kanal. Ein mobiler Proxy ist genau so ein Kanal in Senderichtung: Die typische Upload-Geschwindigkeit eines Modems ist deutlich niedriger als die Download-Geschwindigkeit, und die Puffer auf den Zwischenknoten sind begrenzt.

Die Mechanik ist folgende: Der Client ruft das Schreiben auf, die Daten landen im Sendepuffer des Sockets, der Kernel sendet sie portionsweise, sobald Bestätigungen eintreffen. Bleiben die Bestätigungen aus, füllt sich der Puffer, und der nächste Schreibvorgang blockiert. Der Write-Timeout begrenzt die Dauer dieser Blockierung.

Drei Strategien für große Bodys

Strategie A: Gesamtlimit für das Schreiben. Einfacher Ansatz: ein Write-Timeout für die gesamte Anfrage. Geeignet für Bodys bis zu einigen Megabyte. Der Wert wird aus der Schätzung abgeleitet: Body-Größe geteilt durch die minimal akzeptable Geschwindigkeit plus Reserve. Zum Beispiel 5 Megabyte bei minimal 500 Kilobyte pro Sekunde – 10 Sekunden, mit Reserve 15.

Strategie B: Limit pro Portion. Der Client schreibt den Body in Chunks und begrenzt die Zeit jedes Schreibvorgangs. So arbeiten die meisten asynchronen Clients: Der Write-Timeout bedeutet dort die maximale Pause beim Senden einer Portion. Der Wert liegt bei 3–10 Sekunden, unabhängig von der Dateigröße. Der Schutz vor langsamer Auslieferung liegt vollständig bei der Gesamt-Deadline.

Strategie C: Geschwindigkeitskontrolle. Der Client überwacht die tatsächliche Upload-Geschwindigkeit und bricht die Anfrage ab, wenn sie über N Sekunden unter einen Schwellenwert fällt. Bei curl gibt es dafür das Flagpaar --speed-limit und --speed-time. Das ist das präziseste Werkzeug: Es unterscheidet zwischen „langsam, aber es läuft" und „festgefahren".

Was beim Auslösen passiert

Ein Teil des Bodys ist bereits auf dem Server. Wenn Sie eine Datei in einer einzigen Anfrage hochgeladen haben, erhält der Server einen abgeschnittenen Body. Beim Multipart-Protokoll führt das meist zu einem Parse-Fehler und einer vollständigen Ablehnung, was sicher ist. Bei APIs mit Unterstützung für wiederaufnehmbare Uploads (tus, Chunk-Protokolle von Cloud-Speichern) ist die richtige Reaktion, beim Server den Offset abzufragen und von dort fortzufahren. Genau wiederaufnehmbare Uploads empfehlen wir für alle Bodys über 10 Megabyte über mobile Proxys: Eine einzelne lange Anfrage über einen Mobilfunkkanal ist zu anfällig für Abbrüche.

Schrittweise Konfiguration für Uploads über den Proxy

  1. Schätzen Sie die Median- und Minimalgeschwindigkeit des Uploads über Ihren Proxy. Laden Sie eine Testdatei von 5–10 Megabyte zwanzigmal zu verschiedenen Zeiten hoch.
  2. Wenn die Geschwindigkeit um mehr als das Dreifache schwankt – verwenden Sie Strategie B oder C, nicht das Gesamtlimit.
  3. Teilen Sie große Dateien in Teile von 1–5 Megabyte auf, falls der Zieldienst das unterstützt.
  4. Setzen Sie den Write-Timeout pro Portion auf 5–10 Sekunden.
  5. Ergänzen Sie ihn unbedingt durch eine Gesamt-Deadline für die Anfrage, berechnet aus Größe und Minimalgeschwindigkeit.
  6. Bestimmen Sie beim Auslösen, was der Server tatsächlich empfangen hat, statt alles von vorne zu wiederholen.

Methode 4: Das Gesamtbudget der Anfrage und die Weitergabe der Deadline

Warum die Summe der Einzellimits noch kein Budget ist

Angenommen, Sie haben Connect 5, TLS 5, Write 10, Read 15 Sekunden gesetzt. Es scheint, dass eine Anfrage nicht länger als 35 Sekunden dauern kann. Aber der Read-Timeout ist ein Leerlaufintervall. Eine Antwort, die alle 14 Sekunden ein Kilobyte liefert, verletzt ihn nie. Eine Anfrage von 10 Megabyte dauert bei diesem Tempo fast einen Tag. Ohne Gesamtlimit sind Ihre Worker unbegrenzt beschäftigt, der Connection-Pool erschöpft sich, und das System steht – obwohl kein einziger Einzel-Timeout ausgelöst wurde.

Das Gesamtbudget (Deadline, Total Timeout) ist eine absolute Obergrenze für die gesamte Operation vom ersten Systemaufruf bis zum letzten gelesenen Byte. Es ersetzt die Einzellimits nicht, sondern ergänzt sie: Die Einzellimits liefern eine schnelle und präzise Diagnose, das Gesamtlimit die Garantie der Beendigung.

So berechnen Sie das Budget

Gehen Sie von oben nach unten, nicht von unten nach oben. Beginnen Sie mit der Frage: Welche maximale Wartezeit auf ein Ergebnis ist für die Geschäftsaufgabe akzeptabel? Für ein interaktives Szenario (ein Nutzer wartet) – 3–10 Sekunden. Für Hintergrund-Scraping – 30–60 Sekunden. Für das Hochladen großer Dateien – berechnet aus der Größe.

Dann wird dieses Budget auf die Phasen verteilt, unter Berücksichtigung der gemessenen Verteilungen:

  • Aufbau des Tunnels über den Proxy (TCP plus CONNECT plus TLS): typischerweise 15–25 Prozent des Budgets.
  • Schreiben der Anfrage: 5–10 Prozent bei normalen Anfragen.
  • Warten auf das erste Byte: 30–40 Prozent.
  • Lesen des Bodys: der Rest.

Beispiel: Budget 30 Sekunden für Scraping über einen mobilen Proxy. Connect (einschließlich CONNECT) 6 Sekunden, TLS 4 Sekunden, Write 3 Sekunden, Read als Leerlaufintervall 10 Sekunden, Gesamt-Deadline 30 Sekunden. Die Summe der Einzellimits von 23 Sekunden ist kleiner als das Budget – das ist normal, sie lösen einzeln aus. Die Gesamt-Deadline fängt Fälle langsamer Auslieferung ab, die kein Einzellimit fängt.

Weitergabe der Deadline durch die Kette

In verteilten Systemen ist eine Anfrage selten allein. Ihr Service hat eine Aufgabe mit einem Limit von 30 Sekunden erhalten, hat 4 Sekunden für die Vorbereitung gebraucht und geht dann über den Proxy zur Zielwebsite. Wie viel Zeit hat die HTTP-Anfrage? Nicht 30, sondern 26 Sekunden minus Reserve für die Verarbeitung der Antwort. Das ist die Weitergabe der Deadline: Jeder nachfolgende Aufruf erhält nicht einen festen Timeout, sondern den Rest des Budgets.

In Go wird das über einen Kontext mit Deadline umgesetzt, der an die Anfrage übergeben wird. In Python – über asyncio mit expliziter Übergabe der Restzeit. In Java – über die Berechnung einer Duration vor jedem Aufruf. Die Regel ist eine: Der Timeout für eine HTTP-Anfrage wird dynamisch berechnet, als Minimum aus statischem Limit und verbleibendem Budget.

Ohne das entsteht das klassische Problem: Die obere Ebene hat das Warten bereits aufgegeben und einen Fehler zurückgegeben, während die untere Ebene noch zehn Sekunden lang die Verbindung über den Proxy hält und Traffic für ein Ergebnis verbraucht, das niemand mehr braucht. Bei kostenpflichtigem Traffic mobiler Proxys ist das wörtlich Geldverbrennung.

Connection-Pool und seine eigenen Timeouts

Noch zwei Limits, die oft vergessen werden. Pool-Timeout – wie lange auf eine freie Verbindung aus dem Pool gewartet wird, wenn alle belegt sind. Ist er nicht gesetzt, warten die Anfragen bei einem Lastanstieg unbegrenzt, und äußerlich sieht das wie ein Hängen des Clients aus. Setzen Sie 1–3 Sekunden: Wenn in dieser Zeit keine Verbindung frei wird, ist das System überlastet, und es ist besser, sofort abzulehnen.

Idle-Timeout von Verbindungen im Pool – wie lange eine ungenutzte Keep-Alive-Verbindung bis zum Schließen vorgehalten wird. Hier ist die Abstimmung mit dem Proxy entscheidend. Wenn der Proxy eine Leerlaufverbindung nach 60 Sekunden schließt und Ihr Pool sie 90 Sekunden vorhält, nehmen Sie in der 61. Sekunde einen toten Socket aus dem Pool, senden eine Anfrage hinein und erhalten connection reset – keinen Timeout, sondern einen Abbruch. Viele Bibliotheken wiederholen die Anfrage in dieser Situation transparent, aber nur bei idempotenten Methoden. Die Regel: Der Idle-Timeout des Clients ist strikt kleiner als der Idle-Timeout des Proxys, mit mindestens 10–20 Prozent Reserve.

Framework „Budget von oben nach unten"

  1. Legen Sie die geschäftliche Begrenzung der Wartezeit auf das Ergebnis fest.
  2. Ziehen Sie Zeit für die eigene Verarbeitung und die Reserve für eine Wiederholung ab, falls vorgesehen.
  3. Der verbleibende Rest ist die Gesamt-Deadline der HTTP-Anfrage.
  4. Verteilen Sie ihn auf die Phasen gemäß den gemessenen p99 jeder Phase über Ihren Proxy.
  5. Prüfen Sie, dass jedes Einzellimit kleiner ist als das entsprechende Limit auf der Seite des Proxys.
  6. Setzen Sie Pool-Timeout und Idle-Timeout des Pools, abgestimmt auf den Proxy.
  7. Implementieren Sie die Weitergabe des Restbudgets an verschachtelte Aufrufe.
  8. Loggen Sie, welches Limit genau ausgelöst wurde, und die Zeit, die für jede Phase aufgewendet wurde.

Methode 5: Beobachtbarkeit von Timeouts und adaptive Konfiguration

Ohne Messungen keine Konfiguration

Alle vorherigen Methoden laufen auf eines hinaus: Sie müssen die tatsächlichen Zeitverteilungen pro Phase über Ihren Proxy kennen. Der einzige Weg, das zu erfahren, ist permanente Messung. Moderne Clients bieten Trace-Hooks: der Moment des DNS-Starts, des TCP-Aufbaus, des Empfangs der CONNECT-Antwort, des TLS-Abschlusses, des Sendens der Anfrage, des ersten Bytes, des letzten Bytes. Sammeln Sie diese Ereignisse als Metriken, aufgeschlüsselt nach Proxy, Zielhost und Fehlertyp.

Welche Metriken zu sammeln sind

  • Histogramme der Dauer jeder Phase, getrennt nach Proxy-Endpunkt und Betreiber.
  • Anteil der Auslösungen jedes Timeout-Typs an der Gesamtzahl der Anfragen.
  • Anteil der Timeouts vor dem ersten Byte gegenüber innerhalb des Bodys.
  • Anteil der Verbindungsabbrüche ohne Timeout (Anzeichen für nicht abgestimmte Idle-Limits).
  • Durchschnittliche Zeit für Anfragen, die mit Timeout endeten – das ist Ihr direkter Verlust an Traffic und Ressourcen.

Adaptive Timeouts

Ein Trend der letzten Jahre, der bis 2026 in ausgereiften Systemen zum Standard geworden ist – adaptive Limits. Statt eines statischen Werts unterhält der Client ein gleitendes Beobachtungsfenster für jedes Proxy-Ziel-Paar und setzt den Timeout auf das p99 des Fensters mit einem Reserve-Koeffizienten, begrenzt nach oben und unten durch vernünftige Grenzen. Wenn der Kanal schlechter wird, steigt das Limit und falsche Auslösungen werden seltener. Wenn der Kanal sich erholt, sinkt das Limit und das System reagiert schneller auf echte Probleme.

Die Umsetzung ist nicht schwierig: ein Ringpuffer für 200–500 letzte Messungen pro Schlüssel, Neuberechnung des Quantils alle paar Sekunden, Grenzen wie „nicht unter 3 und nicht über 20 Sekunden für Read". Wichtig ist der Schutz vor Degradation: Wenn alle Anfragen anfangen zu timeouten, füllt sich das Fenster mit Werten auf Höhe des Limits, und das Limit würde nur steigen. Deshalb gelangen nur erfolgreiche Anfragen ins Fenster, und das Wachstum des Limits ist durch die Obergrenze begrenzt.

Hedged Requests

Für Lesevorgänge über einen Pool aus mehreren Proxys gibt es einen Trick, der den Einfluss langsamer Ausreißer ohne höhere Timeouts senkt: Wenn eine Anfrage nicht innerhalb der p95-Zeit abgeschlossen ist, ein Duplikat über einen anderen Proxy senden und die zuerst eintreffende Antwort nehmen. Das erhöht den Traffic um einige Prozent, reduziert aber die p99-Latenz radikal. Es eignet sich nur für idempotente Anfragen und erfordert ein sorgfältiges Abbrechen des unterlegenen Duplikats, um keinen Traffic umsonst zu verbrauchen.

Typische Fehler: Was Sie nicht tun sollten

Eine Zahl für alles

Der häufigste Fehler. Ein einheitlicher Timeout von 30 Sekunden bedeutet, dass Sie einen toten Proxy eine halbe Minute lang entdecken und eine langsame Antwort mitten im Body nie bemerken. Trennen Sie die Phasen.

Fehlende Standard-Timeouts

Mehrere populäre Bibliotheken haben von Haus aus keine Timeouts: Eine Anfrage kann unbegrenzt hängen. In requests ist das bis heute so. Jeder Aufruf ohne expliziten Timeout über einen Proxy ist ein potenziell für immer blockierter Worker.

Read-Timeout größer als das Idle-Limit des Proxys

Sie werden keine Timeouts sehen, Sie werden Verbindungsabbrüche sehen und die Ursache an der falschen Stelle suchen. Finden Sie die Limits Ihres Proxy-Anbieters heraus und konfigurieren Sie den Client strikt darunter.

Blinde Wiederholung nach Read-Timeout bei POST

Der direkte Weg zu doppelten Bestellungen, doppelten Abbuchungen und doppelten Nachrichten. Nach einem Read-Timeout bei einer nicht-idempotenten Anfrage ist das Ergebnis unbekannt – damit muss man sich befassen, statt zu raten.

Ignorieren der CONNECT-Phase

Anzunehmen, dass der Connect-Timeout den Tunnelaufbau abdeckt, ohne das in der Dokumentation der konkreten Bibliothek zu prüfen. In manchen Clients hängt die CONNECT-Phase bis zur Gesamt-Deadline, und wenn es keine gibt – unbegrenzt.

Anpassung an das Maximum

Sie haben eine Anfrage mit 45 Sekunden gesehen und das Limit auf 60 gesetzt. Jetzt kostet Sie jedes echte Problem eine Minute Wartezeit. Orientieren Sie sich am p99 mit Reserve, und Ausreißer überlassen Sie dem Wiederholungs- oder Hedging-Mechanismus.

Timeout ohne Abbruch der darunterliegenden Arbeit

Die obere Ebene hat nach ihrem Limit eine Exception geworfen, aber die HTTP-Anfrage lebt in einer Hintergrundaufgabe weiter. Besonders häufiger Fehler in asynchronem Code: Der Wrapper mit dem Warten ist fertig, aber die Coroutine ist nicht abgebrochen. Stellen Sie sicher, dass das Auslösen eines Timeouts zum tatsächlichen Schließen des Sockets führt.

Gleiche Limits für Datacenter- und mobile Proxys

Der Unterschied bei Verzögerung und Jitter ist um ein Vielfaches groß. Ein Profil, das auf einem Server-Proxy funktioniert, erzeugt auf einem mobilen Proxy eine Flut falscher Timeouts. Halten Sie getrennte Konfigurationsprofile vor.

Fehlender Pool-Timeout

Bei einem Lastanstieg warten Anfragen unbegrenzt auf eine freie Verbindung. Äußerlich – ein Hängen des gesamten Clients bei null Netzwerkverkehr.

Werkzeuge und Ressourcen

Diagnose über die Kommandozeile

curl bleibt das Referenzwerkzeug zur Analyse der Phasen. Die Flags --connect-timeout, --max-time, --speed-limit, --speed-time decken alle Ebenen ab, und das Ausgabeformat -w mit Zeitvariablen zeigt, wie lange jede Phase gedauert hat:

curl -x http://user:pass@proxy:port --connect-timeout 5 --max-time 30 -o /dev/null -s -w "dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}" https://example.com/

Beachten Sie: Über einen Proxy zeigt die Variable time_connect die Zeit bis zum Proxy, und time_appconnect bis zum Abschluss von TLS mit dem Ziel, das heißt einschließlich CONNECT. Die Differenz zwischen ihnen ist Ihr zweiter Hop.

Client-Bibliotheken und ihre Timeout-Modelle

  • Python requests: Tupel (connect, read). Kein Write und kein Gesamt-Timeout; das Gesamtlimit wird über einen externen Wrapper oder eine Thread-Abbrechung umgesetzt.
  • Python httpx: Timeout-Objekt mit connect, read, write, pool. Kein Gesamtlimit, aber im asynchronen Modus leicht über Warten mit Limit und Abbruch hinzuzufügen.
  • Python aiohttp: ClientTimeout mit den Feldern total, connect, sock_connect, sock_read. Der einzige populäre Python-Client mit eingebautem Gesamtlimit.
  • Go net/http: Dialer.Timeout, TLSHandshakeTimeout, ResponseHeaderTimeout, ExpectContinueTimeout, IdleConnTimeout im Transport; Client.Timeout als Gesamtlimit; der Anfragekontext als dynamische Deadline.
  • Java HttpClient: connectTimeout am Client, timeout an der Anfrage (deckt bis zum Empfang der Header ab). Das Lesen des Bodys wird über den BodyHandler oder einen Wrapper begrenzt.
  • Node.js undici: connectTimeout, headersTimeout, bodyTimeout, keepAliveTimeout; Gesamtlimit über AbortSignal.timeout.

Traffic-Analyse

tcpdump und Wireshark zeigen, was tatsächlich auf der Leitung passiert ist: ob das SYN rausging, ob SYN-ACK ankam, wer als erstes FIN oder RST gesendet hat. Das ist der einzige Weg, die Frage zuverlässig zu beantworten, wer die Verbindung abgebrochen hat – ich, der Proxy oder der Server. Beim HTTPS-Inhalt ist die Sichtbarkeit begrenzt, aber die Phasen von Verbindung und Tunnel sind vollständig sichtbar.

Testumgebungen zur Reproduktion

Zur Prüfung des Client-Verhaltens bei Hängern ist ein Satz Attrappen nützlich: ein TCP-Server, der die Verbindung annimmt und schweigt (Prüfung von Connect und CONNECT); ein HTTP-Server, der mit Headern antwortet und danach schweigt (Prüfung von Read bis zum Body); ein Server, der ein Byte pro Sekunde liefert (Prüfung der Gesamt-Deadline). Solche Attrappen zu schreiben kostet eine halbe Stunde Arbeit, und die gesparte Debug-Zeit in der Produktion misst sich in Tagen. Es gibt auch Netzwerksimulationen, mit denen sich Verzögerung, Jitter und Verluste auf einem Interface hinzufügen lassen, um einen mobilen Kanal im Labor nachzubilden.

Beobachtbarkeit

Zum Standard ist das Sammeln von Metriken und Traces im OpenTelemetry-Format mit automatischer Instrumentierung der HTTP-Clients geworden. Histogramme pro Phase, Attribute mit Proxy-Identifikator und Typ des ausgelösten Limits – das ist das Minimum, ohne das die Konfiguration zum Raten wird.

Fallstudien und Ergebnisse

Fall 1: Marktplatz-Scraping über mobile Proxys

Ein Team sammelte Produktkarten über einen Pool mobiler Proxys. Ausgangskonfiguration: einheitlicher Timeout von 15 Sekunden, keine Gesamt-Deadline, Standard-Connection-Pool. Symptome: 11 Prozent der Anfragen endeten mit Fehlern, davon zwei Drittel Timeouts, ein Drittel Verbindungsabbrüche. Die durchschnittliche Dauer einer fehlgeschlagenen Anfrage betrug 14 Sekunden, das heißt jede zehnte Anfrage verbrauchte Zeit und Traffic umsonst.

Die Phasendiagnose zeigte: p99 des Tunnelaufbaus – 4,8 Sekunden, p99 der TTFB – 6,2 Sekunden, maximale Pause zwischen Chunks bei erfolgreichen Antworten – 2,1 Sekunden, Idle-Limit des Tunnels beim Anbieter – 60 Sekunden, während der Client-Pool Verbindungen 120 Sekunden vorhielt.

Die Änderungen: Connect 7 Sekunden mit Abdeckung von CONNECT, Read 9 Sekunden, Write 5 Sekunden, Gesamt-Deadline 25 Sekunden, Idle des Pools 45 Sekunden, Pool-Timeout 2 Sekunden. Trennung von Timeouts vor dem ersten Byte und innerhalb des Bodys in den Metriken.

Ergebnis nach einer Woche: Der Gesamtfehleranteil sank auf 3,4 Prozent, Verbindungsabbrüche verschwanden praktisch vollständig, die durchschnittliche Dauer eines fehlgeschlagenen Requests fiel auf 8 Sekunden. Der Traffic-Verbrauch pro Einheit gesammelter Daten sank um 19 Prozent. An der Wiederholungslogik wurde nichts geändert – nur die Timeouts.

Fall 2: Integration mit einer Payment-API und Duplikate

Ein Service sendete POST-Anfragen zum Anlegen von Zahlungsvorgängen über einen Unternehmensproxy. Read-Timeout 10 Sekunden und automatische Wiederholung bei jeder Exception. Alle paar Tage entstanden doppelte Vorgänge. Die Analyse zeigte: Die Ziel-API antwortete in Lastspitzen in 11–14 Sekunden, der Client brach wegen des Read-Timeouts ab, wiederholte die Anfrage, und beide Vorgänge wurden erfolgreich ausgeführt.

Die Lösung bestand aus drei Teilen: Der Read-Timeout wurde auf 20 Sekunden angehoben, basierend auf einem gemessenen p99 von 15 Sekunden; die Wiederholung nach Read-Timeout bei POST wurde durch eine Statusabfrage des Vorgangs über eine Client-ID ersetzt; ein Idempotenzschlüssel im Header wurde eingeführt, den die API unterstützte. Die Duplikate hörten vollständig auf. Eine separate Erkenntnis des Teams: Ein Read-Timeout bei einer nicht-idempotenten Anfrage ist kein Fehler, sondern der Zustand „Ergebnis unbekannt", der einen eigenen Behandlungszweig erfordert.

Fall 3: Upload von Mediendateien über einen mobilen Kanal

Eine Anwendung lud Videos mit 50–200 Megabyte über mobile Proxys in einer einzigen Anfrage hoch. Write-Timeout 30 Sekunden, keine Gesamt-Deadline. Symptome: Etwa 8 Prozent der Uploads brachen ab, jeder Fehlschlag bedeutete eine Wiederholung von Null, der tägliche Mehrverbrauch an Traffic erreichte dutzende Gigabyte.

Der Übergang zu Chunk-Uploads von je 4 Megabyte mit Wiederaufnahme, Write-Timeout pro Chunk 8 Sekunden, Kontrolle einer Mindestgeschwindigkeit von 100 Kilobyte pro Sekunde über 10 Sekunden, Gesamt-Deadline pro Chunk 60 Sekunden. Der Anteil vollständig gescheiterter Uploads fiel auf 0,3 Prozent, der Mehrverbrauch an Traffic für Wiederholungen sank um das 12-fache, weil nur der letzte fehlgeschlagene Chunk wiederholt wurde.

Fall 4: Hängen von CONNECT ohne Gesamt-Deadline

Ein asynchroner Scraper auf Basis einer Python-Bibliothek „fror" periodisch ein: Worker lebten, das Netzwerk schwieg, die Warteschlange bewegte sich nicht. Nach ein bis zwei Stunden wurde der Scraper manuell neu gestartet. Die Analyse zeigte: Ein Teil der Proxys im Pool nahm TCP an, antwortete aber nicht auf CONNECT. In der verwendeten Konfiguration war diese Phase durch kein Limit abgedeckt. Das Hinzufügen einer Gesamt-Deadline für die Anfrage und eines expliziten Limits für den Tunnelaufbau beseitigte die Hänger. Zusätzlich wurde ein Healthcheck der Proxys eingeführt, der speziell die CONNECT-Phase prüft und nicht nur die TCP-Erreichbarkeit.

FAQ: komplexe Fragen zu Timeouts über Proxys

Worin unterscheidet sich ein Client-Timeout von einer 504-Antwort des Proxys?

Ein Client-Timeout ist Ihre Entscheidung, nicht mehr zu warten; Proxy und Server erfahren davon erst durch das Schließen der Verbindung. Die Antwort 504 ist die Entscheidung des Proxys: Er hat selbst nicht auf den Zielserver gewartet und teilt Ihnen das in einer vollwertigen HTTP-Antwort mit. Im ersten Fall wird der Socket mit einer Exception geschlossen, im zweiten erhalten Sie eine normale Antwort mit Fehlercode. Sie müssen unterschiedlich behandelt werden: 504 bedeutet, dass der Proxy sicher lebt und das Problem weiter unten in der Kette liegt; ein Client-Timeout sagt nichts darüber aus, wo genau es hängt.

Warum braucht man über einen mobilen Proxy längere Timeouts als über einen Datacenter-Proxy?

Wegen des Jitters. Die durchschnittliche Verzögerung eines Mobilfunkkanals ist nicht so hoch, aber ihre Streuung ist enorm: Wechsel zwischen Sektoren, Energiesparmodi des Modems, Konkurrenz um die Funkressource. Der Timeout wird am Ende der Verteilung ausgerichtet, und das Ende ist bei einem mobilen Kanal um ein Vielfaches länger. Gleichzeitig sind zu lange Limits ebenfalls schädlich – sie verlangsamen die Erkennung wirklich toter Proxys. Die Balance erreicht man durch Messung des p99 plus 30–50 Prozent Reserve, nicht durch Verdopplung aller Werte.

Wie erkennt man, welcher Timeout ausgelöst wurde, wenn die Bibliothek eine allgemeine Exception wirft?

Auf drei Wegen. Erstens über die Zeit: Wenn die Exception nach einer Zeit kommt, die dem Connect-Timeout entspricht, und nicht dem Read-Timeout, kennen Sie die Phase. Zweitens über Trace-Hooks: Wenn das Ereignis „TLS abgeschlossen" eintrat, aber „erstes Byte" nicht, hängen Sie am TTFB. Drittens über Text und Typ der Exception: Viele Bibliotheken unterscheiden ConnectTimeout und ReadTimeout als eigene Klassen. Wir empfehlen, immer zu loggen, welche Phasen bis zur Exception abgeschlossen wurden – das verwandelt einen rätselhaften Timeout in eine präzise Diagnose.

Kann man eine Anfrage nach einem Write-Timeout wiederholen?

Bei GET ohne Body – ja, es ist nichts rausgegangen. Bei POST mit Body – nur, wenn Sie sicher sind, dass der Server unvollständige Bodies ablehnt. Die meisten Server tun das: Ungültiges JSON oder abgeschnittenes Multipart lösen einen Parse-Fehler aus. Aber Streaming-APIs, die mit der Verarbeitung beginnen, sobald Daten eintreffen, können Änderungen teilweise anwenden. Wenn Sie unsicher sind – prüfen Sie den Zustand vor der Wiederholung.

Wie stimmt man die Client-Timeouts auf die Timeouts des Proxy-Anbieters ab?

Fragen Sie beim Anbieter nach oder suchen Sie in der Dokumentation nach drei Werten: Limit für die Verbindung zum Zielhost, Idle-Limit des Tunnels und maximale Lebensdauer der Verbindung. Ihr Limit für den Tunnelaufbau darf nicht kleiner sein als das des Anbieters (sonst geben Sie früher auf, als der Proxy es geschafft hätte), und Ihr Read-Timeout sowie der Idle-Timeout des Pools müssen strikt kleiner sein als die Idle-Limits des Anbieters. Gibt es keine Dokumentation, messen Sie empirisch: Öffnen Sie eine Verbindung, schweigen Sie N Sekunden, versuchen Sie dann eine Anfrage zu senden, und finden Sie die Schwelle, ab der ein Abbruch kommt.

Braucht man eine Gesamt-Deadline, wenn alle Einzellimits konfiguriert sind?

Ja, unbedingt. Die Einzellimits begrenzen nicht die Gesamtzeit: Eine langsame Body-Auslieferung mit einem Kilobyte im Abstand unterhalb des Read-Timeouts kann unbegrenzt dauern. Die Gesamt-Deadline ist die einzige Garantie, dass ein Worker freikommt. Außerdem wird bei der Weitergabe des Budgets durch die Aufrufkette genau die Gesamt-Deadline nach unten gereicht, während die Einzellimits eine lokale Konfiguration bleiben.

Wie beeinflussen HTTP/2 und HTTP/3 das Timeout-Modell über Proxys?

HTTP/2 multiplexiert viele Anfragen in eine Verbindung, deshalb ist ein Read-Timeout auf Socket-Ebene kein Timeout einer einzelnen Anfrage mehr: Der Socket empfängt Daten anderer Streams, und der Stillstand einer bestimmten Anfrage fällt nicht auf. Man braucht Limits auf Stream-Ebene – die meisten HTTP/2-Clients bieten diese über die Deadline der Anfrage an. HTTP/3 über QUIC verändert auch die Verbindungsphase: Der Handshake ist mit dem kryptografischen verschmolzen, und der Connect-Timeout deckt beide ab. Über einen klassischen CONNECT-Proxy geht HTTP/3 zum Ziel in der Regel nicht durch – der Tunnel ist TCP-orientiert, und der Client fällt auf HTTP/2 oder HTTP/1.1 zurück. Erweiterungen für UDP-Tunneling über Proxys entwickeln sich, aber 2026 ist ihre Unterstützung in gängigen Clients begrenzt.

Was tun, wenn die Verbindung nach einem Timeout in den Pool zurückkehrt und die nächste Anfrage fehlschlägt?

Das ist ein Anzeichen dafür, dass der Client den Socket nicht korrekt geschlossen oder der Pool die Verbindung nicht als beschädigt markiert hat. Eine Verbindung, bei der ein Read-Timeout ausgelöst wurde, darf nicht wiederverwendet werden: In ihr können Bytes einer verspäteten Antwort liegen, die als Antwort auf die nächste Anfrage gelesen werden. Stellen Sie sicher, dass Ihr Client die Verbindung bei einem Timeout schließt und nicht in den Pool zurückgibt. In gut gestalteten Clients ist das das Standardverhalten, aber bei eigenen Wrappern und Low-Level-Arbeit mit Sockets kommt dieser Fehler regelmäßig vor.

Wie konfiguriert man Timeouts für SOCKS5-Proxys im Unterschied zu HTTP-Proxys?

Das Prinzip ist dasselbe, nur die Phasen unterscheiden sich: Statt CONNECT gibt es Begrüßung, Authentifizierung und Verbindungsbefehl, das sind zwei bis drei Round Trips zum Proxy plus die Zeit der Proxy-Verbindung zum Ziel. In den meisten Clients fällt der SOCKS-Handshake vollständig unter den Connect-Timeout. Stellen Sie sicher, dass der Wert nicht nur TCP zum Proxy berücksichtigt, sondern auch die Zeit des Verbindungsaufbaus des Proxys zum Ziel über den Mobilfunkkanal – dieselben 3–10 Sekunden.

Schlussfolgerung: Timeouts als Ingenieursdisziplin

Fassen wir zusammen. Eine HTTP-Anfrage über einen Proxy ist keine einzelne Operation, sondern eine Kette aus sieben bis acht Wartephasen, jede mit eigener Natur der Verzögerung und eigenen Folgen bei einem Abbruch. Connect- und TLS-Timeouts sind sicher: Nichts ist zum Server gegangen, ein neuer Versuch ist möglich. Der Write-Timeout hinterlässt den Server mit unvollständigen Daten. Der Read-Timeout ist der tückischste: Die Anfrage wurde zugestellt und möglicherweise ausgeführt, und Sie wissen es nicht. Die Gesamt-Deadline ersetzt die Einzellimits nicht, sondern schützt vor langsamer Auslieferung, die sie nicht fangen.

Über mobile Proxys verstärkt sich all das: Der zweite Hop verläuft über einen Kanal mit hohem Jitter, und Limits, die auf Server-Proxys abgestimmt wurden, erzeugen eine Flut falscher Auslösungen. Der einzige Weg, sie richtig zu konfigurieren, ist, die Verteilungen pro Phase über Ihren konkreten Proxy zu messen und die Limits am p99 mit Reserve zu setzen, abgestimmt auf die Limits des Proxys selbst.

Ihre nächsten Schritte:

  1. Finden Sie in Ihrem Code jeden HTTP-Aufruf über einen Proxy und prüfen Sie, ob er explizite Timeouts für alle Phasen und eine Gesamt-Deadline hat.
  2. Finden Sie heraus, ob Ihr Client die CONNECT-Phase abdeckt und wie er den Read-Timeout interpretiert – als Leerlauf oder als Gesamtzeit.
  3. Ermitteln Sie die Idle- und Verbindungslimits Ihres Proxy-Anbieters und bringen Sie die Client-Konfiguration in Einklang damit.
  4. Aktivieren Sie das Tracing der Phasen und sammeln Sie eine Woche lang Verteilungen.
  5. Berechnen Sie die Limits anhand des p99 neu, trennen Sie Profile für Datacenter- und mobile Proxys.
  6. Trennen Sie die Behandlung von Timeouts für idempotente und nicht-idempotente Anfragen.
  7. Ergänzen Sie die Metriken um den Typ des ausgelösten Limits und die Phase, in der es ausgelöst wurde.

Timeouts sind kein Parameter, den man einmal setzt und vergisst. Sie sind Teil des Vertrags Ihres Systems mit der Außenwelt, und wie jeder Vertrag erfordern sie Messungen, Überprüfung und Abstimmung der Seiten. Tun Sie das einmal systematisch – und Sie werden erstaunt sein, wie viel leiser Ihre Logs und wie viel günstiger Ihr Traffic wird.