Введение: почему полоса на прокси решает больше, чем кажется

Большинство разговоров о прокси крутятся вокруг анонимности, геолокации и «не забанят ли». Полоса пропускания при этом остаётся в тени. А ведь именно она определяет, за сколько часов отработает ваш парсер, сколько аккаунтов выдержит один канал и почему скрипт, идеально работавший на тестовом стенде, в продакшене начал сыпать таймаутами каждые десять минут.

Мы с вами разберём тему, о которой редко пишут системно: как на прокси устроено ограничение полосы, что такое шейпинг и полисинг, как выглядит потолок канала в реальных цифрах и, главное, как ведёт себя ваш клиентский код, когда этого потолка касается. Мы сознательно не будем пересказывать методики оценки качества прокси в целом. Здесь речь только о полосе, её пределе и о том, что происходит с приложением в момент насыщения.

Почему это актуально именно сейчас? К 2026 году средний объём одной веб-страницы с ресурсами перевалил за три мегабайта, API отдают всё более тяжёлые JSON-ответы, а мобильные каналы, на которых строятся мобильные прокси, физически делят радиоресурс соты с обычными абонентами. Одновременно операторы и провайдеры прокси активнее применяют шейпинг на уровне сессии, чтобы один клиент не «съедал» канал у остальных. Разработчик, который не понимает механику ограничителя, обречён писать код методом проб и ошибок.

Из этого руководства вы узнаете: как отличить шейпер от полисера по форме графика, как корректно измерить потолок одного потока и агрегата, как оценить размер «ведра» и глубину очереди, почему при насыщении растёт задержка и падает эффективность, как писать клиент с обратным давлением и адаптивной параллельностью, а также как планировать бюджет трафика, а не количество запросов. В финале вас ждут чек-листы, инструменты, три разобранных кейса с цифрами и FAQ на самые каверзные вопросы.

Основы: словарь понятий, без которого дальше не пройти

Полоса, пропускная способность и полезная скорость

Термины часто путают, а разница принципиальна. Полоса пропускания (bandwidth) — это номинальный потолок канала, сколько бит в секунду он способен пропустить в идеале. Пропускная способность (throughput) — сколько бит реально прошло за единицу времени с учётом всех накладных расходов: заголовков TCP и IP, повторных передач, шифрования. Полезная скорость (goodput) — только те байты, которые дошли до вашего приложения и были им использованы. Если файл размером 100 мегабайт скачался за 20 секунд, ваш goodput — 5 мегабайт в секунду, хотя канал при этом мог пропустить на 8–12 процентов больше из-за служебной информации.

Для практики важно запомнить: ограничители на прокси почти всегда считают именно throughput на уровне пакетов, а вы видите goodput. Между ними всегда будет зазор.

Потолок канала и уровни ограничения

Потолок — максимальная скорость, которую ограничитель разрешает на заданном уровне агрегации. Уровней бывает несколько, и они складываются как матрёшка:

  • на TCP-соединение — каждый отдельный поток не может превысить, скажем, 2 мегабита в секунду, но десять потоков дадут двадцать;
  • на сессию или порт прокси — все соединения через один порт делят общий лимит;
  • на аккаунт — сумма по всем портам клиента;
  • на узел — физический предел модема, сервера, аплинка;
  • на канал оператора — то, что даёт сота в конкретный момент времени с учётом загрузки радиосети.

Реальный потолок — это минимум по всем уровням. И этот минимум плавает в течение дня, потому что нижний уровень, радиоканал, зависит от количества абонентов рядом с модемом.

Token bucket: механика почти любого ограничителя

Представьте ведро, в которое с постоянной скоростью капают жетоны. Каждый байт, проходящий через ограничитель, забирает один жетон. Если ведро пусто, байт либо ждёт (шейпинг), либо отбрасывается (полисинг). Скорость капания — это rate, целевая скорость. Объём ведра — burst, допустимый всплеск. Пока ведро полное, вы можете отправить пачку данных быстрее номинала. Потом скорость выравнивается до rate.

Эта модель объясняет удивительно многое. Почему первые две секунды скачивания идут быстрее, чем остальные? Ведро было полным. Почему короткие запросы почти никогда не упираются в лимит? Они укладываются в объём ведра. Почему длинная загрузка внезапно «проседает» ровно до одной цифры? Ведро опустело, работает чистый rate.

Шейпинг против полисинга

Шейпер ставит лишние пакеты в очередь и выпускает их с заданной скоростью. Трафик сглаживается, потерь мало, но растёт задержка: пакет ждёт своей очереди. Полисер очередь не держит, он просто отбрасывает всё, что превышает лимит. Задержка не растёт, зато TCP видит потери, резко снижает окно, потом снова разгоняется, и график скорости превращается в пилу.

Аналогия: шейпер — это светофор с регулируемой длиной зелёного, все проезжают, но медленнее. Полисер — это эвакуатор, который убирает каждую машину сверх нормы. Поток машин при этом дёргается. Для вашего кода разница огромна, и мы к ней вернёмся.

Специфика мобильных каналов

