Очередь запросов к LLM: приоритеты, лимиты и ответ 429

очередь запросов LLM
приоритеты запросов vLLM
ответ 429 сервер инференса
Очередь запросов к LLM: приоритеты, лимиты и ответ 429

Когда запросов к локальной LLM больше, чем может обработать GPU, очередь нужно спроектировать явно: ограничить число одновременных последовательностей в движке, выбрать порядок обслуживания, разделить пользователей по справедливости и вовремя отказывать лишним запросам ответом 429 вместо бесконечного ожидания. Сам движок умеет только часть этой работы. Приоритеты между командами, квоты и отказ при перегрузке обычно живут на шлюзе перед ним.

Материал подготовила AI студия Владимира Ломтева 16 ноября 2026 года для ИТ-команд, которые держат свой сервер инференса для нескольких отделов или продуктов. Статья опирается на документацию vLLM, заметки к выпуску llm-d 1.0.0 от 20 октября 2026 года и RFC по HTTP. Собственного бенчмарка мы не проводили, все числа в примерах условные. Флаги и метрики проверяйте по документации той версии, которую запускаете.

Содержание

Почему очередь появляется даже на мощном сервере

Движок инференса обрабатывает запросы итерациями. На каждой итерации он берёт часть ожидающих запросов, выполняет для них шаг модели и возвращает по токену. Сколько запросов поместится в шаг, зависит от двух ресурсов: вычислительного бюджета итерации и свободной памяти под KV-cache. Когда приходят новые запросы, а память уже занята активными диалогами, новые ждут.

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

У очереди есть три уровня, и их полезно не смешивать:

  • внутри движка — планировщик vLLM или SGLang решает, какие последовательности попадут в следующую итерацию;
  • на шлюзе — прокси или маршрутизатор решает, пропустить ли запрос к движку сейчас, поставить в очередь или отказать;
  • в приложении — клиент решает, повторить ли запрос, показать ли пользователю ожидание и не отправить ли задачу в фоновую обработку.

Что управляет очередью внутри vLLM

В vLLM размер одной итерации ограничивают два параметра. --max-num-seqs задаёт максимум последовательностей в одном шаге, --max-num-batched-tokens — максимум токенов, которые шаг обработает, включая prefill новых запросов. Описание обоих есть в справочнике аргументов движка.

В руководстве по оптимизации vLLM сказано, что в V1 chunked prefill включён по умолчанию, когда это возможно. Планировщик сначала собирает в шаг все ожидающие decode-запросы, а потом добавляет prefill. Если длинный prompt не помещается в max_num_batched_tokens, он разбивается на части. Отсюда главный компромисс настройки:

Значение max_num_batched_tokens Что выигрывает Чем платит
Меньше, например 2048 Ровнее межтокенная задержка: prefill меньше тормозит уже идущие ответы Новые длинные запросы дольше ждут первого токена
Больше, например выше 8192 Быстрее первый токен и выше пропускная способность Активные ответы чаще замедляются из-за чужого prefill

Значения 2048 и 8192 взяты из документации как ориентиры, а не как оптимум для вашего железа. Рабочее значение подбирают нагрузочным тестом на реальной смеси запросов.

Второй механизм — вытеснение. Когда памяти KV-cache не хватает, vLLM V1 по умолчанию вытесняет часть запросов в режиме recompute: их состояние сбрасывается и пересчитывается, когда память освобождается. Документация советует при частых вытеснениях уменьшить max_num_seqs или max_num_batched_tokens, чтобы в шаге было меньше запросов и меньше требовалось кэша. Частые вытеснения значат, что очередь фактически переехала внутрь движка и тратит GPU на повторную работу.

Порядок обслуживания: FCFS или приоритеты

По умолчанию vLLM обслуживает запросы в порядке поступления (fcfs). Параметр --scheduling-policy priority включает обслуживание по приоритету. По справочнику аргументов, меньшее значение означает более раннюю обработку, а при равных приоритетах решает время прихода.

Приоритет передают в самом запросе. В описании OpenAI-совместимого сервера у chat completions и completions есть дополнительный параметр priority со значением по умолчанию 0. Любое ненулевое значение вызовет ошибку, если модель запущена без приоритетного планирования. Там же показан заголовок X-Vllm-Priority, который переопределяет значение из тела запроса.

vllm serve Qwen/Qwen3-8B \
  --host 127.0.0.1 --port 8000 \
  --api-key "$VLLM_API_KEY" \
  --scheduling-policy priority \
  --max-num-seqs 64 \
  --max-num-batched-tokens 4096

