Таймауты HTTP-клиента через прокси: connect, read, write и общий бюджет запроса
Содержание статьи
- Введение: почему таймауты через прокси заслуживают отдельного разговора
- Основы: что такое таймаут и из каких фаз состоит запрос
- Глубокое погружение: что физически происходит при срабатывании каждого таймаута
- Метод 1: настройка connect timeout с учётом двух хопов
- Метод 2: read timeout как интервал бездействия и защита первого байта
- Метод 3: write timeout и работа с большими телами запроса
- Метод 4: общий бюджет запроса и распространение дедлайна
- Метод 5: наблюдаемость таймаутов и адаптивная настройка
- Типичные ошибки: что не нужно делать
- Инструменты и ресурсы
- Кейсы и результаты
- Faq: сложные вопросы о таймаутах через прокси
- Заключение: таймауты как инженерная дисциплина
Введение: почему таймауты через прокси заслуживают отдельного разговора
Представьте: ваш парсер работает уже третьи сутки, потребляет трафик мобильных прокси, а на выходе — половина пустых записей и логи, забитые словами timeout, connection reset и remote end closed connection. Знакомо? Мы видели десятки таких систем, и почти всегда корень проблемы один: таймауты настроены «на глазок» — одно магическое число вроде 30 секунд на всё сразу. Через прямое соединение это ещё как-то работает. Через прокси, особенно мобильный, — уже нет.
Дело в том, что прокси добавляет в цепочку ещё один участок сети, ещё один набор очередей и ещё один узел, у которого есть собственные таймауты. Запрос проходит не одну фазу ожидания, а пять-шесть, и на каждой можно «зависнуть» по разным причинам. Один общий лимит не различает, где именно застряли: на TCP-рукопожатии с прокси, на установке туннеля к целевому сайту, на медленном первом байте ответа или на передаче большого тела.
Эта статья — про архитектуру ожидания. Мы разберём, из каких фаз состоит HTTP-запрос через прокси, какой таймаут отвечает за каждую фазу, что физически происходит, когда он срабатывает, и как собрать из отдельных лимитов согласованный общий бюджет. Важно сразу отстроиться от смежной темы: здесь мы не обсуждаем коды ответа 429 или 503 и стратегии повторов с экспоненциальной задержкой. Это отдельный слой — реакция на то, что сервер уже ответил. Здесь речь о ситуациях, когда ответа нет вовсе, и о том, как долго мы готовы его ждать на каждом уровне.
После прочтения вы сможете: разложить любой запрос на фазы и назначить каждой свой лимит; объяснить, почему клиент показал таймаут, а сервер всё-таки выполнил действие; правильно согласовать таймауты клиента, пула соединений и самого прокси; и, главное, перестать терять данные и деньги на бесполезном ожидании.
Основы: что такое таймаут и из каких фаз состоит запрос
Таймаут как контракт на ожидание
Таймаут — это максимальное время, которое клиент согласен ждать наступления определённого события, прежде чем признать попытку неудачной и освободить ресурсы. Ключевое слово здесь — определённого. Нет такого понятия как «таймаут запроса вообще». Есть таймаут на установку TCP-соединения, таймаут на TLS-рукопожатие, таймаут на ожидание данных от сокета, таймаут на запись в сокет, таймаут ожидания свободного соединения в пуле и, наконец, общий дедлайн всей операции.
Хорошая аналогия — поездка с пересадками. У вас есть время на дорогу до вокзала, время ожидания поезда, время в пути, время на пересадку. И есть общий лимит: к девяти утра вы должны быть на встрече. Если вы контролируете только общий лимит, вы узнаете о проблеме, когда уже опоздали. Если контролируете каждый этап, вы можете принять решение заранее: например, взять такси, потому что автобус не пришёл за десять минут.
Фазы HTTP-запроса через прямое соединение
Даже без прокси запрос — это последовательность шагов:
- Разрешение имени (DNS). Клиент превращает доменное имя в IP-адрес. Обычно занимает от единиц до сотен миллисекунд, но при проблемах с резолвером может висеть секунды.
- TCP-соединение. Трёхстороннее рукопожатие: SYN, SYN-ACK, ACK. Требует один полный круговой обход (RTT) до сервера.
- TLS-рукопожатие для HTTPS. Ещё один-два круговых обхода в зависимости от версии протокола.
- Отправка запроса (write). Заголовки и тело пишутся в сокет. Для маленьких запросов мгновенно, для загрузки файлов — заметное время.
- Ожидание первого байта ответа (TTFB). Сервер думает: выполняет запросы к базе, рендерит страницу, ходит в свои микросервисы.
- Чтение тела ответа (read). Данные приходят порциями; между порциями бывают паузы.
Что добавляет прокси
Прокси разрывает эту цепочку на две части. Клиент устанавливает соединение с прокси-сервером, а прокси уже сам устанавливает соединение с целевым узлом. Для HTTPS через HTTP-прокси используется метод CONNECT: клиент просит прокси открыть TCP-туннель до хоста и порта, прокси отвечает статусом 200, и только после этого клиент начинает TLS-рукопожатие уже с целевым сервером сквозь туннель. Для SOCKS5 логика аналогична: есть фаза приветствия и аутентификации с прокси, затем команда установить соединение с целью, затем ожидание подтверждения.
Получается расширенный список фаз:
- DNS-разрешение адреса прокси (если он задан доменом).
- TCP-соединение с прокси.
- Аутентификация и команда установить туннель (CONNECT или SOCKS-запрос).
- Ожидание, пока прокси разрешит имя целевого хоста и установит с ним TCP-соединение — эта фаза происходит на стороне прокси, но клиент её ждёт.
- TLS-рукопожатие с целевым сервером сквозь туннель.
- Отправка HTTP-запроса.
- Ожидание первого байта ответа.
- Чтение тела.
Обратите внимание на четвёртый пункт. Именно здесь кроется главная ловушка мобильных прокси. Сам прокси-сервер обычно стоит в дата-центре, и TCP-соединение до него устанавливается за десятки миллисекунд. Но дальше трафик уходит через сотовый модем, где RTT составляет 40–120 миллисекунд, а при перегруженной базовой станции скачет до полусекунды и выше. Разрешение имени и рукопожатие с целью на этом участке легко занимают одну-две секунды. Клиент, который считает «connect timeout» только до прокси, будет уверен, что соединение установлено мгновенно, а затем упрётся в непонятное ожидание на следующем шаге.
Глубокое погружение: что физически происходит при срабатывании каждого таймаута
Настроить число — полдела. Гораздо важнее понимать, в каком состоянии остаётся система после того, как лимит сработал. Разберём по фазам.
Срабатывание connect timeout
Клиент отправил SYN и не получил SYN-ACK за отведённое время. Операционная система при этом сама повторяет SYN по экспоненциальной схеме: 1, 2, 4, 8 секунд и так далее, суммарно до 60–120 секунд по умолчанию в популярных ядрах. Ваш connect timeout прерывает это ожидание раньше. Сокет закрывается, никаких данных на сервер не ушло, состояние на удалённой стороне не изменилось. Это самый безопасный вид таймаута: повторять такую попытку можно без опасений за идемпотентность.
Через прокси картина чуть сложнее. Если TCP до прокси установлен, а зависла фаза CONNECT, то клиент уже отправил прокси команду и ждёт статус. При срабатывании клиент закрывает сокет к прокси. Прокси заметит закрытие и, как правило, прервёт свою попытку соединиться с целью. Но не всегда мгновенно: некоторые реализации сначала дожидаются собственного upstream-таймаута и только потом освобождают ресурсы. Для клиента это невидимо, но на прокси-сервере накапливаются полуоткрытые соединения, что при массовой нагрузке снижает его пропускную способность.
Важный нюанс: в разных клиентских библиотеках фаза CONNECT учитывается по-разному. В одних она попадает под connect timeout, в других — не покрывается ничем, кроме общего дедлайна запроса. Если у вас нет общего дедлайна, а CONNECT завис, запрос может висеть неограниченно долго. Проверить это несложно: направьте клиент на прокси, который принимает TCP, но не отвечает на CONNECT (такой заглушкой может служить обычный TCP-сервер без логики), и посмотрите, через сколько секунд клиент сдастся.
Срабатывание TLS handshake timeout
TCP-туннель через прокси открыт, клиент отправил ClientHello, а ServerHello не пришёл. Причины: медленный канал модема, потеря пакета на мобильном участке, перегруженный целевой сервер, который принимает TCP, но не успевает обработать TLS. При срабатывании сокет закрывается, HTTP-запрос ещё не отправлен, состояние на сервере не изменилось. Тоже безопасно для повтора.
Практическое наблюдение: через мобильные каналы TLS-рукопожатие — частая точка задержек, потому что требует нескольких круговых обходов подряд, и каждый потерянный пакет добавляет секунду на повторную передачу. При переходе на TLS 1.3 количество обходов уменьшилось, что заметно снизило долю таких таймаутов.
Срабатывание write timeout
Клиент пишет тело запроса в сокет, а буфер отправки заполнен и не освобождается: удалённая сторона не читает или не подтверждает получение. При срабатывании часть данных уже могла уйти на сервер. Если это загрузка файла или отправка формы — сервер мог получить фрагмент. Обычно неполное тело приводит к ошибке разбора на стороне сервера, но для потоковых протоколов и многосоставных загрузок последствия зависят от реализации. Повтор такого запроса требует осторожности.
Срабатывание read timeout
Здесь начинается самое интересное и самое опасное. Запрос отправлен полностью. Клиент ждёт данные, и они не приходят за отведённый интервал. Клиент закрывает сокет и выбрасывает исключение. Но что происходит на другом конце?
Прокси видит, что клиент закрыл соединение. Хороший прокси в этот момент закроет и upstream-соединение к целевому серверу. Но целевой сервер уже получил запрос и уже его обрабатывает. Если это POST, который создаёт заказ, списывает баланс или отправляет сообщение, — действие с высокой вероятностью будет выполнено. Сервер узнает о разрыве только когда попробует записать ответ и получит ошибку. К этому моменту транзакция в базе давно завершена.
Это фундаментальное свойство read timeout: он говорит вам, что вы не дождались ответа, но ничего не говорит о том, выполнилось ли действие. Именно поэтому для неидемпотентных операций read timeout должен обрабатываться иначе, чем connect timeout, и именно поэтому серьёзные API требуют ключи идемпотентности.
Ещё один нюанс — где именно вы застряли. Read timeout срабатывает и при ожидании первого байта (сервер думает), и при паузе между порциями тела (сервер отдаёт данные потоком с задержками). Многие библиотеки трактуют read timeout как интервал бездействия между двумя успешными чтениями из сокета, а не как общее время чтения. Это значит, что ответ размером в сотни мегабайт, приходящий со скоростью один килобайт в секунду, никогда не вызовет read timeout в 10 секунд — данные ведь приходят регулярно. Без общего дедлайна такой запрос может висеть часами.
Что видит прокси и что он возвращает
У прокси есть собственные таймауты, и они порождают другие симптомы. Если прокси не смог соединиться с целью за свой лимит, он вернёт клиенту ответ на CONNECT со статусом 502 или 504 — и с точки зрения клиента это не таймаут, а ошибка прокси. Если прокси ждал ответ от цели и не дождался, он тоже может вернуть 504 Gateway Timeout уже внутри HTTP-ответа (для обычного HTTP без туннеля). А если у прокси есть лимит бездействия на туннеле и он сработал, клиент увидит внезапный разрыв соединения — connection reset или пустой ответ — без всякого таймаута со своей стороны.
Отсюда правило: таймаут клиента должен быть согласован с таймаутами прокси. Если прокси рвёт туннель через 60 секунд бездействия, а ваш read timeout 90 секунд, вы никогда не увидите таймаут — вы будете видеть загадочные обрывы. Если прокси даёт 30 секунд на соединение с целью, а ваш лимит на эту фазу 10 секунд, вы будете сдаваться раньше и не узнаете, что прокси мог бы успеть.
Метод 1: настройка connect timeout с учётом двух хопов
Теория: что покрывает и что должен покрывать
Connect timeout ограничивает установку транспортного соединения. Через прокси это ставит перед нами вопрос: соединение с кем? Формально — с прокси. Практически — нам важно, когда мы получим готовый туннель до цели. Поэтому мы рекомендуем мыслить двумя отдельными лимитами, даже если библиотека даёт один параметр.
Лимит первого хопа — TCP до прокси-сервера. Прокси стоит в дата-центре, RTT до него стабилен. Ориентир: 5–8 RTT, но не менее 2 секунд и не более 5. Если прокси не отвечает на SYN за 3 секунды — он либо перегружен, либо недоступен, и ждать дальше бессмысленно; лучше переключиться на другой адрес из пула.
Лимит второго хопа — время от отправки CONNECT до получения статуса 200. Здесь работает мобильный канал. Ориентир зависит от того, где находится цель, и от качества сотовой сети: типично 3–10 секунд. Мы наблюдали, что 95-й процентиль времени установки туннеля через LTE к популярным сайтам укладывается в 1,5–2,5 секунды, а 99-й — в 4–6 секунд. Ставить лимит ниже 99-го процентиля — значит терять каждый сотый запрос по собственной инициативе.
Как измерить свои значения
- Соберите выборку не менее 500 запросов через ваш прокси к целевым хостам в разное время суток.
- Логируйте отдельно время до установки TCP с прокси, время до ответа на CONNECT, время TLS-рукопожатия. Большинство клиентов умеют отдавать такие метрики: у curl это переменные time_connect и time_appconnect, у Go — хуки httptrace, у Python-клиентов — события трассировки или замеры вокруг фаз.
- Постройте распределение. Вас интересуют p50, p95, p99 и максимум.
- Установите лимит на уровне p99 плюс 30–50 процентов запаса. Не на максимуме — выбросы всегда есть, и подстраиваться под них означает держать ресурсы ради единичных аномалий.
- Пересматривайте раз в квартал или при смене оператора, региона, тарифа прокси.
Практика в разных клиентах
В Python-библиотеке requests таймаут задаётся кортежем, где первое значение — connect, второе — read. Через прокси первое значение покрывает TCP до прокси и, как правило, ожидание ответа на CONNECT, поскольку туннель устанавливается на том же сокете с тем же лимитом. Пример:
resp = session.get(url, proxies=proxies, timeout=(5, 20))В httpx есть отдельный объект Timeout с четырьмя полями: connect, read, write и pool. Это самая внятная модель среди Python-клиентов:
timeout = httpx.Timeout(connect=5.0, read=20.0, write=10.0, pool=3.0)В curl два ключевых флага: --connect-timeout задаёт лимит установки соединения, включая CONNECT и TLS, а --max-time — общий потолок. В Go таймаут набора TCP задаётся через Dialer в Transport, TLS — через TLSHandshakeTimeout, а фаза CONNECT ограничивается контекстом запроса. В Java HttpClient connectTimeout настраивается на билдере клиента, а лимит запроса — на самом запросе. В Node.js через undici есть connectTimeout, headersTimeout и bodyTimeout, плюс AbortSignal для общего дедлайна.
Чек-лист по connect timeout
- Значение не меньше 2 и не больше 10 секунд для датацентрового и мобильного прокси соответственно.
- Вы точно знаете, покрывает ли ваш клиент фазу CONNECT этим лимитом.
- При срабатывании вы переключаетесь на другой прокси из пула, а не бьётесь в тот же.
- Учтено, что ОС сама ретраит SYN — ваш лимит должен быть короче системного.
- Для IPv6-хостов включён fallback на IPv4 (Happy Eyeballs), иначе неудачный IPv6-путь съест весь лимит.
Метод 2: read timeout как интервал бездействия и защита первого байта
Две разные задачи под одним именем
Read timeout решает две задачи, и полезно их разделять мысленно, даже если библиотека даёт один параметр.
Ожидание первого байта. Это время работы сервера над вашим запросом. Для статических страниц — десятки миллисекунд. Для поисковой выдачи маркетплейса с фильтрами — от полусекунды до нескольких секунд. Для тяжёлых отчётных API — десятки секунд. Через мобильный прокси к этому добавляется задержка канала на обратном пути.
Пауза между порциями тела. Сервер уже отдаёт данные, но с перерывами: генерирует страницу по частям, стримит результат или просто упирается в узкий канал. Здесь важен не суммарный размер, а максимальная тишина.
Некоторые клиенты имеют раздельные параметры. В Go это ResponseHeaderTimeout для первого байта заголовков и отдельные механизмы для тела. В undici — headersTimeout и bodyTimeout. В большинстве Python-клиентов один read timeout работает как интервал бездействия на любом этапе чтения.
Как выбирать значение
- Определите характер целевых ответов. HTML-страница и потоковый JSON требуют разных лимитов.
- Измерьте TTFB через ваш прокси. Возьмите p99 и умножьте на 1,5. Для типичного веб-скрапинга через мобильный канал получается 8–15 секунд.
- Измерьте максимальную паузу между чанками на выборке успешных ответов. Обычно она в разы меньше TTFB: 1–3 секунды. Если клиент позволяет — задайте bodyTimeout отдельно и жёстче.
- Никогда не полагайтесь на read timeout как на защиту от медленной отдачи. Для этого есть общий дедлайн (Метод 4).
Что делать при срабатывании
Здесь возникает главный вопрос: можно ли повторить? Ответ зависит от метода и семантики:
- GET, HEAD, OPTIONS — повторять можно, состояние сервера не менялось (если сайт не нарушает семантику протокола).
- PUT с полным телом, DELETE — формально идемпотентны, повтор безопасен.
- POST без ключа идемпотентности — повтор может создать дубликат. Правильная реакция: не повторять слепо, а сначала проверить состояние другим запросом или пометить операцию как «неизвестный результат» для последующей сверки.
- POST с ключом идемпотентности — повторять безопасно, сервер вернёт результат первого выполнения.
Мы настоятельно рекомендуем в логах и метриках различать read timeout до первого байта и read timeout в середине тела. Первый чаще указывает на перегрузку целевого сервера или прокси; второй — на проблемы канала. Лечатся они по-разному: в первом случае помогает снижение параллелизма, во втором — смена прокси или региона.
Особенность мобильных каналов
Сотовая сеть работает с переменной задержкой. Модем может на секунду-две «замереть» при переключении между секторами базовой станции или при переходе из режима экономии энергии. С точки зрения клиента это выглядит как тишина в сокете. Если ваш read timeout 2 секунды — вы будете ловить ложные срабатывания несколько раз в час на каждом модеме. Мы наблюдали, что подъём лимита с 3 до 6 секунд снижал долю таймаутов на мобильных прокси в 4–5 раз без заметного роста среднего времени запроса. Секунды простоя на редких запросах обходятся дешевле, чем повторные запросы и потерянный трафик.
Чек-лист по read timeout
- Значение основано на измеренном p99 TTFB через ваш прокси, а не на интуиции.
- Вы понимаете, что лимит — это интервал бездействия, а не общее время чтения.
- Для неидемпотентных запросов при срабатывании нет автоматического повтора без проверки.
- В метриках разделены таймауты до первого байта и внутри тела.
- Значение меньше idle-таймаута туннеля на стороне прокси.
Метод 3: write timeout и работа с большими телами запроса
Когда запись вообще может зависнуть
Для большинства запросов тело помещается в один TCP-сегмент и уходит мгновенно — запись завершается ещё до того, как данные физически покинули машину. Write timeout становится значимым в трёх случаях: загрузка файлов, отправка крупных JSON-массивов и любая передача через узкий канал. Мобильный прокси — как раз такой канал в исходящем направлении: типичная скорость отдачи с модема заметно ниже скорости приёма, а буферы на промежуточных узлах ограничены.
Механика такова: клиент вызывает запись, данные попадают в буфер отправки сокета, ядро отправляет их порциями по мере получения подтверждений. Если подтверждения не приходят, буфер заполняется, и следующая запись блокируется. Write timeout ограничивает время такой блокировки.
Три стратегии для больших тел
Стратегия А: общий лимит на запись. Простой подход: один write timeout на весь запрос. Подходит для тел до нескольких мегабайт. Значение выбирается из оценки: размер тела, делённый на минимально приемлемую скорость, плюс запас. Например, 5 мегабайт при минимальной скорости 500 килобайт в секунду — 10 секунд, с запасом — 15.
Стратегия Б: лимит на порцию. Клиент пишет тело чанками и ограничивает время каждой записи. Так работает большинство асинхронных клиентов: write timeout там означает максимальную паузу на отправке одной порции. Значение — 3–10 секунд, вне зависимости от размера файла. Защита от медленной отдачи целиком ложится на общий дедлайн.
Стратегия В: контроль скорости. Клиент отслеживает реальную скорость отдачи и прерывает запрос, если она падает ниже порога на протяжении N секунд. У curl для этого есть пара флагов --speed-limit и --speed-time. Это самый точный инструмент: он различает «медленно, но идёт» и «застряло».
Что происходит при срабатывании
Часть тела уже на сервере. Если вы загружали файл в одном запросе — сервер получит обрезанное тело. Для protokol multipart это чаще всего приведёт к ошибке разбора и отказу целиком, что безопасно. Для API с поддержкой возобновляемых загрузок (tus, чанковые протоколы облачных хранилищ) правильная реакция — запросить у сервера смещение и продолжить с него. Именно возобновляемые загрузки мы рекомендуем для любых тел свыше 10 мегабайт через мобильные прокси: одиночный длинный запрос через сотовый канал слишком уязвим к обрывам.
Пошаговая настройка для загрузок через прокси
- Оцените медианную и минимальную скорость отдачи через ваш прокси. Загрузите тестовый файл 5–10 мегабайт двадцать раз в разное время.
- Если разброс скорости более чем трёхкратный — используйте Стратегию Б или В, а не общий лимит.
- Разбейте большие файлы на части 1–5 мегабайт, если целевой сервис это поддерживает.
- Установите write timeout на порцию 5–10 секунд.
- Обязательно дополните общим дедлайном на весь запрос, рассчитанным из размера и минимальной скорости.
- При срабатывании — определяйте, что именно сервер успел получить, а не повторяйте всё с начала.
Метод 4: общий бюджет запроса и распространение дедлайна
Почему сумма частных лимитов — это ещё не бюджет
Допустим, вы выставили connect 5, TLS 5, write 10, read 15 секунд. Кажется, что запрос не может длиться больше 35 секунд. Но read timeout — интервал бездействия. Ответ, приходящий по одному килобайту каждые 14 секунд, никогда его не нарушит. Запрос в 10 мегабайт при таком темпе займёт почти сутки. Без общего лимита ваши воркеры будут заняты бесконечно, пул соединений исчерпается, и система встанет — при том что ни один частный таймаут не сработал.
Общий бюджет (deadline, total timeout) — это абсолютный потолок для всей операции от первого системного вызова до последнего прочитанного байта. Он не заменяет частные лимиты, а дополняет их: частные лимиты дают быструю и точную диагностику, общий — гарантию завершения.
Как рассчитать бюджет
Идём сверху вниз, а не снизу вверх. Начните с вопроса: какое максимальное время ожидания одного результата приемлемо для бизнес-задачи? Для интерактивного сценария (пользователь ждёт) — 3–10 секунд. Для фонового парсинга — 30–60 секунд. Для загрузки крупных файлов — рассчитывается от размера.
Затем этот бюджет распределяется по фазам с учётом измеренных распределений:
- Установка туннеля через прокси (TCP плюс CONNECT плюс TLS): типично 15–25 процентов бюджета.
- Запись запроса: 5–10 процентов для обычных запросов.
- Ожидание первого байта: 30–40 процентов.
- Чтение тела: остаток.
Пример: бюджет 30 секунд для парсинга через мобильный прокси. Connect (включая CONNECT) 6 секунд, TLS 4 секунды, write 3 секунды, read как интервал бездействия 10 секунд, общий дедлайн 30 секунд. Сумма частных лимитов 23 секунды меньше бюджета — это нормально, они срабатывают по отдельности. Общий дедлайн ловит случаи медленной отдачи, которые не поймает ни один частный.
Распространение дедлайна через цепочку
В распределённых системах запрос редко бывает одиночным. Ваш сервис получил задачу с лимитом 30 секунд, потратил 4 секунды на подготовку, затем идёт через прокси к целевому сайту. Сколько времени у HTTP-запроса? Не 30, а 26 секунд минус запас на обработку ответа. Это и есть распространение дедлайна: каждый последующий вызов получает не фиксированный таймаут, а остаток бюджета.
В Go это реализуется контекстом с дедлайном, который передаётся в запрос. В Python — через asyncio с явной передачей оставшегося времени. В Java — через вычисление Duration перед каждым вызовом. Правило одно: таймаут на HTTP-запрос вычисляется динамически, как минимум из статического лимита и оставшегося бюджета.
Без этого возникает классическая проблема: верхний уровень уже отказался ждать и вернул ошибку, а нижний ещё десять секунд держит соединение через прокси и потребляет трафик ради результата, который никому не нужен. При платном трафике мобильных прокси это буквально сжигание денег.
Пул соединений и его собственные таймауты
Ещё два лимита, о которых часто забывают. Pool timeout — сколько ждать свободного соединения из пула, если все заняты. Если он не задан, при всплеске нагрузки запросы будут ждать неограниченно, и внешне это выглядит как зависание клиента. Ставьте 1–3 секунды: если за это время соединение не освободилось, система перегружена и лучше отказать сразу.
Idle timeout соединения в пуле — сколько неиспользуемое keep-alive-соединение хранится перед закрытием. Здесь критично согласование с прокси. Если прокси закрывает бездействующее соединение через 60 секунд, а ваш пул хранит его 90 секунд, то на 61-й секунде вы возьмёте из пула мёртвый сокет, отправите в него запрос и получите connection reset — не таймаут, а разрыв. Многие библиотеки прозрачно повторяют запрос в такой ситуации, но только для идемпотентных методов. Правило: idle timeout клиента строго меньше idle timeout прокси, с запасом хотя бы 10–20 процентов.
Фреймворк «бюджет сверху вниз»
- Зафиксируйте бизнес-ограничение на время ожидания результата.
- Вычтите время на собственную обработку и запас на повтор, если он предусмотрен.
- Полученный остаток — общий дедлайн HTTP-запроса.
- Распределите его по фазам согласно измеренным p99 каждой фазы через ваш прокси.
- Проверьте, что каждый частный лимит меньше соответствующего лимита на стороне прокси.
- Задайте pool timeout и idle timeout пула, согласованные с прокси.
- Реализуйте передачу остатка бюджета во вложенные вызовы.
- Логируйте, какой именно лимит сработал, и время, потраченное на каждую фазу.
Метод 5: наблюдаемость таймаутов и адаптивная настройка
Без измерений нет настройки
Все предыдущие методы упираются в одно: вы должны знать реальные распределения времени по фазам через ваш прокси. Единственный способ узнать — измерять постоянно. Современные клиенты предоставляют хуки трассировки: момент начала DNS, установления TCP, получения ответа на CONNECT, завершения TLS, отправки запроса, первого байта, последнего байта. Соберите эти события в метрики с разбивкой по прокси, целевому хосту и типу ошибки.
Какие метрики собирать
- Гистограммы длительности каждой фазы, отдельно по прокси-эндпоинту и оператору.
- Доля срабатываний каждого типа таймаута от общего числа запросов.
- Доля таймаутов до первого байта против внутри тела.
- Доля разрывов соединения без таймаута (признак несогласованных idle-лимитов).
- Среднее время, потраченное на запросы, завершившиеся таймаутом — это ваш прямой убыток в трафике и ресурсах.
Адаптивные таймауты
Тренд последних лет, который к 2026 году стал стандартом в зрелых системах, — адаптивные лимиты. Вместо статического числа клиент поддерживает скользящее окно наблюдений по каждой паре прокси-цель и выставляет таймаут как p99 окна с коэффициентом запаса, ограниченный сверху и снизу разумными границами. Когда канал ухудшается, лимит растёт и ложных срабатываний становится меньше. Когда канал восстанавливается, лимит снижается и система быстрее реагирует на реальные проблемы.
Реализация несложна: кольцевой буфер на 200–500 последних измерений на ключ, пересчёт квантиля раз в несколько секунд, границы вида «не меньше 3 и не больше 20 секунд для read». Важно защититься от деградации: если все запросы начинают таймаутить, окно наполняется значениями на уровне лимита, и лимит будет только расти. Поэтому в окно попадают лишь успешные запросы, а рост лимита ограничен верхней границей.
Хеджированные запросы
Для чтения через пул из нескольких прокси есть приём, снижающий влияние медленных хвостов без роста таймаутов: если запрос не завершился за p95 времени, отправить дубликат через другой прокси и взять первый пришедший ответ. Это увеличивает трафик на несколько процентов, но радикально уменьшает p99 латентности. Подходит только для идемпотентных запросов и требует аккуратной отмены проигравшего дубликата, чтобы не расходовать трафик впустую.
Типичные ошибки: что не нужно делать
Одно число на всё
Самая распространённая ошибка. Единый таймаут 30 секунд означает, что мёртвый прокси вы будете обнаруживать полминуты, а медленный ответ в середине тела не обнаружите никогда. Разделяйте фазы.
Отсутствие таймаутов по умолчанию
Несколько популярных библиотек не имеют таймаутов из коробки: запрос может висеть бесконечно. В requests это так до сих пор. Любой вызов без явного таймаута через прокси — это потенциально навечно заблокированный воркер.
Read timeout больше idle-лимита прокси
Вы не увидите таймауты, вы увидите разрывы соединений и будете искать проблему не там. Узнайте лимиты своего прокси-провайдера и настройте клиента строго ниже.
Слепой повтор после read timeout на POST
Прямой путь к дубликатам заказов, двойным списаниям и повторным сообщениям. После read timeout на неидемпотентном запросе результат неизвестен — с ним надо разбираться, а не гадать.
Игнорирование фазы CONNECT
Считать, что connect timeout покрывает установку туннеля, не проверив это в документации конкретной библиотеки. В некоторых клиентах фаза CONNECT висит до общего дедлайна, а если его нет — бесконечно.
Подгонка под максимум
Увидели один запрос за 45 секунд — поставили лимит 60. Теперь каждая реальная проблема стоит вам минуту ожидания. Ориентируйтесь на p99 с запасом, а выбросы отдавайте механизму повтора или хеджирования.
Таймаут без отмены нижележащей работы
Верхний уровень бросил исключение по своему лимиту, а HTTP-запрос продолжает жить в фоновой задаче. Особенно частая ошибка в асинхронном коде: обёртка с ожиданием отработала, а корутина не отменена. Убедитесь, что срабатывание таймаута приводит к реальному закрытию сокета.
Одинаковые лимиты для датацентровых и мобильных прокси
Разница в задержке и джиттере между ними — в разы. Профиль, работающий на серверном прокси, на мобильном даёт шквал ложных таймаутов. Держите отдельные профили настроек.
Отсутствие pool timeout
При всплеске нагрузки запросы бесконечно ждут свободного соединения. Внешне — зависание всего клиента при нулевом сетевом трафике.
Инструменты и ресурсы
Диагностика из командной строки
curl остаётся эталонным инструментом для разбора фаз. Флаги --connect-timeout, --max-time, --speed-limit, --speed-time покрывают все уровни, а формат вывода -w с переменными времени показывает, сколько заняла каждая фаза:
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/Обратите внимание: через прокси переменная time_connect показывает время до прокси, а time_appconnect — до завершения TLS с целью, то есть включает CONNECT. Разница между ними — ваш второй хоп.
Клиентские библиотеки и их модели таймаутов
- Python requests: кортеж (connect, read). Нет write и общего таймаута; общий реализуется внешней обёрткой или отменой на уровне потока.
- Python httpx: объект Timeout с connect, read, write, pool. Общего нет, но в асинхронном режиме легко добавляется через ожидание с лимитом и отменой.
- Python aiohttp: ClientTimeout с полями total, connect, sock_connect, sock_read. Единственный из популярных Python-клиентов с встроенным общим лимитом.
- Go net/http: Dialer.Timeout, TLSHandshakeTimeout, ResponseHeaderTimeout, ExpectContinueTimeout, IdleConnTimeout на транспорте; Client.Timeout как общий; контекст запроса как динамический дедлайн.
- Java HttpClient: connectTimeout на клиенте, timeout на запросе (покрывает до получения заголовков). Чтение тела ограничивается на уровне BodyHandler или обёрткой.
- Node.js undici: connectTimeout, headersTimeout, bodyTimeout, keepAliveTimeout; общий — через AbortSignal.timeout.
Анализ трафика
tcpdump и Wireshark позволяют увидеть, что реально происходило на проводе: ушёл ли SYN, пришёл ли SYN-ACK, кто первым отправил FIN или RST. Это единственный способ достоверно ответить на вопрос «кто разорвал соединение — я, прокси или сервер». Для HTTPS-содержимого видимость ограничена, но фазы соединения и туннеля видны полностью.
Стенды для воспроизведения
Для проверки поведения клиента при зависаниях полезно иметь набор заглушек: TCP-сервер, который принимает соединение и молчит (проверка connect и CONNECT); HTTP-сервер, который отвечает заголовками и затем молчит (проверка read до тела); сервер, отдающий байт в секунду (проверка общего дедлайна). Написать такие заглушки — полчаса работы, а сэкономленное время на отладке в продакшене измеряется днями. Также существуют инструменты сетевой эмуляции, позволяющие добавить задержку, джиттер и потери на интерфейсе, чтобы имитировать мобильный канал в лаборатории.
Наблюдаемость
Стандартом стал сбор метрик и трассировок в формате OpenTelemetry с автоматической инструментацией HTTP-клиентов. Гистограммы по фазам, атрибуты с идентификатором прокси и типом сработавшего лимита — минимальный набор, без которого настройка превращается в гадание.
Кейсы и результаты
Кейс 1: парсинг маркетплейса через мобильные прокси
Команда собирала карточки товаров через пул мобильных прокси. Исходная конфигурация: единый таймаут 15 секунд, без общего дедлайна, стандартный пул соединений. Симптомы: 11 процентов запросов завершались ошибками, из них две трети — таймауты, треть — разрывы соединения. Средняя длительность неудачного запроса — 14 секунд, то есть каждый десятый запрос съедал время и трафик впустую.
Диагностика по фазам показала: p99 установки туннеля — 4,8 секунды, p99 TTFB — 6,2 секунды, максимальная пауза между чанками у успешных ответов — 2,1 секунды, idle-лимит туннеля у провайдера — 60 секунд, а пул клиента хранил соединения 120 секунд.
Изменения: connect 7 секунд с покрытием CONNECT, read 9 секунд, write 5 секунд, общий дедлайн 25 секунд, idle пула 45 секунд, pool timeout 2 секунды. Разделение таймаутов до первого байта и внутри тела в метриках.
Результат через неделю: общая доля ошибок снизилась до 3,4 процента, разрывы соединений исчезли практически полностью, средняя длительность неудачного запроса упала до 8 секунд. Расход трафика на единицу собранных данных сократился на 19 процентов. Никаких изменений в логике повторов не делалось — только таймауты.
Кейс 2: интеграция с платёжным API и дубликаты
Сервис отправлял POST-запросы на создание платёжных операций через корпоративный прокси. Read timeout 10 секунд и автоматический повтор при любом исключении. Раз в несколько дней возникали дубликаты операций. Анализ показал: целевой API в моменты нагрузки отвечал за 11–14 секунд, клиент отваливался по read timeout, повторял запрос, и обе операции успешно выполнялись.
Решение состояло из трёх частей: read timeout поднят до 20 секунд на основании измеренного p99 в 15 секунд; повтор после read timeout на POST заменён на запрос статуса операции по клиентскому идентификатору; введён ключ идемпотентности в заголовке, который поддерживал API. Дубликаты прекратились полностью. Отдельный вывод команды: read timeout на неидемпотентном запросе — это не ошибка, а состояние «результат неизвестен», требующее отдельной ветки обработки.
Кейс 3: загрузка медиафайлов через мобильный канал
Приложение загружало видео объёмом 50–200 мегабайт через мобильные прокси одним запросом. Write timeout 30 секунд, общего дедлайна нет. Симптомы: около 8 процентов загрузок обрывались, каждая неудача означала повтор с нуля, суточный перерасход трафика достигал десятков гигабайт.
Переход на чанковую загрузку по 4 мегабайта с возобновлением, write timeout на чанк 8 секунд, контроль минимальной скорости 100 килобайт в секунду на протяжении 10 секунд, общий дедлайн на чанк 60 секунд. Доля полностью проваленных загрузок упала до 0,3 процента, перерасход трафика на повторы сократился в 12 раз, потому что повторялся только последний неудачный чанк.
Кейс 4: зависание CONNECT без общего дедлайна
Асинхронный сборщик на одной из Python-библиотек периодически «застывал»: воркеры живы, сеть молчит, очередь не двигается. Через час-два сборщик перезапускали вручную. Разбор показал: часть прокси в пуле принимала TCP, но не отвечала на CONNECT. В используемой конфигурации эта фаза не была покрыта ни одним лимитом. Добавление общего дедлайна на весь запрос и явного лимита на установку туннеля устранило зависания. Дополнительно добавлен healthcheck прокси с проверкой именно CONNECT-фазы, а не только TCP-доступности.
FAQ: сложные вопросы о таймаутах через прокси
Чем таймаут клиента отличается от ответа 504 от прокси?
Таймаут клиента — это ваше решение перестать ждать; прокси и сервер о нём узнают только по закрытию соединения. Ответ 504 — это решение прокси: он сам не дождался целевого сервера и сообщил вам об этом полноценным HTTP-ответом. В первом случае сокет закрывается с исключением, во втором вы получаете нормальный ответ с кодом ошибки. Обрабатывать их надо по-разному: 504 означает, что прокси точно жив и проблема ниже по цепочке; клиентский таймаут ничего не говорит о том, где именно застряло.
Почему через мобильный прокси нужны более длинные таймауты, чем через датацентровый?
Из-за джиттера. Средняя задержка сотового канала не так велика, но её разброс огромен: переключения между секторами, режимы энергосбережения модема, конкуренция за радиоресурс. Таймаут настраивается по хвосту распределения, а хвост у мобильного канала в несколько раз длиннее. При этом слишком длинные лимиты тоже вредны — они замедляют обнаружение реально мёртвых прокси. Баланс достигается измерением p99 и запасом в 30–50 процентов, а не удвоением всех чисел.
Как понять, какой именно таймаут сработал, если библиотека выбрасывает одно общее исключение?
Три способа. Первый — по времени: если исключение пришло через время, равное connect timeout, а не read, вы знаете фазу. Второй — через хуки трассировки: если событие «TLS завершён» было, а «первый байт» — нет, застряли на TTFB. Третий — по тексту и типу исключения: многие библиотеки различают ConnectTimeout и ReadTimeout как отдельные классы. Мы рекомендуем всегда логировать, какие фазы успели завершиться до исключения — это превращает загадочный таймаут в точный диагноз.
Можно ли повторять запрос после срабатывания write timeout?
Для GET без тела — да, ничего не ушло. Для POST с телом — только если вы уверены, что сервер отвергает неполные тела. Большинство серверов так и делают: неполный JSON или обрезанный multipart вызывают ошибку разбора. Но потоковые API, которые начинают обработку по мере получения данных, могут частично применить изменения. Если сомневаетесь — проверяйте состояние перед повтором.
Как согласовать таймауты клиента с таймаутами прокси-провайдера?
Запросите у провайдера или найдите в документации три значения: лимит на соединение с целевым хостом, idle-лимит туннеля и максимальное время жизни соединения. Ваш лимит на установку туннеля должен быть не меньше провайдерского (иначе вы сдаётесь раньше, чем прокси мог бы успеть), а ваш read timeout и idle пула — строго меньше провайдерских idle-лимитов. Если документации нет, измерьте эмпирически: откройте соединение, помолчите N секунд, попробуйте отправить запрос, найдите порог, после которого приходит разрыв.
Нужен ли общий дедлайн, если все частные лимиты настроены?
Да, обязательно. Частные лимиты не ограничивают суммарное время: медленная отдача тела по одному килобайту с интервалом меньше read timeout может длиться неограниченно. Общий дедлайн — единственная гарантия, что воркер освободится. Кроме того, при распространении бюджета через цепочку вызовов именно общий дедлайн передаётся вниз, а частные лимиты остаются локальной настройкой.
Как влияют HTTP/2 и HTTP/3 на модель таймаутов через прокси?
HTTP/2 мультиплексирует много запросов в одно соединение, поэтому read timeout на уровне сокета перестаёт быть таймаутом одного запроса: сокет получает данные других потоков, и бездействие конкретного запроса не заметно. Нужны лимиты на уровне потока — большинство HTTP/2-клиентов их предоставляют через дедлайн запроса. HTTP/3 поверх QUIC меняет и фазу соединения: рукопожатие совмещено с криптографическим, и connect timeout покрывает оба. Через классический CONNECT-прокси HTTP/3 к цели, как правило, не проходит — туннель TCP-ориентирован, и клиент откатывается на HTTP/2 или HTTP/1.1. Расширения для UDP-туннелирования через прокси развиваются, но на 2026 год в массовых клиентах их поддержка ограничена.
Что делать, если после таймаута соединение возвращается в пул и следующий запрос падает?
Это признак того, что клиент не закрыл сокет корректно или пул не пометил соединение как испорченное. Соединение, на котором сработал read timeout, нельзя переиспользовать: в нём могут находиться байты запоздавшего ответа, которые будут прочитаны как ответ на следующий запрос. Убедитесь, что ваш клиент при таймауте закрывает соединение, а не возвращает в пул. В хорошо спроектированных клиентах это поведение по умолчанию, но при собственных обёртках и низкоуровневой работе с сокетами ошибка встречается регулярно.
Как настроить таймауты для SOCKS5-прокси в отличие от HTTP-прокси?
Принцип тот же, отличаются фазы: вместо CONNECT — приветствие, аутентификация и команда соединения, это два-три круговых обхода до прокси плюс время соединения прокси с целью. В большинстве клиентов SOCKS-рукопожатие целиком попадает под connect timeout. Убедитесь, что значение учитывает не только TCP до прокси, но и время установки соединения прокси с целью через мобильный канал — те же 3–10 секунд.
Заключение: таймауты как инженерная дисциплина
Давайте подведём итог. HTTP-запрос через прокси — это не одна операция, а цепочка из семи-восьми фаз ожидания, каждая со своей природой задержек и своими последствиями при обрыве. Connect и TLS-таймауты безопасны: ничего не ушло на сервер, можно пробовать снова. Write timeout оставляет сервер с неполными данными. Read timeout — самый коварный: запрос доставлен и, возможно, выполнен, а вы этого не знаете. Общий дедлайн не заменяет частные лимиты, а страхует от медленной отдачи, которую они не ловят.
Через мобильные прокси всё это усиливается: второй хоп проходит по каналу с высоким джиттером, и лимиты, отлаженные на серверных прокси, дают шквал ложных срабатываний. Единственный способ настроить их правильно — измерять распределения по фазам через ваш конкретный прокси и ставить лимиты по p99 с запасом, согласовывая их с лимитами самого прокси.
Ваши следующие шаги:
- Найдите в своём коде каждый HTTP-вызов через прокси и проверьте, есть ли у него явные таймауты на все фазы и общий дедлайн.
- Выясните, покрывает ли ваш клиент фазу CONNECT и как он трактует read timeout — как бездействие или как общее время.
- Узнайте idle-лимиты и лимиты соединения вашего прокси-провайдера и приведите настройки клиента в соответствие.
- Включите трассировку фаз и соберите распределения за неделю.
- Пересчитайте лимиты по p99, разделите профили для датацентровых и мобильных прокси.
- Разделите обработку таймаутов для идемпотентных и неидемпотентных запросов.
- Добавьте в метрики тип сработавшего лимита и фазу, на которой он сработал.
Таймауты — это не параметр, который выставляют один раз и забывают. Это часть контракта вашей системы с внешним миром, и как любой контракт она требует измерений, пересмотра и согласования сторон. Сделайте это один раз системно — и вы удивитесь, насколько тише станут ваши логи и насколько дешевле — ваш трафик.