Мобильный прокси стоит на канале сотового оператора. Здесь потолок задаётся не только настройками сервера, но и физикой: категорией модема, полосой частот, числом абонентов в соте, качеством сигнала. Плюс оператор сам применяет приоритизацию трафика на уровне классов обслуживания. Итог: полоса мобильного канала на порядок менее стабильна, чем у серверного, и любая методика замера должна учитывать временной фактор.

Глубокое погружение: что происходит в момент насыщения

Момент истины: очередь растёт

Пока ваш трафик ниже потолка, ограничитель практически невидим. Проблемы начинаются, когда сумма потоков превышает rate. У шейпера начинает расти очередь. Каждый пакет, прежде чем уйти дальше, ждёт в буфере. Если буфер глубокий, а такие буферы любят ставить на дешёвом сетевом оборудовании и в программных ограничителях с щедрыми настройками, задержка может вырасти с 60 миллисекунд до полутора секунд. Это явление называется bufferbloat: раздутый буфер превращает быстрый канал в медленный и вязкий.

Для приложения это выглядит так: скорость загрузки вроде нормальная, а каждый новый запрос стартует с чудовищной задержкой. Мелкие API-вызовы, на которые раньше уходило 100 миллисекунд, теперь занимают секунду. Таймауты, настроенные «с запасом», начинают срабатывать. И самое коварное: вы не увидите потерь пакетов, всё просто станет медленным.

Реакция TCP: почему алгоритм управления перегрузкой важен

TCP сам пытается нащупать потолок канала. Классический алгоритм CUBIC разгоняет окно передачи, пока не увидит потерю, потом сбрасывает скорость и разгоняется снова. С полисером CUBIC работает плохо: потери частые и резкие, средняя скорость может оказаться на 30–40 процентов ниже потолка. С шейпером CUBIC заполняет очередь до отказа, потому что потерь долго нет, и именно он становится главным виновником bufferbloat.

Алгоритм BBR, который всё шире используется на серверах, ведёт себя иначе: он оценивает пропускную способность и минимальный RTT и старается не переполнять очередь. Через шейпер BBR даёт ровную скорость и умеренную задержку. Но помните: алгоритм на стороне вашего клиента управляет только исходящим потоком. Входящий поток от прокси к вам определяется настройками прокси-сервера и целевого сайта, а на них вы не влияете.

Один туннель, много потоков: блокировка головы очереди

Когда вы работаете через HTTP-прокси методом CONNECT или через SOCKS5, каждое ваше TCP-соединение к целевому сайту оборачивается в отдельное соединение с прокси. Если вы используете HTTP/2 к целевому сайту внутри одного туннеля, все запросы мультиплексируются в один TCP-поток. При насыщении это создаёт блокировку головы очереди: один тяжёлый ответ занимает окно, и лёгкие запросы ждут за ним. Через ограничитель на соединение это особенно болезненно: весь мультиплекс делит один лимит.

Практический вывод, который многие делают слишком поздно: параллельность через прокси нужно строить на нескольких TCP-соединениях, а не на мультиплексировании внутри одного. Мы это учтём в разделе про код.

Справедливость между потоками

Как ограничитель делит полосу между вашими десятью соединениями? Если лимит общий и очередь одна, полосу разбирают агрессивнее те потоки, у которых больше данных в полёте. Мелкие запросы систематически проигрывают крупным. Если на ограничителе стоит справедливая очередь, каждый поток получает примерно равную долю. Понять, какой вариант перед вами, можно только экспериментально, и от этого зависит, стоит ли разделять тяжёлые загрузки и лёгкие API-вызовы по разным соединениям или даже портам.

Медленный старт и короткие запросы

TCP начинает с маленького окна и удваивает его каждый RTT. Через мобильный канал с RTT около 80 миллисекунд разгон до, скажем, 20 мегабит занимает несколько сотен миллисекунд. Запрос на 50 килобайт заканчивается раньше, чем TCP успевает разогнаться. Поэтому короткие запросы никогда не упираются в потолок полосы, зато они крайне чувствительны к задержке. Это разделяет ваш трафик на два класса с разными правилами: тяжёлые потоки, где важен rate, и лёгкие, где важен RTT. Одно ограничение душит первые, а bufferbloat от первых убивает вторые.

Сигнатуры на графике

Если вы построите скорость по секундам, ограничители выдадут себя формой:

  • ровное плато с плавным выходом и растущим RTT — шейпер с глубокой очередью;
  • плато с горбом в начале — шейпер или полисер с заметным burst-ведром;
  • пила с провалами на 30–50 процентов, стабильный RTT, есть ретрансмиссии — полисер;
  • хаотичные колебания без явного плато — вы упёрлись не в ограничитель, а в радиоканал или загруженный узел.

Умение читать эти сигнатуры экономит часы отладки. Дальше — как их получить корректно.

Метод 1: корректный замер потолка полосы

Зачем нужна методика, а не одна проверка

Запустить скачивание файла и посмотреть цифру может каждый. Проблема в том, что одна цифра ничего не значит: она зависит от времени суток, от источника, от вашего собственного канала, от фазы медленного старта. Нам нужен воспроизводимый протокол, результаты которого можно сравнивать между каналами и днями.

Подготовка эталонного источника