Числа 64 и 4096 здесь — стартовая точка для эксперимента, а не рекомендация. Клиент интерактивного чата может передавать приоритет через заголовок:

import os
from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key=os.environ["VLLM_API_KEY"])

def ask(question: str, interactive: bool) -> str:
    # В vLLM меньшее значение обслуживается раньше: чат получает -10, фоновые задачи 10.
    priority = "-10" if interactive else "10"
    reply = client.chat.completions.create(
        model="Qwen/Qwen3-8B",
        messages=[{"role": "user", "content": question}],
        max_tokens=400,
        extra_headers={"X-Vllm-Priority": priority},
    )
    return reply.choices[0].message.content

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

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

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

В llm-d эту задачу решает управление потоком запросов (flow control). В выпуске llm-d v1.0.0 от 20 октября 2026 года оно названо одной из главных тем: управление потоком с учётом приоритета и справедливости и контролируемый отказ при перегрузке, чтобы чувствительные к задержке запросы и всплески от агентов делили парк серверов без взаимного голодания. Как устроен механизм, описано в статье Red Hat Developer от 27 августа 2026 года:

  • у каждого запроса есть ключ потока из приоритета и идентификатора арендатора, у каждого ключа своя очередь внутри полосы приоритета;
  • приоритет задаётся ресурсом InferenceObjective; в llm-d большее число означает более высокий приоритет, отсутствующий объект даёт приоритет 0, а отрицательные значения помечают трафик, от которого можно отказаться при перегрузке;
  • полосы обслуживаются от высокой к низкой, внутри полосы арендаторы выбираются по кругу, а внутри очереди арендатора действует порядок поступления;
  • детектор насыщения объединяет давление на очередь и на KV-cache реплик и решает, когда придерживать запросы;
  • лимиты очереди и время жизни ограничивают число ожидающих запросов, их объём и время ожидания.

Обратите внимание на направление шкалы. В vLLM приоритет −10 обслуживается раньше 10, а в InferenceObjective llm-d — наоборот. Если шлюз llm-d стоит перед vLLM с приоритетным планированием, договоритесь о шкале письменно и проверьте её тестом.

Если Kubernetes и llm-d вам не нужны, справедливость можно получить проще: отдельный лимит одновременных запросов на ключ API или отдел на шлюзе вроде LiteLLM, а тяжёлые пакетные задачи отправлять в отдельную очередь с низким приоритетом. Варианты шлюзов разобраны в статье о корпоративном доступе к ИИ.

Когда отказывать: ответ 429 и Retry-After

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

Код 429 Too Many Requests определён в RFC 6585: пользователь отправил слишком много запросов за период, и ответ может содержать заголовок Retry-After. Этот заголовок по RFC 9110 указывает, через сколько секунд или к какому времени стоит повторить запрос. Код 503 обычно используют, когда сервис перегружен или недоступен целиком, а не из-за конкретного клиента.

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

import asyncio, os
import httpx
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

UPSTREAM = "http://127.0.0.1:8000/v1/chat/completions"
IN_FLIGHT = asyncio.Semaphore(48)   # сколько запросов пропускаем к движку одновременно
MAX_WAITING = 32                    # сколько можем держать в ожидании
waiting = 0
app = FastAPI()

@app.post("/v1/chat/completions")
async def proxy(request: Request):
    global waiting
    if waiting >= MAX_WAITING:
        return JSONResponse({"error": "overloaded"}, status_code=429, headers={"Retry-After": "5"})
    waiting += 1
    try:
        await asyncio.wait_for(IN_FLIGHT.acquire(), timeout=20)
    except asyncio.TimeoutError:
        return JSONResponse({"error": "queue timeout"}, status_code=429, headers={"Retry-After": "10"})
    finally:
        waiting -= 1
    try:
        async with httpx.AsyncClient(timeout=120) as client:
            upstream = await client.post(UPSTREAM, content=await request.body(),
                                         headers={"Authorization": "Bearer " + os.environ["VLLM_API_KEY"],
                                                  "Content-Type": "application/json"})
        return JSONResponse(upstream.json(), status_code=upstream.status_code)
    finally:
        IN_FLIGHT.release()

Лимит 48 стоит связать с max-num-seqs движка и результатами теста, а время ожидания — с тем, сколько пользователь готов ждать в интерфейсе. Клиент, получив 429, должен повторять запрос с паузой из Retry-After и случайной добавкой, а не сразу, иначе повторы создадут новую волну.

Какие метрики показывают, что очередь растёт

vLLM экспортирует метрики в формате Prometheus. По списку метрик для очереди важны:

