Rate limit на клиенте: token bucket, leaky bucket и лимиты по хостам — экспертное руководство
Содержание статьи
- Введение: зачем клиенту собственный rate limit
- Основы: что такое rate limit на клиенте и почему сервера недостаточно
- Глубокое погружение: семейства алгоритмов и их математика
- Метод 1: token bucket на практике — реализация без подводных камней
- Метод 2: leaky bucket и gcra — когда нужен ровный поток
- Метод 3: лимиты по хостам — реестр, иерархия и композиция
- Метод 4: лимитер и ротация ip — как учитывать смену адреса в модели
- Типичные ошибки проектирования клиентского rate limit
- Инструменты и ресурсы для реализации
- Кейсы и сценарии применения
- Faq: ответы на сложные вопросы
- Заключение: что делать дальше
Введение: зачем клиенту собственный rate limit
Представьте, что вы пришли в банк, где работает одно окно, а за вами выстроилась очередь из тысячи человек. Можно толкаться, можно кричать, но пропускная способность окна от этого не вырастет. Можно лишь либо прийти в разумном темпе, либо получить отказ. Серверный rate limit (ограничение частоты запросов) — это тот самый операционист, который однажды просто перестаёт вас обслуживать. А клиентский rate limit — ваше личное решение не подходить к окну чаще, чем оно физически способно принять.
Эта статья целиком посвящена алгоритмам. Мы сознательно не будем повторять материалы о том, как обрабатывать код 429 и выстраивать экспоненциальный backoff, и не станем обсуждать, сколько потоков запускать. Здесь другой фокус: как заранее, ещё до отправки запроса, вычислить, можно ли его отправлять сейчас, и если нет — сколько ждать. Именно эта математика отделяет клиента, который «иногда получает отказы», от клиента, который годами работает с одним и тем же API, не вызывая раздражения у его владельцев.
Что вы узнаете из материала:
- как устроены четыре семейства алгоритмов — fixed window, sliding window, token bucket и leaky bucket — и чем они отличаются на уровне поведения, а не только названий;
- почему token bucket и GCRA (вариант leaky bucket) стали стандартом де-факто и как реализовать их за один вечер без ошибок округления;
- как строить иерархию лимитов: глобальный бюджет, бюджет на хост, на эндпоинт, на ключ авторизации и на исходящий IP-адрес;
- как встроить ротацию IP в модель лимитера, не ломая ни серверные квоты, ни собственную телеметрию;
- какие ошибки проектирования выглядят безобидно, но приводят к бесконечному ожиданию, «взрывам» в начале минуты и утечке памяти.
Мы будем говорить языком инженера-наставника: с формулами, но без заумности, с примерами, но без воды. Если вы пишете парсер, SDK для чужого API, интеграцию с маркетплейсом или агрегатор, который ходит на сотни хостов, — это руководство стоит добавить в закладки.
Основы: что такое rate limit на клиенте и почему сервера недостаточно
Два взгляда на одну проблему
Серверный rate limit защищает инфраструктуру владельца API: он считает ваши запросы и отвечает отказом, когда квота исчерпана. Клиентский rate limit решает другую задачу — не доводить до отказа. Разница принципиальна. Сервер реагирует постфактум: запрос уже ушёл, канал занят, лог засорён, репутация клиента чуть испорчена. Клиент же действует упреждающе: он знает (или оценивает) бюджет и расходует его аккуратно.
Почему нельзя просто полагаться на серверные отказы и повторять попытки? Потому что каждая отклонённая попытка — это потраченное соединение, потраченный токен авторизации, строка в чужом журнале безопасности и, как правило, ухудшение вашей позиции в адаптивных системах защиты. Клиент, который сам соблюдает режим, выглядит для сервера как хорошо воспитанный партнёр. А клиент, который «пробует, пока не пустят», выглядит как источник проблем. Угадайте, кого ограничат жёстче при следующем пересмотре политик?
Базовая терминология
- Rate (скорость) — установившаяся частота запросов, например «десять запросов в секунду». Это то, что сервер готов принимать бесконечно долго.
- Burst (всплеск) — сколько запросов можно отправить сразу, подряд, не дожидаясь пополнения. Сервер часто допускает короткие всплески, если средняя скорость не нарушается.
- Окно (window) — отрезок времени, за который считаются запросы: секунда, минута, час, сутки.
- Квота (quota) — максимальное число запросов в окне. Квота делённая на длину окна и есть средняя скорость.
- Ключ лимита (limit key) — признак, по которому сервер группирует запросы: IP-адрес, токен, аккаунт, пара «хост плюс эндпоинт». Один и тот же клиент почти всегда попадает одновременно под несколько ключей.
- Стоимость (cost) — вес запроса. Некоторые API считают поиск за десять единиц, а чтение карточки — за одну.
Главный принцип: лимитер решает «когда», а не «сколько»
Распространённое заблуждение — путать лимитер с семафором. Семафор ограничивает число одновременных операций и отвечает на вопрос «сколько сейчас в полёте». Лимитер ограничивает частоту и отвечает на вопрос «можно ли начать ещё одну операцию прямо сейчас, а если нет — через сколько миллисекунд можно». Эти два механизма дополняют друг друга, но не взаимозаменяемы. Можно держать одно соединение и при этом превышать лимит, если запросы короткие. Можно держать сто соединений и соблюдать лимит, если запросы медленные.
Три свойства хорошего клиентского лимитера
- Предсказуемость. При одинаковом входе он даёт одинаковый ответ. Никаких «иногда пропускает чуть больше».
- Дешевизна. Решение принимается за константное время и с константной памятью на ключ. Если у вас тысячи хостов, лимитер не может хранить историю всех запросов.
- Честность. Если несколько задач ждут разрешения, они получают его в порядке очереди, а не в порядке «кто удачнее проснулся».
Держите эти три критерия в голове: по ним мы будем сравнивать алгоритмы в следующем разделе.
Глубокое погружение: семейства алгоритмов и их математика
Fixed window — честный, но коварный счётчик
Самый простой вариант: делим время на окна фиксированной длины, в каждом окне ведём счётчик, при достижении квоты ждём начала следующего окна. Памяти — одно число и одна метка времени на ключ. Казалось бы, идеал.
Проблема называется эффектом границы окна. Если квота — сто запросов в минуту, клиент может отправить сто запросов в последнюю секунду одного окна и ещё сто в первую секунду следующего. С точки зрения клиента всё законно: в каждом окне ровно сто. С точки зрения сервера за две секунды пришло двести запросов — вдвое выше любой разумной трактовки лимита. Если сервер считает скользящим окном (а большинство современных так и делает), вы получите отказ, искренне считая себя невиновным.
Вторая беда — синхронизация всплесков. Все ваши воркеры одновременно «просыпаются» в начале минуты, потому что именно тогда обнуляется счётчик. Это создаёт пики нагрузки на сеть, на прокси и на целевой сервер.
Sliding window log — точно, но дорого
Храним метки времени всех запросов за последний интервал. Перед отправкой выбрасываем устаревшие и считаем оставшиеся. Абсолютно точный учёт, никакого эффекта границы. Но память растёт линейно с квотой: при квоте в десять тысяч запросов в час вы храните десять тысяч меток на каждый ключ. Для одного хоста терпимо, для тысячи хостов — нет.
Sliding window counter — компромисс
Храним два счётчика: текущего окна и предыдущего. Оценка нагрузки — это текущий счётчик плюс предыдущий, умноженный на долю предыдущего окна, которая ещё попадает в скользящий интервал. Если прошло 20 процентов текущей минуты, берём 80 процентов прошлого счётчика. Это приближение, но оно отлично сглаживает границу и требует всего две переменные. Многие серверные реализации используют именно его, поэтому имитировать его на клиенте — хороший способ «думать как сервер».
Token bucket — ведро с жетонами
Представьте ведро ёмкостью B жетонов. Каждую секунду в него капает r жетонов, лишние переливаются через край. Чтобы отправить запрос стоимостью c, нужно взять c жетонов. Если их нет — ждать, пока накапает.
Два параметра дают два независимых свойства. Параметр r — установившаяся скорость: сколько бы вы ни ждали, долгосрочный темп не превысит r запросов в секунду. Параметр B — максимальный всплеск: после простоя можно сразу отправить B запросов. Это идеально соответствует тому, как формулируются реальные серверные политики: «не более ста в минуту, не более десяти за раз».
Ключевая деталь реализации — ленивое пополнение. Не нужен фоновый поток, который каждую секунду добавляет жетоны. Достаточно при каждом обращении вычислить, сколько прошло времени с прошлого обращения, и добавить соответствующее количество: tokens = min(B, tokens + elapsed * r). Два числа на ключ, вычисление за константное время. Полностью соответствует критерию дешевизны.
Leaky bucket — ведро с дыркой
Здесь метафора обратная: запросы вливаются в ведро, а из дырки на дне они вытекают с постоянной скоростью r. Ведро переполнилось — новый запрос отвергается или ждёт. Выход всегда ровный: никаких всплесков, строго один запрос каждые 1/r секунд. Если у сервера нет толерантности к всплескам или вы хотите максимально гладкий профиль трафика, это ваш выбор.
Существуют две трактовки leaky bucket. Первая — как очередь: запросы реально складываются в буфер, а отдельный процесс выпускает их по таймеру. Вторая — как счётчик: мы просто проверяем, не переполнится ли воображаемое ведро, и либо пропускаем, либо нет. Вторая трактовка в телекоммуникациях называется GCRA (Generic Cell Rate Algorithm) и математически эквивалентна token bucket с другой параметризацией. Это важное наблюдение: если вы уже реализовали token bucket, вы умеете делать и leaky bucket.
GCRA: один таймстемп вместо счётчика
GCRA хранит единственное значение — TAT (theoretical arrival time, теоретическое время прибытия): момент, раньше которого следующий «идеальный» запрос приходить не должен. Параметры: интервал эмиссии T = 1/r и допуск τ, равный (B − 1) * T. Алгоритм:
- Получаем текущее время now.
- Если TAT меньше now, считаем TAT равным now (ведро давно пустое).
- Если TAT − τ больше now — запрос пришёл слишком рано; время ожидания равно TAT − τ − now.
- Иначе разрешаем запрос и сдвигаем TAT на T вперёд.
Одно число на ключ, никаких счётчиков с плавающей точкой, которые постепенно расходятся. По этой причине GCRA — любимый алгоритм для распределённых лимитеров: его состояние легко хранить в одном поле ключ-значение и атомарно обновлять.
Сравнительная таблица в словах
- Fixed window: память минимальна, точность низкая, всплески на границах, годится лишь как грубая страховка.
- Sliding log: точность абсолютная, память линейна от квоты, уместен для нескольких ключей с небольшими квотами.
- Sliding counter: память две переменные, точность приближённая, хорошо имитирует серверную логику.
- Token bucket: память две переменные, явный контроль всплеска, стандарт для клиентских SDK.
- Leaky bucket / GCRA: память одна переменная, идеально ровный выход, стандарт для распределённых систем.
О часах: монотонность и дрейф
Все алгоритмы опираются на «текущее время». Используйте монотонные часы (monotonic clock), а не системное время. Системное время может прыгнуть назад при синхронизации, и ваш лимитер решит, что прошло отрицательное число секунд, обнулит пополнение или, наоборот, выдаст гигантский всплеск. Монотонные часы гарантированно не идут назад. Единственное исключение — распределённый лимитер в общем хранилище, где время берётся на стороне хранилища, а не на клиентах, чтобы не зависеть от расхождения часов между машинами.
Метод 1: token bucket на практике — реализация без подводных камней
Шаг 1. Выбор параметров
Переводите серверную политику в пару (r, B). Если документация говорит «сто запросов в минуту», базовая скорость r = 100/60 жетонов в секунду. Ёмкость B — отдельное решение. Безопасный выбор для незнакомого API — B равна от пяти до десяти процентов квоты окна, то есть пять-десять жетонов при квоте сто. Это позволяет быстро отработать небольшую пачку, но не создаёт пиков, которые сервер со скользящим окном воспримет как нарушение.
Ещё лучше — считать с запасом: использовать 80–90 процентов задекларированной скорости. Серверные счётчики, сетевые задержки и округления на обеих сторонах неизбежно вносят погрешность, и запас её поглощает.
Шаг 2. Структура состояния
На каждый ключ храните: tokens (вещественное число, текущее количество жетонов), last (монотонная метка последнего пересчёта), rate, capacity. Защищайте состояние мьютексом или, в асинхронном коде, единственной задачей-арбитром, через которую проходят все запросы на жетоны.
Шаг 3. Алгоритм acquire(cost)
- Захватываем блокировку.
- now = monotonic(); elapsed = now − last; last = now.
- tokens = min(capacity, tokens + elapsed * rate).
- Если tokens ≥ cost: tokens −= cost; отпускаем блокировку; возвращаем «ноль ожидания».
- Иначе: wait = (cost − tokens) / rate; списываем жетоны в минус: tokens −= cost; отпускаем блокировку; возвращаем wait.
- Вызывающая сторона спит wait секунд и затем отправляет запрос.
Обратите внимание на пункт пять. Списание в минус — это резервирование. Оно гарантирует честность: следующий вызов увидит отрицательный остаток и получит ещё большее ожидание, то есть встанет в очередь за предыдущим. Без резервирования возникает классическая ошибка: десять задач одновременно видят ноль жетонов, все рассчитывают одинаковое ожидание, все просыпаются одновременно и устраивают всплеск, который лимитер должен был предотвратить.
Шаг 4. Ограничение глубины резервирования
Резервирование в минус может уйти в бесконечность: если задачи прибывают быстрее, чем пополняются жетоны, очередь ожидающих растёт, а время ожидания последнего стремится к часам. Введите максимальную задержку (max_delay). Если вычисленное wait больше порога, не резервируйте, а возвращайте ошибку «лимитер перегружен». Пусть планировщик задач решает, что делать: отложить, снизить приоритет, переключить на другой хост. Это та самая точка, где клиентский лимитер превращается из пассивного тормоза в инструмент управления нагрузкой.
Шаг 5. Взвешенная стоимость
Позвольте запросам иметь разный cost. Поисковые эндпоинты, массовые выборки, операции записи обычно «дороже» для сервера, и многие API это отражают в своих политиках. Если документация молчит, задавайте вес по собственным наблюдениям о времени ответа: запрос, который сервер обрабатывает дольше, разумно считать дороже. Формула ожидания от этого не меняется — cost просто входит в неё множителем.
Шаг 6. Прогрев и холодный старт
Начальное значение tokens — отдельное решение. Полное ведро при старте означает мгновенный всплеск B запросов, как только процесс запустился. Это может быть нежелательно, если у вас десятки процессов стартуют одновременно после деплоя. Безопаснее начинать с нуля или с половины ёмкости. А если известно, что сервер считает квоту по окну, не привязанному к вашему старту, нулевой старт ещё и честнее.
Чек-лист token bucket
- Используются монотонные часы.
- Пополнение ленивое, по разнице времени, без фоновых таймеров.
- Резервирование в минус для честной очереди.
- Есть max_delay и явный отказ при переполнении.
- Скорость задана с запасом относительно серверной.
- Ёмкость ограничена разумной долей квоты окна.
- Поддерживается cost для взвешенных запросов.
- Начальное состояние не создаёт всплеск при деплое.
Метод 2: leaky bucket и GCRA — когда нужен ровный поток
Когда предпочесть leaky bucket
Token bucket разрешает всплески. Это удобно, но есть ситуации, где всплеск вреден сам по себе: сервер агрессивно реагирует на кратковременные пики, прокси-канал имеет ограниченную полосу, вы хотите, чтобы паттерн трафика выглядел как у обычного, неспешного клиента. Во всех этих случаях нужен выход с жёстко постоянным интервалом между запросами. Это и есть leaky bucket.
Реализация как очереди
Классический вариант: буфер фиксированной ёмкости и единственный потребитель, который раз в T секунд достаёт элемент и отправляет его. Плюс — простота и наглядность. Минусы — нужен отдельный поток или задача, а при остановке потребителя буфер «замерзает». Этот подход уместен, когда у вас есть явный конвейер: очередь задач, из которой запросы и так берутся по одному.
Реализация как GCRA
Для большинства клиентских сценариев удобнее счётчиковая трактовка. Выше мы описали алгоритм; разберём, как задать параметры. Если требуется строгий интервал, положите τ = 0: тогда допуск нулевой, и запросы проходят не чаще, чем раз в T. Если хотите разрешить небольшой всплеск, увеличьте τ. Так одна реализация покрывает и строгий leaky bucket, и token bucket. Именно поэтому GCRA — хороший «единый движок» для библиотеки лимитирования.
Пошаговая процедура GCRA с резервированием
- Прочитать TAT для ключа; если его нет, считать TAT = now.
- new_TAT = max(TAT, now) + T * cost.
- allow_at = new_TAT − τ − T * cost; это момент, когда запрос с такой стоимостью можно было бы отправить без ожидания.
- Если allow_at ≤ now: записать new_TAT, вернуть «ноль ожидания».
- Иначе: wait = allow_at − now; если wait больше max_delay — вернуть отказ без записи; иначе записать new_TAT и вернуть wait.
В распределённом хранилище шаги с первого по пятый выполняются одной атомарной операцией — например, скриптом на стороне хранилища. Так гарантируется, что два клиента не прочитают один и тот же TAT и не «продублируют» разрешение.
Эквивалентность и выбор по характеру нагрузки
Полезно понимать: token bucket с параметрами (r, B) и GCRA с параметрами (T = 1/r, τ = (B − 1)/r) пропускают ровно одни и те же последовательности запросов. Разница только в представлении состояния. Поэтому вопрос «что лучше» на самом деле звучит иначе: нужен ли вам всплеск. Нужен — ставьте B больше единицы. Не нужен — ставьте B = 1 (τ = 0). Остальное — вкус и удобство хранения.
Чек-лист leaky bucket / GCRA
- Решено, нужен всплеск или строго ровный поток.
- Состояние — одно значение TAT на ключ.
- Операция чтения-проверки-записи атомарна.
- Есть max_delay и явный отказ.
- Время в распределённом варианте берётся на стороне хранилища.
Метод 3: лимиты по хостам — реестр, иерархия и композиция
Почему «один лимитер на всё» не работает
Если ваш клиент ходит только на один API, достаточно одного ведра. Но агрегаторы, парсеры и интеграционные шины обращаются к десяткам и сотням хостов, у каждого своя политика. Единый глобальный лимит либо недоиспользует быстрые хосты, либо перегружает медленные. Нужен реестр лимитеров: отображение «ключ лимита — состояние ведра», где ключ строится из характеристик запроса.
Ключ лимита: от хоста к эндпоинту
Минимальный ключ — схема плюс хост плюс порт. Два домена одного владельца часто делят квоту, а поддомены могут считаться отдельно; это нужно знать из документации или выяснять наблюдением. Более тонкий ключ — хост плюс шаблон пути: например, поисковый эндпоинт и эндпоинт карточки товара имеют разные квоты. Ещё тоньше — хост плюс токен авторизации, если сервер считает квоту на ключ API, а у вас их несколько.
Практическое правило: стройте ключ из тех же признаков, по которым считает сервер. Если сервер считает по IP, в ключ входит ваш исходящий IP. Если по токену — токен. Если по тому и другому одновременно — вам нужны два лимитера, и запрос должен пройти оба.
Иерархия лимитов
Хорошо спроектированная система выстраивает лимитеры по уровням:
- Глобальный — общий бюджет процесса. Защищает ваши собственные ресурсы: сокеты, память, полосу канала.
- По исходящему IP — сколько запросов уходит через конкретный адрес. Ключевой уровень при работе через пул адресов.
- По хосту — политика целевого сервера в целом.
- По эндпоинту — отдельные квоты на дорогие методы.
- По учётным данным — квоты на токен или аккаунт.
Запрос обязан получить разрешение на каждом уровне. Это и есть композиция лимитеров.
Композиция без взаимной блокировки
Наивный подход — последовательно вызвать acquire у каждого лимитера и просуммировать ожидания. Он неверен: первый лимитер уже списал жетон, а второй заставляет ждать десять секунд, за которые жетон первого «протухает» с точки зрения справедливости. Хуже того, две задачи, захватывающие лимитеры в разном порядке, могут бесконечно мешать друг другу.
Корректная процедура:
- Для каждого лимитера вычислить ожидание без списания (операция peek).
- Взять максимум ожиданий — это общее wait.
- Если wait превышает max_delay — отказ.
- Иначе выполнить списание во всех лимитерах, передав им единое время прибытия now + wait, чтобы каждый резервировал ресурс на один и тот же момент.
- Спать wait и отправлять.
Всегда обходите лимитеры в одном и том же фиксированном порядке (например, от глобального к самому узкому). Это исключает взаимные блокировки при конкурентном доступе.
Конфигурация и значения по умолчанию
Реестр должен уметь создавать лимитер для ранее не виденного хоста. Задайте консервативный дефолт: низкая скорость, минимальный всплеск. Для известных хостов — явная конфигурация. Хорошая практика — хранить политику в декларативном виде: хост или шаблон, rate, burst, cost по шаблонам путей, признак «считать по IP» и «считать по токену». Тогда при изменении политики сервера меняется один файл, а не код.
Вытеснение и утечки
Реестр с тысячами хостов — это кандидат на утечку памяти. Хосты, к которым давно не обращались, нужно вытеснять. Поскольку состояние ведра после долгого простоя всё равно «полное» (или TAT в прошлом), вытеснение не теряет информации: при следующем обращении лимитер создастся заново в том же состоянии. Используйте LRU-кэш с ограничением размера либо периодическую чистку записей, у которых last старше нескольких окон.
Чек-лист лимитов по хостам
- Ключ лимита повторяет признаки, по которым считает сервер.
- Есть уровни: глобальный, IP, хост, эндпоинт, учётные данные.
- Композиция через peek — максимум — единое списание.
- Лимитеры обходятся в фиксированном порядке.
- Консервативные дефолты для неизвестных хостов.
- Политики вынесены в конфигурацию.
- Реестр ограничен по размеру и вытесняет неактивные ключи.
Метод 4: лимитер и ротация IP — как учитывать смену адреса в модели
Почему ротация ломает наивный лимитер
Если целевой сервер считает квоту по IP, то смена адреса меняет ключ лимита на стороне сервера. Наивный клиент, который ведёт один счётчик на хост, после смены IP продолжит тормозить, хотя сервер уже видит «нового» посетителя. Обратная ошибка опаснее: клиент сбрасывает все лимиты при смене IP, включая те, что сервер считает по токену или аккаунту, — и получает отказ по квоте, которая к IP не имеет никакого отношения. Вывод: ротация должна влиять только на уровень «по исходящему IP» в иерархии, а остальные уровни — жить своей жизнью.
Два режима смены адреса
В инфраструктуре Proxeon IP на порту меняется либо по таймеру, либо по ссылке/API (по данным на 22.09.2026). Это два принципиально разных сценария для лимитера. При таймерной смене клиент не управляет моментом: адрес меняется «извне», и лимитер по IP должен узнавать об этом — через событие, опрос текущего адреса либо по расписанию, если интервал известен. При смене по ссылке клиент сам инициирует переключение и может синхронизировать его с собственным состоянием: дождаться завершения запросов в полёте, зафиксировать момент, завести новый ключ «хост плюс IP-эпоха».
Насколько распространён каждый режим? По данным на 14.11.2026, доля смен IP по таймеру составляет 51,1 %, остальное приходится на ссылку/API. То есть обе стратегии встречаются примерно поровну, и универсальный лимитер должен поддерживать обе.
Эпоха адреса как часть ключа
Вместо того чтобы хранить в ключе сам IP (его можно и не знать заранее), используйте эпоху — счётчик, увеличивающийся при каждой смене. Ключ уровня «по IP» становится парой «порт плюс эпоха». При смене эпохи старый ключ просто перестаёт использоваться и позже вытесняется реестром, новый создаётся в начальном состоянии. Обратите внимание: начальное состояние снова должно быть консервативным. Новый адрес для сервера — незнакомец, и первое, что он увидит, — ваш паттерн трафика.
Согласование окна лимитера с таймером ротации
По данным на 14.11.2026, медианный интервал между сменами IP по таймеру составляет 120 с, а 78,1 % таймерных интервалов кратны ровно минуте. Это очень удобно для проектирования. Если у вас квота на хост «N запросов в минуту по IP», а адрес живёт две минуты, то бюджет одного адреса — ровно два окна. Лимитер по IP может работать как token bucket со скоростью N/60 и ёмкостью, рассчитанной так, чтобы за время жизни адреса не превысить 2N. Важно не «догонять» упущенное: если в первую минуту вы отправили мало, во вторую нельзя отправлять вдвое больше, потому что сервер считает по минутному окну, а не по вашей эпохе.
Пауза на время переключения
Смена адреса не мгновенна. По данным на 14.11.2026, средняя длительность самой смены — от команды до нового адреса — 4,56 с, и 80,8 % смен укладываются в 5 секунд. Что это значит для лимитера? На время переключения запросы либо уйдут через старый адрес, либо не уйдут вовсе. Правильная стратегия — трактовать переключение как короткий интервал «дренажа»: перед командой смены лимитер перестаёт выдавать новые разрешения, ждёт завершения запросов в полёте, выполняет смену, затем открывает новую эпоху. Поскольку четыре из пяти переключений завершаются в пределах пяти секунд, разумно закладывать таймаут ожидания нового адреса чуть выше этой отметки и переходить к обработке исключения, если он превышен.
Ограничьте частоту самой команды смены
Вот инсайт, который часто упускают: команда смены IP — тоже запрос к API, и его тоже нужно лимитировать. По данным на 14.11.2026, доля дублирующихся записей о сменах по ссылке (интервал не более 2 с, тот же IP) — 1,2 %. Это следы ситуаций, когда клиент дёрнул ссылку дважды подряд: из-за гонки между воркерами, из-за повтора по таймауту, из-за отсутствия единой точки принятия решения. Решение — отдельное ведро с ёмкостью один и строгим интервалом (чистый leaky bucket с τ = 0) на команду ротации, плюс дедупликация: если смена уже запущена, остальные воркеры ждут её результата, а не инициируют новую. Тот же принцип, что и для целевых хостов, только применённый к вашей собственной инфраструктуре.
Масштаб и планирование бюджета
Чтобы почувствовать масштаб: по данным на 14.11.2026, за сутки по всей сети Proxeon выполнено 2 196 242 смены IP, в них участвовало 7 924 прокси-порта, а медиана уникальных IP на один модем за сутки — 95. Для проектировщика лимитера это означает, что один порт за сутки проходит через десятки адресных эпох, и состояние «по IP» должно быть лёгким и быстро вытесняемым: хранить историю всех эпох нет никакого смысла, а вот обеспечить константную стоимость создания новой эпохи — обязательно.
Протоколы и адресация портов
Мелочь, которая упрощает конфигурацию: в Proxeon SOCKS5-порт равен HTTP-порту плюс один (по данным на 22.09.2026). Если вы используете оба протокола для одного и того же канала, лимитер по IP должен считать их как один ключ, а не два: адрес у них общий, значит, и бюджет общий. Запишите в реестре нормализацию: ключ строится по HTTP-порту, а SOCKS5-порт приводится к нему вычитанием единицы.
Распределённый лимитер по IP
Когда через один порт ходят несколько процессов или машин, ведро должно быть общим. Используйте хранилище с атомарными операциями, храните TAT (GCRA) под ключом «порт плюс эпоха плюс хост», обновляйте скриптом на стороне хранилища и берите время оттуда же. Эпоху также храните централизованно и меняйте атомарно вместе с командой ротации — тогда все процессы согласованно переходят на новый ключ.
Чек-лист лимитера при ротации
- Ротация влияет только на уровень «по IP», остальные уровни не сбрасываются.
- Поддерживаются оба режима: таймер и смена по ссылке/API.
- Ключ уровня IP включает эпоху адреса.
- Новая эпоха стартует в консервативном состоянии.
- Скорость по IP согласована с серверным окном, а не с длиной эпохи.
- На время переключения выдача разрешений приостанавливается.
- Команда ротации сама лимитируется и дедуплицируется.
- HTTP- и SOCKS5-порты одного канала нормализуются в один ключ.
- Для многопроцессных сценариев состояние вынесено в общее хранилище.
Типичные ошибки проектирования клиентского rate limit
Ошибка 1. Sleep вместо лимитера
«Поставим паузу сто миллисекунд между запросами» — самое частое решение и самое хрупкое. Оно не учитывает время самого запроса, не работает при нескольких воркерах, не даёт всплесков там, где они разрешены, и не защищает от их возникновения там, где запрещены. Пауза — это не лимитер, а его имитация.
Ошибка 2. Считать по окну, когда сервер считает скользяще
Эффект границы окна разобран выше. Если вы не уверены, как считает сервер, предполагайте худшее — скользящее окно — и используйте token bucket со скромной ёмкостью.
Ошибка 3. Гонка без резервирования
Несколько задач одновременно вычисляют одинаковое ожидание, засыпают и просыпаются вместе. Результат — ровно тот всплеск, который лимитер должен был предотвратить. Лечится резервированием (списанием в минус или сдвигом TAT) под блокировкой.
Ошибка 4. Бесконечная очередь ожидания
Без max_delay очередь растёт неограниченно, а задачи ждут минуты и часы, занимая память и соединения. Лимитер должен уметь отказывать.
Ошибка 5. Системные часы
Один скачок времени при синхронизации — и ведро либо переполняется, либо «застывает». Только монотонные часы на клиенте; только время хранилища в распределённом варианте.
Ошибка 6. Сброс всех лимитов при смене IP
Квоты по токену и аккаунту не зависят от адреса. Сбросив их, вы тут же нарушите политику, которая вас не касалась.
Ошибка 7. Полное ведро при старте
Десятки процессов после деплоя стартуют с полными вёдрами и одновременно выдают всплеск. Начинайте с пустого ведра или добавляйте случайную задержку старта.
Ошибка 8. Реестр без вытеснения
Каждый новый хост — новая запись навсегда. Через недели работы процесс держит в памяти лимитеры для хостов, которые больше никогда не понадобятся.
Ошибка 9. Игнорирование стоимости запроса
Если сервер считает поиск за десять единиц, а вы — за одну, ваш лимитер пропустит в десять раз больше, чем нужно, и будет искренне удивлён отказом.
Ошибка 10. Неограниченная команда ротации
Повтор команды смены адреса по таймауту или из нескольких воркеров приводит к дублям и лишним переключениям. Команда — тоже ресурс; дайте ей ведро.
Инструменты и ресурсы для реализации
Готовые библиотеки по экосистемам
- Go: пакет golang.org/x/time/rate — эталонная реализация token bucket с методами Allow, Reserve и Wait. Метод Reserve возвращает объект с временем ожидания и возможностью отмены — именно то, что нужно для композиции.
- Python: библиотека limits предоставляет fixed window, sliding window и GCRA с разными бэкендами; aiolimiter реализует leaky bucket для asyncio; pyrate-limiter поддерживает несколько окон одновременно.
- Java/Kotlin: Bucket4j — зрелый token bucket с поддержкой распределённых хранилищ; Resilience4j RateLimiter — вариант с фиксированными циклами обновления.
- JavaScript/TypeScript: bottleneck умеет лимитировать по группам ключей и кластеризоваться через общее хранилище; p-throttle — минималистичный вариант для простых случаев.
- Rust: governor — реализация GCRA с ключами и без, пригодная для асинхронного кода.
- .NET: встроенное пространство System.Threading.RateLimiting с token bucket, sliding window и partitioned-лимитерами по ключам.
Хранилища для распределённого состояния
Redis и совместимые хранилища с серверными скриптами — стандарт для общего GCRA: одна атомарная операция, время берётся командой хранилища, ключи с TTL автоматически вытесняются. Для сценариев внутри одного кластера приложений подойдут и встроенные механизмы вроде распределённых кэшей с атомарными операциями.
Инструменты наблюдаемости
Лимитер без метрик — чёрный ящик. Экспортируйте: число разрешений без ожидания, распределение времени ожидания, число отказов по max_delay, текущее заполнение вёдер по ключам, частоту смены эпох адресов. Гистограмма ожидания по хостам моментально покажет, где политика слишком жёсткая, а где вы на грани.
Инфраструктура адресов
Для сценариев с ротацией понадобится провайдер, который даёт два режима смены адреса — по таймеру и по ссылке/API — и предсказуемую адресацию портов. В Proxeon оба режима доступны, а SOCKS5-порт отстоит от HTTP-порта ровно на единицу (по данным на 22.09.2026), что упрощает нормализацию ключей в реестре лимитеров.
Что читать
- Описание GCRA в спецификациях телекоммуникационных стандартов — первоисточник для leaky bucket как счётчика.
- Документация пакета x/time/rate — образцовая формулировка семантики Reserve и Wait.
- Разделы о лимитах в документации крупных публичных API — там встречаются все модели подсчёта, и это лучший способ научиться переводить политику в параметры ведра.
Кейсы и сценарии применения
Сценарий 1. Агрегатор цен на сотни хостов
Задача: регулярно обходить карточки товаров на множестве площадок, у каждой своя политика. Решение: реестр лимитеров с ключом «хост плюс шаблон пути», консервативный дефолт для новых площадок, явные политики для известных. Композиция с глобальным лимитом по числу сокетов. Результат, которого добиваются такие системы: равномерная загрузка всех хостов без простоев на быстрых и без перегрузки медленных; при изменении политики площадки правится одна строка конфигурации. Главный урок — переход от единого глобального лимита к иерархии резко снижает долю запросов, отправленных «зря».
Сценарий 2. SDK для партнёрского API с квотой на токен и на IP
Задача: библиотека для клиентов, у которых несколько токенов и несколько исходящих адресов. Решение: два уровня лимитеров — по токену и по адресу — с композицией через peek и единым временем прибытия. Планировщик выбирает пару «токен плюс адрес» с наименьшим ожиданием. Урок — лимитер превращается в инструмент маршрутизации: вместо «ждать» он подсказывает «куда отправить, чтобы не ждать».
Сценарий 3. Парсер на мобильных адресах с таймерной ротацией
Задача: обход открытых страниц через пул портов, адреса меняются по таймеру. Решение: лимитер по IP с ключом «порт плюс эпоха», скорость согласована с минутным окном целевого хоста. С учётом того, что по данным на 14.11.2026 медианный таймерный интервал — 120 с, а 78,1 % интервалов кратны минуте, бюджет на эпоху вычисляется как целое число минутных окон. На время переключения — а 80,8 % смен укладываются в 5 секунд (по данным на 14.11.2026) — выдача разрешений ставится на паузу с таймаутом чуть выше этого порога. Урок — согласование окна лимитера с ритмом ротации избавляет от «догоняющих» всплесков в начале новой эпохи.
Сценарий 4. Воркеры с ротацией по ссылке и дублирующиеся команды
Задача: несколько воркеров делят один порт и каждый при необходимости инициирует смену адреса. Симптом — следы повторных команд в журналах. Решение: единая точка ротации с leaky bucket (τ = 0) и дедупликацией: если смена уже идёт, остальные ждут её завершения. По данным на 14.11.2026, доля дублирующихся записей о сменах по ссылке по сети — 1,2 %; это ровно те ситуации, которые устраняет единая точка принятия решения. Урок — лимитировать нужно не только запросы к чужим API, но и команды к собственной инфраструктуре.
Сценарий 5. Единый движок на GCRA для всех уровней
Задача: упростить кодовую базу, где исторически сосуществовали fixed window, sleep-паузы и ручные счётчики. Решение: одна реализация GCRA с параметрами (T, τ), применяемая на всех уровнях иерархии, с хранением состояния в общем хранилище для распределённых ключей и в памяти — для локальных. Урок — одна формула заменяет зоопарк решений и делает поведение системы предсказуемым.
FAQ: ответы на сложные вопросы
Чем token bucket принципиально отличается от leaky bucket, если они эквивалентны?
Эквивалентны они как математические объекты: при правильном соответствии параметров пропускают одни и те же последовательности. Различие — в интуиции и в том, какой параметр вы контролируете напрямую. Token bucket думает в терминах «скорость и всплеск», leaky bucket — в терминах «интервал и допуск». Для политик вида «N в минуту, не более M за раз» удобнее первый; для «ровно один запрос каждые T» — второй. GCRA объединяет обе интуиции в одном состоянии.
Как выбрать ёмкость ведра, если сервер не публикует допустимый всплеск?
Начинайте с малой доли квоты окна — порядка пяти-десяти процентов — и наблюдайте. Если отказов нет и задержки ожидания велики, осторожно увеличивайте. Помните, что сервер со скользящим окном не терпит всплесков, превышающих квоту за короткий подынтервал, поэтому ёмкость никогда не должна приближаться к полной квоте.
Нужен ли лимитер, если у меня всего один поток?
Да. Один поток с короткими запросами легко превышает квоту: если ответ приходит за двадцать миллисекунд, вы отправите пятьдесят запросов в секунду, даже не задумываясь. Лимитер нужен независимо от числа потоков; он решает другой вопрос, чем семафор.
Как лимитировать запросы с разной стоимостью, если сервер считает их по-разному?
Передавайте cost в acquire. Жетоны списываются пропорционально, ожидание вычисляется по той же формуле. Если стоимость неизвестна, оценивайте по времени ответа или по размеру ответа и уточняйте по мере наблюдений. Лучше переоценить, чем недооценить.
Что делать, если один запрос должен пройти пять лимитеров и каждый даёт разное ожидание?
Сначала у всех спросить ожидание без списания, взять максимум, затем списать у всех на один и тот же момент прибытия. Обходить лимитеры всегда в одном порядке. Если максимум превышает порог — отказ без списания, иначе ресурсы будут зарезервированы «впустую».
Как лимитер должен реагировать на смену IP по таймеру, если я не знаю точный момент?
Используйте событие или опрос текущего адреса, а если известен интервал — расписание с запасом. В Proxeon смена по таймеру и по ссылке/API — оба режима штатные (по данным на 22.09.2026), и если вам нужна точная синхронизация, предпочтительнее режим по ссылке: тогда момент смены определяете вы и открываете новую эпоху в своём реестре ровно тогда, когда переключение подтверждено.
Почему нельзя сбросить все лимиты после смены адреса?
Потому что сервер может считать квоту по нескольким признакам сразу. Адрес сменился — квота по IP начинается заново, но квота по токену, аккаунту или сессии продолжает отсчёт. Сбросив всё, вы нарушите те политики, которые от адреса не зависят. Ротация должна затрагивать только уровень «по IP» в иерархии.
Что лучше для распределённого лимитера — token bucket или GCRA?
GCRA. У него одно значение состояния, его проще обновлять атомарно и проще хранить с TTL. Token bucket требует двух значений и чуть более сложной логики пополнения, что усложняет атомарный скрипт. Семантически оба дают одинаковый результат.
Как проверить, что лимитер работает правильно, до выхода в продакшен?
Напишите тест с подменяемыми часами: подавайте запросы в заданные моменты и сравнивайте решения с эталонной последовательностью. Проверьте граничные случаи: нулевое время, долгий простой, одновременное прибытие многих запросов, стоимость больше ёмкости (должен быть явный отказ, а не бесконечное ожидание). Отдельно протестируйте композицию: два лимитера с разными скоростями и проверка, что ни один не пропускает больше своей квоты.
Заключение: что делать дальше
Клиентский rate limit — это не тормоз, а система управления. Правильно построенный лимитер делает три вещи: не доводит до отказа, равномерно использует доступный бюджет и подсказывает планировщику, куда и когда отправлять следующий запрос. В основе — всего одна формула, будь то token bucket или GCRA, но её нужно окружить дисциплиной: монотонные часы, резервирование под блокировкой, максимальная задержка, иерархия ключей и вытеснение.
Краткое резюме:
- Fixed window прост, но коварен на границах; предпочитайте token bucket или GCRA.
- Token bucket даёт раздельный контроль скорости и всплеска; GCRA — то же в одном числе состояния.
- Ключ лимита повторяет признаки, по которым считает сервер; лимитеры выстраиваются в иерархию и композируются через peek — максимум — единое списание.
- Ротация адреса меняет только уровень «по IP»; команда ротации сама заслуживает собственного ведра.
- Метрики ожидания и отказов — единственный честный способ понять, насколько ваша политика совпадает с серверной.
Следующие шаги для вас: выберите единый движок (мы советуем GCRA), опишите политики известных хостов в конфигурации, добавьте консервативный дефолт, включите метрики и прогоните тесты с подменяемыми часами. Если работаете через пул адресов, добавьте эпоху в ключ и отдельное ведро на команду смены. После этого ваш клиент будет выглядеть для любого сервера как самый вежливый гость — тот, кому никогда не отказывают.