Первое правило: измерять полосу нужно против источника, который сам заведомо быстрее любого прокси. Иначе вы измерите не прокси, а источник. Идеальный вариант — собственный сервер на площадке с гарантированным гигабитным аплинком, на котором лежат тестовые файлы размером 20, 100 и 500 мегабайт, сгенерированные из случайных данных. Случайные данные важны: сжимаемый файл может быть сжат где-то на пути, и вы получите завышенную цифру.

Публичные тестовые файлы популярных CDN использовать можно, но с оговоркой: CDN отдаёт с ближайшего к прокси узла, и вы фактически измеряете полосу «прокси — CDN», а не «прокси — произвольный сайт». Для оценки потолка это приемлемо, для оценки реального goodput к вашим целевым ресурсам — нет.

Исключение собственного узкого места

Машина, с которой вы замеряете, должна иметь канал минимум в три раза шире ожидаемого потолка прокси. Проверьте это отдельным скачиванием того же файла напрямую. Отключите фоновые загрузки, синхронизацию облаков, обновления. Если вы запускаете замеры из контейнера или виртуалки, убедитесь, что виртуальная сеть не режет полосу сама.

Протокол одиночного потока

  1. Запускаете скачивание файла на 100 мегабайт через прокси одним соединением с фиксацией скорости каждую секунду. Через curl это делается ключами для прогресса; удобнее написать небольшой скрипт, который читает тело потоково и записывает байты по секундам.
  2. Отбрасываете первые три секунды — там медленный старт и опустошение ведра.
  3. Прекращаете замер через 40–60 секунд или по окончании файла. Меньше 20 секунд — недостаточно, чтобы увидеть устоявшийся режим.
  4. Считаете по оставшимся секундам медиану, десятый и девяностый процентиль, коэффициент вариации (стандартное отклонение, делённое на среднее).
  5. Повторяете три раза с паузой в минуту.

Медиана — ваш устоявшийся потолок одного потока. Разрыв между десятым и девяностым процентилем говорит о стабильности. Коэффициент вариации ниже 0,15 — ровный канал, выше 0,4 — либо полисер, либо перегруженная радиосеть.

Протокол агрегата

Теперь то же самое, но с 2, 4, 8 и 16 параллельными соединениями к тому же файлу или к нескольким файлам. Суммируете скорости по секундам. Получаете зависимость агрегированной скорости от числа потоков. Она бывает трёх типов:

  • линейный рост до плато — лимит на соединение, потолок агрегата выше; плато показывает следующий уровень ограничения;
  • плато с первого потока — лимит общий на сессию, дополнительные потоки ничего не дают, только увеличивают задержку;
  • рост, а потом падение — при большом числе потоков растут потери и накладные расходы, канал деградирует. Оптимум — там, где рост остановился.

Одиночный curl для быстрой ориентировки выглядит так: curl -x http://user:pass@host:port -o /dev/null -w "%{speed_download} %{time_total}" https://your-server/100mb.bin. Он даст среднюю скорость за весь файл, что для первичной оценки достаточно, но для сигнатур нужна посекундная запись.

Временная развёртка

Для мобильного канала обязателен замер в четыре окна суток: ночь, утро, день, вечер. Потолок вечером в жилом районе может быть вдвое ниже ночного. Если вы планируете круглосуточную нагрузку, вашему коду придётся жить по вечернему потолку, а не по ночному.

Чек-лист замера потолка

  • Эталонный источник заведомо быстрее прокси, файлы из случайных данных.
  • Собственный канал проверен отдельно и минимум в три раза шире.
  • Посекундная запись байтов, первые три секунды отброшены.
  • Длительность устоявшегося режима не менее 20 секунд.
  • Три повтора, медиана и процентили, коэффициент вариации.
  • Серия по числу потоков: 1, 2, 4, 8, 16.
  • Четыре временных окна суток для мобильных каналов.
  • Результаты записаны в единый формат с указанием времени, порта, источника.

Метод 2: определяем тип ограничителя и его параметры

Зачем знать, что перед вами

Один и тот же потолок в 10 мегабит требует разного кода в зависимости от того, шейпер это или полисер, есть ли ведро всплеска и какого размера, растёт ли задержка под нагрузкой. Этот метод превращает график скорости в набор параметров, которые потом лягут в конфиг вашего клиента.

Тест всплеска: измеряем ведро

  1. Даёте каналу отдохнуть 30 секунд без трафика, чтобы ведро наполнилось.
  2. Запускаете скачивание и записываете скорость с разрешением 100–200 миллисекунд первые пять секунд.
  3. Находите момент, когда скорость падает до устоявшегося значения из Метода 1.
  4. Объём ведра оцениваете как суммарные байты, переданные до этого момента, минус то, что прошло бы за то же время на устоявшейся скорости.

Пример: первые 1,5 секунды идут на 40 мегабитах, потом ровно 10. Ведро примерно 40 минус 10, умножить на 1,5 секунды, делить на 8 — около 5,6 мегабайта. Это означает, что запросы объёмом до 5 мегабайт, разнесённые паузами, будут проходить на «быстрой» скорости. Отличный инструмент для планирования, если ваша нагрузка состоит из средних ответов.