Метрика Тип Что показывает
vllm:num_requests_waiting gauge Сколько запросов ждут обработки
vllm:num_requests_running gauge Сколько запросов сейчас в батче
vllm:kv_cache_usage_perc gauge Доля занятого KV-cache
vllm:num_preemptions counter Сколько раз движок вытеснял запросы
vllm:request_queue_time_seconds histogram Сколько запрос провёл в ожидании
vllm:time_to_first_token_seconds histogram Время до первого токена

Полезные выражения для Prometheus:

max_over_time(vllm:num_requests_waiting[5m])
histogram_quantile(0.95, sum by (le) (rate(vllm:request_queue_time_seconds_bucket[5m])))
rate(vllm:num_preemptions_total[5m])

Имя счётчика вытеснений в Prometheus может отображаться с суффиксом _total, проверьте его в выводе /metrics своей версии. Как собрать эти метрики в Grafana, разобрано в статье о мониторинге vLLM.

Чтение простое. Ожидающих много, а KV-cache свободен — упираетесь в max-num-seqs или вычисления. Кэш почти заполнен и растут вытеснения — упираетесь в память, и увеличение max-num-seqs сделает хуже. Время в очереди растёт только у фоновых задач — приоритеты работают как задумано.

Пошаговая настройка очереди

  1. Опишите классы трафика. Например, интерактивный чат, агентские цепочки и пакетная обработка документов. Для каждого класса запишите допустимое время до первого токена и что делать при перегрузке.
  2. Измерьте предел одной реплики. Нагрузочным тестом найдите поток запросов, при котором p95 времени в очереди начинает расти. Это рабочая ёмкость, а не паспортная.
  3. Настройте движок. Подберите max-num-seqs и max-num-batched-tokens так, чтобы вытеснения были редкими. Включите priority, если классы трафика должны обгонять друг друга.
  4. Поставьте шлюз допуска. Ограничьте одновременные запросы и длину ожидания, отдавайте 429 с Retry-After, разделите лимиты по ключам или отделам.
  5. Уведите пакетные задачи из интерактивного потока. Ночные выгрузки и массовую разметку лучше запускать отдельной очередью с низким приоритетом или на отдельной реплике.
  6. Проверьте поведение клиентов. Повторы должны соблюдать Retry-After, а интерфейс — показывать ожидание или предлагать отложенный ответ.
  7. Повторите тест с перегрузкой. Подайте поток выше ёмкости и убедитесь, что интерактивные запросы укладываются в цель, а лишние получают быстрый отказ.

Частые ошибки

  • Увеличить max-num-seqs, чтобы очередь исчезла. Если упираетесь в память, это даст больше вытеснений и повторных вычислений.
  • Оставить очередь без лимита. Запросы ждут дольше, чем живёт соединение у клиента, и GPU обслуживает ушедших пользователей.
  • Перепутать шкалы приоритетов между движком и шлюзом.
  • Мерить только среднюю задержку. Очередь видна в p95 и p99 времени ожидания, а среднее её прячет.
  • Повторять 429 без паузы. Клиенты сами создают пик, от которого шлюз их защищал.

Частые вопросы

Есть ли в vLLM ограничение длины очереди? В описаниях параметров, на которые мы опирались, ограничения длины очереди с автоматическим ответом 429 нет: движок принимает запросы и держит их в ожидании. Лимит и отказ надёжнее делать на шлюзе.

Что лучше: приоритет в движке или отдельная реплика для фоновых задач? Приоритет проще и не требует второго GPU, но фоновые задачи всё равно делят память KV-cache с интерактивными. Отдельная реплика изолирует их полностью и стоит оборудования.

Нужен ли llm-d, чтобы получить справедливость между отделами? Нет. Для одного-двух серверов хватит лимитов на ключ API в шлюзе. Llm-d оправдан, когда реплик много и они работают в Kubernetes.

Почему после включения chunked prefill время первого токена выросло? Если max_num_batched_tokens мал, длинный prompt проходит prefill несколькими частями между decode-шагами других запросов. Это осознанный обмен: ответы, которые уже идут, текут ровнее.

Как AI студия Владимира Ломтева помогает настроить очередь запросов

AI студия Владимира Ломтева разворачивает LLM на серверах компании и сопровождает их в эксплуатации. Для очереди запросов это означает:

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

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

Итог: очередь должна быть ограничена и видна

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

Оставить заявку

Заполните форму и мы свяжемся с вами

← Все статьи

Комментарии (0)

Пока нет комментариев. Будьте первым!

Оставить комментарий
Регистрация не требуется