Если всплеска нет и скорость сразу выходит на плато с плавным разгоном, ведро маленькое или отсутствует, а ограничитель, вероятно, шейпер с жёстким rate.

Тест задержки под нагрузкой

Это главный тест на различие шейпера и полисера. Параллельно с длинным скачиванием запускаете серию лёгких запросов через тот же порт прокси: например, HEAD к вашему серверу каждые 500 миллисекунд. Записываете время ответа до нагрузки, во время и после.

  • Задержка выросла в несколько раз, до сотен миллисекунд или секунд, при этом скорость ровная — шейпер с глубокой очередью. Запишите глубину: прирост задержки, умноженный на rate, даёт примерный размер буфера в байтах.
  • Задержка почти не изменилась, но в статистике соединения есть ретрансмиссии, а скорость пилообразная — полисер.
  • Задержка выросла умеренно, на 50–150 миллисекунд, скорость ровная — шейпер с управляемой очередью, самый комфортный вариант.

Статистику ретрансмиссий на Linux можно посмотреть командой ss -ti по нужному соединению: там есть счётчики retrans и текущий RTT. Это бесплатный и точный способ увидеть, теряются ли пакеты.

Тест агрегации: на соединение или на сессию

Вы уже получили кривую из Метода 1. Уточните её: запустите одно соединение на полную и второе с ограничением на стороне клиента в 10 процентов от потолка. Если первое почти не замедлилось — лимиты раздельные на соединение. Если первое потеряло ровно столько, сколько взяло второе — лимит общий. Этот тест дешевле, чем серия из 16 потоков, и даёт однозначный ответ.

Отделяем ограничитель от радиоканала

Как понять, что плато — это настройка, а не физика соты? Три признака настройки: плато держится с точностью до нескольких процентов в разное время суток, цифра «круглая» (5, 10, 20, 50 мегабит), а форма выхода на плато одинаковая в каждом повторе. Радиоканал даёт «некруглые» и плавающие значения, зависящие от времени. Дополнительно можно замерить второй порт того же узла в тот же момент: если два порта в сумме дают больше, чем один, лимит стоит на порт, а не на модем.

Фреймворк классификации

Соберите результаты в карточку канала:

  • Потолок одного потока: медиана, коэффициент вариации.
  • Потолок агрегата: значение и число потоков, при котором достигнуто.
  • Уровень лимита: соединение, сессия, узел.
  • Тип: шейпер или полисер.
  • Ведро: объём в мегабайтах или «нет».
  • Глубина очереди: прирост задержки под нагрузкой.
  • Суточный профиль: потолки по четырём окнам.

Такая карточка — прямой вход в конфигурацию клиента. Без неё вы будете подбирать параметры на ощупь.

Метод 3: пишем клиент, который согласуется с ограничителем

Философия: не бороться, а договариваться

Главный инсайт, который приходит после десятка отлаженных систем: ограничитель невозможно «пробить» большим числом потоков. Можно только заполнить его очередь и получить bufferbloat, или спровоцировать полисер на массовые потери. Эффективный клиент сам держит скорость немного ниже потолка, чтобы очередь ограничителя оставалась почти пустой, а задержка — низкой. Парадокс, который удивляет новичков: снизив скорость на 10 процентов, вы часто увеличиваете goodput, потому что исчезают таймауты и повторы.

Компонент 1: клиентский token bucket

Реализуйте у себя такое же ведро, как у ограничителя, но с rate на 85–90 процентов от измеренного устоявшегося потолка и с объёмом ведра не больше половины измеренного ведра прокси. Ограничитель применяется к чтению тела ответа: перед чтением очередного чанка вы запрашиваете у ведра столько жетонов, сколько байт собираетесь прочитать, и ждёте, если их нет. Логика по шагам:

  1. Храните два числа: текущий запас жетонов и время последнего пополнения.
  2. При запросе N жетонов сначала пополняете запас: tokens = min(burst, tokens + (now - last) * rate).
  3. Если жетонов хватает, вычитаете и продолжаете. Если нет, вычисляете время ожидания (N - tokens) / rate и засыпаете асинхронно.
  4. Ведро одно на порт прокси, общее для всех соединений через этот порт, если лимит на сессию. Если лимит на соединение — ведро на соединение плюс общее на узел.

Почему ограничивать чтение, а не запросы? Потому что именно чтение определяет, с какой скоростью данные вытягиваются из очереди ограничителя. Если вы читаете медленнее, чем отдаёт прокси, TCP сам сообщит отправителю уменьшить окно, и данные перестанут скапливаться в промежуточных буферах. Это и есть обратное давление (backpressure) в чистом виде.

Компонент 2: семафор параллельности

Число одновременных соединений на порт ограничивайте семафором. Стартовое значение берите из кривой агрегата Метода 1: то число потоков, при котором рост остановился, минус один. Для типичного мобильного канала это 4–8. Больше — только задержка растёт.

Компонент 3: потоковое чтение и таймаут прогресса

Никогда не задавайте единый таймаут на весь запрос. Файл на 50 мегабайт при потолке 5 мегабит будет качаться 80 секунд честно, и таймаут в 30 секунд убьёт его на середине, потратив половину полосы впустую. Правильный подход: таймаут на подключение (5–10 секунд), таймаут на первый байт (10–20 секунд с учётом возможного bufferbloat) и таймаут прогресса — максимальный интервал между двумя успешно прочитанными чанками, обычно 15–30 секунд. Читаете тело чанками по 32–64 килобайта, после каждого чанка обновляете отметку прогресса.

Компонент 4: адаптивная параллельность по схеме AIMD

Потолок мобильного канала плавает, а статичный семафор его не отслеживает. Решение — управлять параллельностью динамически по принципу аддитивного увеличения и мультипликативного уменьшения, ровно так, как делает TCP:

  1. Каждые 10 секунд считаете goodput за окно и медианную задержку первого байта.
  2. Если задержка ниже базовой в полтора раза и ошибок нет — увеличиваете лимит семафора на единицу, до верхней границы.
  3. Если задержка выросла больше чем вдвое от базовой или появились таймауты прогресса — уменьшаете лимит вдвое, но не ниже единицы.
  4. Базовую задержку измеряете в начале работы при одном соединении и пересчитываете раз в час.

Такой контроллер за пару минут нащупывает комфортную точку и держится около неё, автоматически сжимаясь вечером и расширяясь ночью. Мы видели, как он поднимал суточный goodput на 20–35 процентов без единого изменения потолка.

Компонент 5: повторы с экспоненциальной задержкой и джиттером

Таймаут — это сигнал перегрузки, а не приглашение повторить немедленно. Повтор сразу усугубляет очередь. Правило: первый повтор через 1–2 секунды, каждый следующий вдвое дольше, максимум 5 попыток, к каждой задержке добавляется случайный джиттер до 50 процентов, чтобы десять потоков не проснулись одновременно. При таймауте прогресса на большом файле имеет смысл продолжить с места обрыва запросом с заголовком Range, если сервер его поддерживает: полоса, потраченная на первую половину, не пропадёт.

Компонент 6: приоритетные очереди

Разделите задачи на классы: интерактивные (лёгкие API-вызовы, где важна задержка) и фоновые (тяжёлые загрузки). Фоновые получают долю ведра, скажем 70 процентов, интерактивные — гарантированный резерв. Если лимит на соединение, а не на сессию, выносите классы на разные соединения. Если возможно — на разные порты прокси. Так один тяжёлый файл не заблокирует сотню мелких запросов.

Компонент 7: учёт байтов, а не запросов

Считайте каждый прочитанный байт по порту, по классу и по целевому домену. Экспортируйте в метрики. Именно эти цифры покажут, где уходит полоса, и позволят планировать бюджет, о чём следующий метод.

Мини-каркас на Python

Схема реализации на asyncio и любом асинхронном HTTP-клиенте выглядит так:

  1. Класс TokenBucket с методом async def take(n) по логике из Компонента 1.
  2. Класс Channel: адрес прокси, ведро, семафор, счётчики, контроллер AIMD.
  3. Функция async def fetch(channel, url): под семафором открывает запрос через прокси, ждёт заголовки с таймаутом первого байта, затем в цикле читает chunk = await resp.content.read(65536), перед этим вызывая await channel.bucket.take(len(chunk)), обновляет отметку прогресса и счётчики байтов.
  4. Фоновая задача async def tune(channel): раз в 10 секунд читает метрики и корректирует размер семафора.
  5. Обёртка повторов с экспоненциальной задержкой и поддержкой Range.

Важная деталь для Python: стандартные клиенты по умолчанию буферизуют весь ответ в память. Убедитесь, что вы используете потоковый режим, иначе обратного давления не будет, и ограничитель на чтении окажется бесполезен. В Go аналог строится на io.Reader с обёрткой-лимитером и golang.org/x/time/rate; в Node.js — на паузе и возобновлении потока ответа.

Чек-лист клиента

  • Клиентское ведро с rate 85–90 процентов от потолка.
  • Потоковое чтение чанками, лимитер на чтении.
  • Три раздельных таймаута: подключение, первый байт, прогресс.
  • Семафор с адаптивным управлением по задержке.
  • Повторы с экспоненциальной задержкой, джиттером и Range.
  • Разделение интерактивных и фоновых задач.
  • Параллельность на нескольких TCP-соединениях, не на мультиплексе внутри одного туннеля.
  • Учёт байтов по порту, классу и домену.

Метод 4: бюджет трафика и архитектура нагрузки

Мыслите байтами

Большинство систем планируют нагрузку в запросах в секунду. Но ограничитель полосы считает байты. Запрос к API на 4 килобайта и загрузка страницы на 3 мегабайта — это разница в 750 раз. Первый шаг метода — перевести ваш план в байты: сколько ответов какого размера вы получаете за час, и хватает ли на это суточного профиля потолка из карточки канала.

Простая формула: суточная ёмкость канала в байтах равна сумме по четырём окнам произведения потолка на длительность окна, умноженной на коэффициент 0,8 на накладные расходы и запас. Для канала с ночным потолком 20 мегабит и вечерним 8 мегабит суточная ёмкость составит порядка 120–130 гигабайт. Если ваш план требует 300, никакая оптимизация кода не поможет, нужны ещё каналы.

Снижаем объём на каждый запрос

  • Сжатие: всегда отправляйте заголовок Accept-Encoding с gzip и br. Текстовые ответы ужимаются в 4–8 раз. Если ваш клиент не распаковывает ответы автоматически, включите это.
  • Отказ от лишних ресурсов: при работе с браузерной автоматизацией блокируйте загрузку изображений, шрифтов и медиа, если они не нужны для задачи. Это экономит 60–80 процентов трафика страницы.
  • Условные запросы: сохраняйте ETag и Last-Modified, отправляйте If-None-Match. Ответ 304 весит сотни байт вместо мегабайт.
  • HEAD перед GET: если нужно проверить наличие или размер ресурса, не скачивайте его.
  • Range-запросы: когда нужна только часть файла, например метаданные в начале, запрашивайте диапазон.
  • Поля API: многие API поддерживают выбор полей ответа. Запрашивайте только нужные.

Распределение по каналам

Если каналов несколько, не делите задачи поровну. Делите пропорционально текущему потолку, который вы измеряете на лету через goodput каждого канала. Планировщик держит очередь задач и отдаёт следующую тому каналу, у которого свободнее ведро и ниже задержка. Канал, ушедший в деградацию, автоматически получает меньше работы, без ручного вмешательства.

Планирование во времени

Фоновые объёмные задачи переносите в ночные окна, когда потолок выше. Интерактивные и срочные — распределяйте равномерно, но с резервом полосы. Это банально звучит, но на практике мало кто строит планировщик с учётом суточного профиля канала. Разница в суточном goodput при таком планировании — до 40 процентов на том же наборе каналов.

Предохранитель

Заложите в клиент жёсткий предохранитель: если goodput канала за последние две минуты упал ниже 20 процентов от медианы карточки, а задержка выросла более чем в четыре раза, канал временно исключается из ротации на 5 минут. Это защищает от ситуации, когда перегруженная сота или проблемный узел затягивает всю систему в бесконечные повторы.

Чек-лист бюджета

  • План переведён в байты по классам задач.
  • Суточная ёмкость каналов посчитана по профилю с запасом 20 процентов.
  • Сжатие, блокировка лишних ресурсов, условные запросы, Range применены.
  • Планировщик распределяет по текущему goodput, не поровну.
  • Объёмные задачи сдвинуты в окна высокого потолка.
  • Предохранитель по goodput и задержке настроен.

Типичные ошибки: что точно не нужно делать

Добавлять потоки, пока не станет быстрее

Самая распространённая ошибка. При общем лимите на сессию дополнительные потоки лишь удлиняют очередь шейпера. Скорость не растёт, задержка растёт, таймауты сыплются. При полисере — растут потери, и агрегат может даже упасть. Рост параллельности оправдан только до точки, где кривая агрегата вышла на плато.

Один таймаут на весь запрос

Убивает честно идущие большие загрузки на середине и тратит полосу впустую. Используйте таймаут прогресса.

Мгновенные повторы

При перегрузке повтор без паузы удваивает нагрузку на очередь. Десять потоков, повторяющих одновременно, устраивают маленький шторм. Экспоненциальная задержка и джиттер обязательны.

Мерить потолок одним замером

Одна цифра в 14:00 вторника ничего не говорит о поведении канала в 20:00 пятницы. Без суточного профиля вы либо недогрузите канал, либо построите систему на несуществующей полосе.

Замерять против медленного источника

Публичный сервер с загруженным аплинком покажет вам свой потолок, а не потолок прокси. Проверяйте источник напрямую.

Буферизовать ответ целиком

Без потокового чтения нет обратного давления. Клиент «глотает» всё, что даёт прокси, и лимитер на клиенте не работает. Плюс память под большие ответы.

Мультиплексировать всё в один туннель

HTTP/2 внутри одного CONNECT при лимите на соединение делит полосу между всеми запросами и создаёт блокировку головы очереди. Несколько TCP-соединений почти всегда эффективнее через прокси.

Игнорировать сжатие

Отключенный Accept-Encoding означает, что вы платите полосой за текст в несжатом виде. Пятикратная разница на пустом месте.

Путать полосу с задержкой

Канал на 50 мегабит с RTT 400 миллисекунд для сотни мелких API-вызовов медленнее канала на 10 мегабит с RTT 60 миллисекунд. Оценивайте оба параметра под ваш профиль трафика.

Считать запросы, а не байты

Планирование в запросах в секунду не учитывает размер ответов и приводит к неожиданному упору в потолок.

Инструменты и ресурсы

Для замеров

  • curl — универсальный инструмент для быстрых замеров через прокси. Ключ вывода переменных времени даёт среднюю скорость, время до первого байта, время соединения. Для посекундной записи проще написать десять строк на Python.
  • iperf3 — для измерения чистой полосы между вашей машиной и вашим сервером напрямую, чтобы исключить собственное узкое место. Через HTTP-прокси он не работает, но как контроль источника незаменим.
  • ss с ключом -ti — статистика TCP-соединений на Linux: RTT, окно перегрузки, ретрансмиссии, алгоритм управления перегрузкой. Главный бесплатный детектор полисера.
  • tcpdump и Wireshark — когда нужно увидеть, что именно происходит на уровне пакетов: паттерны потерь, задержки подтверждений, поведение окна.
  • mtr — трассировка с потерями по узлам, помогает понять, где именно возникают потери на пути до прокси.

Для локальной эмуляции

Прежде чем тестировать код на реальном прокси, соберите стенд. На Linux утилита tc с дисциплинами tbf (token bucket filter) и netem позволяет эмулировать шейпер с заданным rate и burst, полисер, задержку и потери. Вы можете воспроизвести карточку канала локально и гонять клиент против неё сколько угодно, не тратя трафик и не зависящий от времени суток. Разработчики, которые заводят такой стенд, отлаживают клиент в разы быстрее.

Для кода

  • Python: asyncio, aiohttp или httpx в потоковом режиме, собственный token bucket в 20 строк. Готовые библиотеки лимитеров есть, но большинство ограничивает запросы, а не байты, поэтому своя реализация надёжнее.
  • Go: пакет rate из расширенной стандартной библиотеки, обёртка над io.Reader для лимитирования чтения, контекст с дедлайнами для таймаутов.
  • Node.js: потоковый ответ с ручным управлением паузой и возобновлением, библиотеки для семафоров и повторов.

Для наблюдаемости

Экспортируйте метрики goodput, задержки первого байта, числа активных соединений, таймаутов и повторов по каждому порту прокси в систему сбора метрик и стройте панели. Сигнатуры ограничителя видны на графиках за минуту, а аномалии канала — задолго до того, как они уронят задачу. Без наблюдаемости адаптивный контроллер невозможно ни настроить, ни проверить.

Что почитать

Спецификации RFC по управлению перегрузкой TCP и по алгоритмам активного управления очередью дают глубокое понимание, почему шейперы ведут себя именно так. Документация Linux по дисциплинам очередей tc — практический справочник по эмуляции. Статьи по bufferbloat объясняют, почему глубокие буферы вредят и как с этим борются на уровне сетевого оборудования.

Кейсы и результаты

Кейс 1: парсер каталога маркетплейса, который «умирал» вечером

Задача: ежедневный обход каталога, около 400 тысяч страниц, через восемь мобильных каналов. Симптомы: ночью система отрабатывала за пять часов, вечером — таймауты на каждом третьем запросе, суточный план не выполнялся.

Замер по Методу 1 показал: ночной потолок канала около 18 мегабит, вечерний — 6–7. Метод 2: шейпер с глубокой очередью, задержка под нагрузкой росла с 90 до 1400 миллисекунд, лимит общий на сессию. Клиент использовал 32 потока на канал и единый таймаут в 20 секунд.

Что сделали: ввели клиентское ведро на 85 процентов от текущего потолка, снизили стартовую параллельность до 6 с адаптивным контроллером, заменили таймаут на трёхуровневый, включили сжатие и блокировку изображений (страницы стали весить 180 килобайт вместо 1,4 мегабайта). Результат: вечерний процент таймаутов упал с 33 до 0,4, суточный goodput вырос на 41 процент при том же наборе каналов, обход стал укладываться в 7 часов в любое время суток. Самое показательное: снижение параллельности с 32 до 6 увеличило полезную скорость, а не уменьшило.

Кейс 2: выгрузка медиафайлов и полисер

Задача: скачивание видео по 40–200 мегабайт с публичного хостинга через прокси, около 2 терабайт в месяц. Симптомы: рваная скорость, средняя вдвое ниже заявленной, частые обрывы на середине файла.

Замер показал классическую пилу: провалы на 40–50 процентов каждые несколько секунд, стабильный RTT, счётчик ретрансмиссий рос на десятки в секунду. Полисер с лимитом на соединение около 12 мегабит, агрегат до 4 потоков рос почти линейно.

Что сделали: разбили каждый файл на четыре части по Range и качали параллельно четырьмя соединениями, каждое с клиентским ведром на 10 мегабит, чуть ниже лимита полисера, чтобы потери не провоцировались. Добавили докачку по Range при таймауте прогресса. Результат: средняя скорость на файл выросла с 5,5 до 36 мегабит, обрывы перестали приводить к потере скачанного, месячный объём стал проходить за 12 дней вместо 30. Полисер невозможно обмануть, но можно не давать ему повода отбрасывать пакеты.

Кейс 3: смешанная нагрузка API и загрузок

Задача: одновременная работа с API социальной платформы (тысячи мелких запросов) и фоновая выгрузка медиаконтента через те же каналы. Симптомы: API-вызовы периодически уходили в задержку 3–5 секунд, платформа начинала считать клиента медленным.

Диагноз: шейпер на сессию, фоновые загрузки заполняли очередь, мелкие запросы вставали за ними. Классический bufferbloat внутри одной сессии.

Что сделали: развели классы по разным портам прокси одного узла; на портах фоновых загрузок ведро на 70 процентов их потолка, на портах API — параллельность не выше 3 и приоритет по задержке. Результат: девяностый процентиль задержки API упал с 3,8 секунды до 210 миллисекунд, фоновые загрузки замедлились на 12 процентов, что было приемлемо. Общая эффективность системы, измеренная в успешных операциях за час, выросла на 27 процентов.

FAQ: сложные вопросы о полосе и шейпинге

Почему при одном потоке скорость 8 мегабит, а при десяти — те же 8, но всё стало медленнее?

Лимит стоит на сессию, а не на соединение. Десять потоков делят один rate и заполняют очередь шейпера. Полоса не растёт, а задержка растёт пропорционально глубине очереди. Оптимально держать 2–4 потока и лимитировать чтение на клиенте.

Как понять, что упёрся в радиоканал, а не в настройку прокси?

Настройка даёт стабильное плато с «круглой» цифрой в разное время суток и одинаковой формой выхода. Радиоканал даёт плавающие некруглые значения и высокий коэффициент вариации, особенно вечером. Дополнительно сравните два порта одного узла одновременно: если сумма выше одного порта, лимит стоит на порт, а не на модем.

Стоит ли ставить BBR на своём сервере, если работаю через прокси?

BBR влияет на исходящий поток от вашего сервера. Если вы отдаёте данные через прокси, он поможет держать очередь шейпера пустой и снизит задержку. На входящий поток от целевых сайтов к вам он не влияет: там управляет отправитель. Для клиентской стороны важнее лимитер на чтении.

Насколько ниже потолка держать клиентское ведро?

Для шейпера — 85–90 процентов устоявшегося потолка: очередь почти пустая, задержка низкая, потеря полосы минимальна. Для полисера — 80–85 процентов от лимита на соединение, чтобы не провоцировать отбрасывание. Для нестабильного радиоканала лучше доверить точку адаптивному контроллеру, а ведро задать по вечернему профилю.

Можно ли использовать HTTP/2 через прокси для ускорения?

Через CONNECT-туннель HTTP/2 к целевому сайту работает, но все потоки делят одно TCP-соединение и один лимит, если он на соединение. Плюс блокировка головы очереди при насыщении. Для тяжёлых задач несколько HTTP/1.1-соединений через прокси обычно дают лучший goodput и предсказуемую задержку.

Как измерить размер ведра всплеска точнее?

Дайте каналу паузу 30–60 секунд, запишите байты с разрешением 100 миллисекунд, найдите точку перелома к устоявшейся скорости, посчитайте избыток над устоявшейся линией. Повторите пять раз, возьмите медиану. Точность около 15 процентов достаточна для планирования.

Что делать, если таймауты появляются только на конкретных доменах?

Скорее всего, узкое место не в прокси, а на пути от прокси к этому домену или на самом домене. Замерьте потолок против вашего эталонного источника в тот же момент: если он в норме, ограничение внешнее. В коде выделите такому домену отдельный класс с меньшей параллельностью и более длинным таймаутом первого байта.

Как понять, что адаптивный контроллер работает правильно?

На графиках параллельность должна плавно снижаться вечером и расти ночью, задержка первого байта — держаться в пределах полутора-двух базовых значений, доля таймаутов — ниже одного процента. Если параллельность дёргается между минимумом и максимумом каждую минуту, окно оценки слишком короткое или порог реакции слишком чувствительный.

Нужно ли учитывать шифрование при расчёте байтов?

TLS добавляет 2–5 процентов накладных расходов на заголовки записей и рукопожатия. Для планирования бюджета достаточно коэффициента 0,8 на всё вместе с TCP/IP. Для точного учёта считайте байты на уровне сокета, а не на уровне тела ответа.

Заключение: от догадок к управляемой полосе

Мы прошли путь от базовых понятий до архитектуры клиента, который не воюет с ограничителем, а согласуется с ним. Сведём главное.

  • Потолок — это минимум по нескольким уровням, и для мобильных каналов он плавает в течение суток. Одна цифра ничего не значит, нужен профиль.
  • Шейпер и полисер требуют разного кода. Шейпер наказывает задержкой, полисер — потерями. Различить их можно за десять минут тестом задержки под нагрузкой и статистикой ретрансмиссий.
  • Насыщение — это не про скорость, а про очередь. Bufferbloat превращает быстрый канал в вязкий и убивает мелкие запросы раньше, чем упадёт скорость больших.
  • Клиент должен читать потоково, лимитировать чтение чуть ниже потолка, использовать три раздельных таймаута, адаптивно управлять параллельностью и повторять с задержкой.
  • Планируйте байты, а не запросы. Сжатие, отказ от лишних ресурсов и условные запросы часто дают больше, чем любые ухищрения с потоками.

Что делать дальше? Сегодня: поднять эталонный источник и снять карточку канала по Методам 1 и 2 хотя бы для одного порта. На этой неделе: собрать локальный стенд на tc, воспроизвести карточку и переписать клиент по чек-листу Метода 3. В течение месяца: включить учёт байтов, построить панели и настроить адаптивный контроллер, затем пересчитать бюджет трафика по Методу 4.

Полоса перестаёт быть источником сюрпризов ровно в тот момент, когда вы начинаете её измерять и уважать. Код, написанный с пониманием ограничителя, работает не только быстрее. Он работает предсказуемо, а в инфраструктурных задачах предсказуемость и есть главная валюта.