Reject uploads with 429 at [uploads] max_unfinished_jobs, counted by the existing partial indexes in the membership block. Add the bench_queue profile, hypotheses H1-H9 and the fifth failure-stand API. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
85 KiB
Design
Context
Мотивация — proposal.md, раздел Why. Требования — specs/. Контракт — contracts/README.md («Формат и ошибки», «Фоновая обработка»), contracts/openapi.json (у загрузки уже есть 429 с Retry-After), рубрика — README.md, «Трек 1», правила измерений — COURSE.md и .claude/rules/bench.md. Основа — design архива 2026-10-31-pipeline-reliability, решение 8 (что мерить и откуда), и 2026-11-01-unit-of-work (порты, блоки).
Код
Состояние — 5a97416:
AttachmentService.upload: блок с членством; затем без БД 415 и 413; затем место загрузки и_store. Предела принятой работы нет: 429 — только от мест (4 + 16 на реплику);src/worker/main.py:set_qos(prefetch), задача на доставку,asyncio.Semaphore(concurrency)вокругservice.handle; по умолчанию 2 и 2; процесс обработки на задание; пул PostgreSQL 2;AttachmentRelayService:room = max_published_backlog − count_published()(1000), «потерянные» — есть отмеченные старше 300 с и ноль готовых;- частичные индексы
attachment_jobs:ix_attachment_jobs_outbox,ix_attachment_jobs_published,ix_attachment_jobs_lease— покрывают всё незавершённое; bench/:Stand.start_broker, лимитыBENCH_BROKER_*,BENCH_RELAY_*,BENCH_WORKER_*описаны и не используются; сэмплер — режимыlist,scan,peak; профильuploadsидёт без worker, и задания копятся.
Пробы (2026-11-01, scratchpad track1/, проект compose q1probe, образ git archive 5a97416)
Это пробы, а не результат: один прогон на точку, часть — при соседней пробе; они нужны, чтобы выбрать методику, значения и пороги. Условия: arm64, Docker 29.9.2, ВМ 12 CPU / 7,75 ГиБ, рядом простаивали рабочий стенд и domains-*. Лимиты — рабочего стенда, worker 1 CPU / 1 ГБ без swap. Секреты — синтетические, .env и config.toml не подключались. Что осталось после проб — раздел «Migration Plan».
Кандидаты классов. Файлы — Pillow образа, от зерна; процесс обработки — те же аргументы, что у ImageRenderer, 1 CPU, по одному, медиана пяти:
| Файл | Млн пикс. | MiB | Стена / CPU, мс | VmHWM, МиБ | WebP, КиБ |
|---|---|---|---|---|---|
| JPEG 640 × 480, q85 | 0,31 | 0,10 | 208 / 200 | 31 | 82 |
s: JPEG 1600 × 1200, q85 |
1,92 | 0,48 | 299 / 290 | 49 | 200 |
| PNG 1600 × 1200 | 1,92 | 3,77 | 342 / 330 | 53 | 221 |
m: PNG RGB из шума 1024 × 3409 |
3,49 | 9,99 | 269 / 260 | 57 | 191 |
lj: JPEG 8000 × 5000, q88 |
40 | 8,60 | 365 / 350 | 57 | 158 |
| JPEG прогрессивный, те же пиксели | 40 | 7,64 | 515 / 500 | 155 | 158 |
| PNG RGB 8000 × 5000, 4 значащих бита | 40 | 8,52 | 655 / 630 | 213 | 160 |
lp: PNG RGBA 8000 × 5000, 4 значащих бита |
40 | 9,97 | 1025 / 1010 | 367 | 479 |
Запуск процесса — около половины CPU малого файла: ~100 мс из 200 (проба pipeline-reliability: 90 мс на импорт Pillow и плагинов). Память решает формат, а не пиксели: 40 Мпкс — 57 МиБ у JPEG с draft и 367 МиБ у PNG RGBA.
Потолок worker. Загрузки при остановленном worker, затем запуск, готовых в секунду по finished_at, 25–120 заданий:
| Класс | (1, 1) | (2, 2) | (4, 4) | (8, 8) | Другие |
|---|---|---|---|---|---|
| 0,3 Мпкс | 4,33/с, 118 МиБ | 4,30, 142 | 3,41, 178 | 3,32, 253 | (2, 64): 4,03, 171 |
s |
2,78, 147 | 2,96, 176 | 2,58, 283 | — | — |
m |
2,48, 197 | 2,93, 261 | 2,63, 347 | 2,73, 591 | (2, 3): 2,39; (2, 8): 2,79 |
lj |
1,91, 198 | 2,37, 249 | 2,13, 357 | 1,88, 494 | — |
| JPEG прогрессивный | — | 1,48, 401 | 1,57, 695 | — | — |
lp |
0,81, 484 | 0,92, 842 | 0,89, OOM ×10 | — | (3, 3): 0,81, OOM ×4; (2, 64): 0,84, 845 |
memory.peak — на весь прогон. У lp при (3, 3) и (4, 4) ядро убивало процессы обработки, задания возвращались render_killed и все дошли до ready с попытками 29 и 35 на 25 заданий. CPU worker — 1 ядро на всём прогоне, кроме (1, 1), где часть времени ждут S3 и PostgreSQL: потолок при 1 CPU — CPU, и конкуренция сверх двух его не поднимает, а удлиняет процесс (render_ms p50 на 0,3 Мпкс: 213 → 424 → 1107 → 2108 мс). Цена задания: 0,24 с CPU на 0,3 Мпкс, 0,35 на s и m, 0,45 на lj, 1,13 на lp.
Открытая модель, настройка по умолчанию. До окна — 15 с ниже потолка, окно перегрузки — 25 с, затем спад до нуля; контрольный поток 10 + 10 + 10 запросов в секунду:
| Класс | λ, /с | Принято | Загрузка p50 / p95, мс | Готовых/с в окне | Пик незаверш. | Восстановление, с | До ready p50 / p95, с |
Контроль p95: запись / чтение / скачивание, мс | CPU worker / S3 |
|---|---|---|---|---|---|---|---|---|---|
s |
8 | 223, все 202 | 13 / 19 | 2,9 | 126 | 45,8 | 22 / 44 | 8 / 7 / 9 | 1,03 / 0,09 |
m |
6 | 174, все 202 | 141 / 279 | 2,7 | 85 | 30,2 | 16 / 29 | 46 / 12 / 85 | 0,98 / 0,95 |
lj |
6 | 169, все 202 | 112 / 197 | 2,2 | 98 | 43,9 | 23 / 42 | 57 / 11 / 43 | 1,02 / 0,68 |
lp |
2,5 | 71, все 202 | 393 / 601 | 0,83 | 43 | 46,3 | 25 / 45 | 24 / 12 / 29 | 0,99 / 0,32 |
s, (8, 8) |
8 | 224, все 202 | 15 / 25 | 2,0 | 156 | 76,7 | 41 / 75 | 17 / 14 / 18 | 0,98 / 0,13 |
CPU — снимок docker stats. Очередь и задержка согласуются с простой моделью: p95 до ready ≈ пик незавершённых / throughput окна (отношение 0,86–1,01), восстановление — столько же (0,89–1,05); throughput в окне и при восстановлении один и тот же (провала нет). На m при 6/с S3 уже близко к своему 1 CPU (0,83–0,95): дальше упирается приём, а не worker. outbox держится на 0–2: relay не узкое место; rabbitmq в снимках занят только нашими вызовами rabbitmqctl.
Повтор на свежем стенде, окно 20 с, как в матрице. До окна 10 с низкой λ; после разбора — окно той же низкой λ:
| Класс, настройка | λ, /с | Принято | Загрузка p50 / p95, мс | Пик незаверш. | Восстановление, с | До ready в окне p50 / p95, с |
p95 до окна / после, с | Контроль скачивания p95, мс | Пик worker, МиБ |
|---|---|---|---|---|---|---|---|---|---|
s, (2, 2) |
8 | 176 | 13 / 19 | 99 | 32,9 | 17 / 31 | 0,62 / 0,58 | 7,5 | 174 |
m, (2, 2) |
6 | 137 | 113 / 223 | 65 | 23,9 | 12 / 22 | 1,13 / 0,88 | 70 | 211 |
lp, (2, 2) |
2,5 | 57 | 368 / 581 | 34 | 36,3 | 20 / 35 | 1,37 / 1,37 | 18 | 836 |
s, (2, 256), старый стенд |
8 | 177 | 14 / 22 | 106 | 35,8 | 19 / 34 | 0,59 / — | 12,5 | 175 |
Время до ready после разбора вернулось: отношение p95 — 0,78–1,00. У (2, 256) брокер всё окно показывает готовых 0 и неподтверждённых до 98; у (2, 2) готовых 91–163 при пике 99–170.
Память: lp, (4, 4), те же окна, 2,5/с. Прогон — свежий стенд, кроме последнего:
| Прогон | Завершений ядром | Заданий с повторной попыткой | Итог |
|---|---|---|---|
| 1 | 20 процессов обработки | 20 | все ready, разбор ~60 с |
| 2 | 44 | 26 | все ready, ~78 с |
| 3 | 0, memory.peak 1024 МиБ |
0 | все ready, ~42 с |
| 4 | 3 и процесс 1 worker | — | контейнер exit 137, OOMKilled на 20-й секунде |
| 5, старый стенд | не снято: контейнер пересоздан раньше разбора | — | те же признаки: контейнера нет на 24-й секунде, потребителей 0, через аренду 51 задание queued, ничего не потеряно |
Журнал ядра прогона 4: за 1,2 мс убиты три процесса обработки (356, 233, 202 МиБ анонимной памяти) и следом процесс 1 (135 МиБ, тот же oom_score_adj 0): память ещё не вернулась, а других кандидатов уже нет. Значит, oom_score_adj у процесса обработки его не защитит: защита — конкуренция, которая помещается в лимит. На рабочем стенде worker вернётся сам (restart: unless-stopped), в bench/ стоит restart: "no", и ячейка зависла бы (решение 10).
Граница приёма: m, (2, 2), λ выше того, что принимают реплики и S3. Свежий стенд; CPU — снимок docker stats:
| λ, /с, окно | Ответы | Загрузка 202 p50 / p95, мс | Принято/с в окне | Готовых/с в окне | Пик незаверш. | Восстановление, с | До ready p95, с |
Контроль p95: запись / чтение / скачивание, мс | CPU S3 / worker |
|---|---|---|---|---|---|---|---|---|---|
| 6, 20 с | 137 — 202 | 113 / 223 | 6,1 | 2,9 | 65 | 23,9 | 22 | 17 / 11 / 70 | 0,83 / 0,98 |
| 12, 20 с | 203 — 202, 20 — 429 | 3 320 / 5 333 | 9,4 | 0,56 | 170 | 59,9 | 58 | 31 / 22 / 384 | 0,97 / 0,07 |
| 15, 20 с | 207 — 202, 76 — 429 | 3 768 / 5 641 | 9,6 | 0,62 | 175 | 62,3 | 60 | 28 / 10 / 332 | 1,02 / 0,30 |
| 15, 40 с, предел 250 | 323 — 202, 202 — 429 busy, 57 — 429 backlog |
4 804 / 5 872 | 7,7 | 0,57 | 284 | 100,5 | 95 | 20 / 17 / 341 | 0,97 / 0,63 |
5xx нет. Выше ~8–9,6 загрузок 10 MiB в секунду упирается CPU шлюза S3; места держат ответ 3–6 с и отказывают лишним (первый busy — на ~10-й секунде перегрузки), предел приходит на ~35-й, а превышение — 34 из 40 возможных загрузок в полёте. S3 — общий ресурс приёма и worker: пока приём занимает его, готовых/с падает с 2,9 до ~0,6 (worker ждёт S3, а не CPU), сразу после окна — снова 2,87/с. k6 с телом 10 MiB — до 2,1 ГиБ при 80 VU; VU, создаваемые на ходу, теряют итерации (33–36 недосланных).
Старый стенд: S3 убит ядром. Один и тот же стенд ~80 мин принимал пробы (~9 200 заданий, volume не пересоздавался); S3 у него держал 330–415 МиБ при лимите 512 и GOMEMLIMIT 400 МиБ. При 12/с на m — exit 137, OOMKilled, 9 ответов 503 на загрузке; без него все 229 незавершённых заданий за ~85 с исчерпали бюджет: failed, retry_exhausted, storage_unavailable, возврат — make replay. Те же 12 и 15/с на свежем стенде: oom_kill 0, 322–399 МиБ (memory.peak 515 МиБ — с учётом страничного кэша). На рабочем стенде S3 вернулся бы сам, ячейки метки — на свежих volume; запись — KNOWN_ISSUES.md.
Цена проверки предела. Схема стенда, 300 000 завершённых заданий, свой контейнер PostgreSQL 2 CPU / 1 ГБ, pgbench -M prepared, один клиент, задержка на запрос:
| Незавершённых | state IN (…) без индекса: Parallel Seq Scan |
Сумма трёх Index Only Scan | Сумма с LIMIT 1001 на группу |
|---|---|---|---|
| ~0 | 10,8 мс | 0,045 мс | 0,047 мс |
| 1 000 | 10,6 | 0,081 | 0,092 |
| 5 000 | 11,4 | 0,233 | 0,135 |
| 25 000 | 11,7 | 0,959 | 0,129 |
| 125 000 | 15,9 | 4,876 | 0,130 |
Новый частичный индекс (id) WHERE state IN ('queued','processing'): 4,8 МБ на 125 000 строк, полный счёт 5,3 мс, с LIMIT — 0,084 мс: выигрыша перед тремя существующими нет, а цена записи есть. Под оборотом 100 заданий в секунду (четыре транзакции жизни задания, в ~30 раз больше потолка, autovacuum по умолчанию, 26 000 мёртвых строк за 90 с, 1 020 незавершённых): 0,65–1,05 мс без роста; Heap Fetches — все незавершённые, карта видимости на живых страницах бесполезна, потому и граница по LIMIT. Счётчик одной строкой в транзакциях приёма и итога: читать 0,033 мс, но потолок оборота при 2 / 4 / 8 клиентах падает с 2003 / 2879 / 2567 до 1347 / 2055 / 1311 циклов задания в секунду (−29…−49 %, в другом прогоне −16…−24 %), задержка цикла +40…+96 %.
Прототип предела на копии кода (образ q1probe-gate, решение 3 как есть; план — три Index Only Scan по трём индексам, 0,22 мс, у _lease Heap Fetches 173 на 2 живые строки до VACUUM). s, (2, 2), 1,5/с 10 с, затем 20/с 30 с:
| Предел | Принято / 429 | Загрузка 202 p50 / p95, мс | Пик незаверш. | Восстановление, с | До ready p50 / p95, с |
Контроль p95: запись / чтение / скачивание, мс |
|---|---|---|---|---|---|---|
| 250 | 349 / 265 | 14 / 161 | 250, плато до конца окна | 84,3 | 50 / 85 | 8,7 / 7,8 / 10,4 |
| 0 | 615 / 0 | 14 / 41 | 513, рост до конца окна | 173,2 | 87 / 165 | 9,0 / 7,5 / 10,4 |
При пределе p95 до ready ровно предел / потолок (250 / 2,95 = 85 с). Превышения на этой интенсивности нет: загрузка s короче интервала между счётами. Хвост 161 мс — один прогон, причина не разбиралась; в опыте ниже его нет.
Цена проверки на загрузку и отказа. Свежий стенд, 25 загрузок/с, тело 0,1 MiB (доля проверки наибольшая), worker, relay и уборщик остановлены, четыре круга по 16 с, реплики пересоздаются на каждое плечо; CPU — разность cpu.stat на запрос, медианы кругов:
| Загрузка p50 / p95 / p99, мс | CPU реплик, мс | CPU PostgreSQL, мс | |
|---|---|---|---|
| Без проверки (предел 0) | 9,87 / 11,7 / 13,0 | 6,38 | 1,09 |
| С проверкой (предел 100 000: отказов нет, счёт до 4 400 строк) | 10,78 / 13,0 / 16,4 | 7,21 | 1,47 |
| Отказ у предела, 4 клиента без пауз, ~980 отказов/с | 3,7 / 4,7 / 5,7 | 1,89 | 0,27 |
| Отказ у предела, 16 клиентов, ~1 000 отказов/с | 14,5 / 27 / 58 | 1,90 | 0,32 |
Проверка — +0,9 мс p50, +0,8 мс CPU реплики, +0,4 мс CPU PostgreSQL на загрузку; это оценка сверху: значение по умолчанию обрывает счёт на 250 строках на группу, а у файлов больше доля ещё меньше. Отказ втрое дешевле загрузки, пределы 5 и 250 при бэклоге 4 400 по цене неотличимы, потолок — CPU реплик.
Брокер. Контейнер образа и лимитов стенда, предел памяти 400 МиБ, очередь без потребителя, сообщение 243 байта:
| Что | Результат |
|---|---|
| Память на готовое сообщение | 1 000 / 50 000 / 200 000 сообщений: cgroup 173 / 180 / 257 МиБ, анонимная ~106 МиБ, память очереди 110–430 КиБ: классическая очередь держит в памяти ~1 000 сообщений, остальное на диске. До предела памяти лимитом max_published_backlog и пределом заданий не дойти |
| Неподтверждённые | prefetch 1 000 / 10 000: память очереди 1,1 / 11,5 МиБ: ~1,1 КиБ на сообщение, выдача за миллисекунды |
| Цена цикла выдача — ack, 20 000 сообщений | prefetch 1 — 5 836/с, 2 — 8 637/с, 8 — 16 147/с, 64 — 17 362/с: 0,17 мс против сотен мс задания: prefetch сверх конкуренции throughput на этих заданиях поднять нечем |
Сработавший предел памяти (set_vm_memory_high_watermark) |
публикация без подтверждения за 4 с, закрытие соединения издателя — по сроку; потребитель на своём соединении подтверждает 100 сообщений за 0,01 с |
consumer_timeout |
30 мин: сообщение, выданное worker и не подтверждённое дольше, закрывает канал. Значит, prefetch / потолок должен быть меньше 30 мин |
rabbitmqctl list_queues |
0,54 с, 0,52 с CPU в cgroup брокера на вызов: опрашивать им — портить CPU брокера в замере |
Плагин rabbitmq_prometheus из файла enabled_plugins при старте, collect_statistics_interval = 1000 |
старт как без него, значения свежие за ~1 с; /metrics/detailed?vhost=%2F&family=queue_coarse_metrics — 2,4 КБ, 4,7 мс CPU на опрос; простой 0,0044 ядра, с опросом раз в секунду 0,0056; полный /metrics — 224 КБ, 33 мс. Чтение из bash образа PostgreSQL (/dev/tcp, HTTP/1.0, контейнер сэмплера): ready=1234 unacked=0 при тех же значениях rabbitmqctl list_queues |
Большой prefetch (s, 150 заданий накоплено при остановленном worker):
| Опыт | (2, 2) | (2, 256) |
|---|---|---|
| Очередь через 10 с после запуска | готовых 120, неподтверждённых 2 | готовых 0, неподтверждённых 122 |
| Второй worker через 10 с | 5,36/с, задания 92 + 58, всего 34,1 с | 2,94/с, задания 150 + 0, всего 53,0 с |
| Порог потерянного 15 с вместо 300 с | копий 0 | копий 188 на 150 заданий: готовых ноль, а сообщения старше порога; все — Skipped job message finished, лишний эффект 0, время то же (51,8 с) |
Рестарты посреди перегрузки (s, 8/с, 30 с, 255–257 принятых): KILL worker и запуск — все ready, две попытки у 2 заданий, восстановление 59,1 с (без рестарта по модели ~56), контроль p95 ≤ 10 мс; docker restart брокера — все ready, попыток сверх одной нет, 56,7 с; KILL брокера и запуск — то же, 56,6 с; загрузки — все 202.
Шум и цена стенда. Три повтора drain при (2, 2) подряд: s (90 заданий) 3,02 / 3,05 / 3,02 готовых/с, пик 174 МиБ; m (60) 2,95 / 2,89 / 2,72, 209–215 МиБ; lp (30) 0,97 / 0,95 / 0,97, 831–838 МиБ: разброс throughput 1–8 %, памяти до 3 %. Свежий стенд: PostgreSQL и Valkey 1,9 с, миграции 2,5, брокер 3,7, S3 7,7, bootstrap 4,6, реплики, LB, relay, уборщик 0,7, готовность 1,2, пользователь и чат 0,9 — 20,5–25 с по шести запускам.
Что найдено до решений
- Узкое место при 1 CPU — сам CPU worker, а не брокер, relay, PostgreSQL или prefetch. Поэтому сравнение настроек при том же лимите покажет не рост, а цену: выше двух — та же скорость, вдвое больше памяти, вдвое дольше обработка задания. Настоящее ускорение — второй worker.
- Границу памяти задаёт формат: конкуренция 3 уже не помещается в 1 ГБ на PNG RGBA 40 Мпкс и свободно помещается на JPEG тех же пикселей. Отсюда четыре класса, а не три.
- Брокер не копит и не сдерживает: 200 000 сообщений — 106 МиБ анонимной памяти. Предел памяти брокера в этой системе — защита от чужого, а не сдерживание работы: без отдельного предела на входе бэклог упрётся только в диск.
- Большой prefetch не вреден для одного worker и вреден для всего остального: очередь выглядит пустой, второй worker простаивает, появляются копии «потерянных». Это видно только особыми опытами, а не по throughput одного worker.
- Метрики очереди нельзя снимать
rabbitmqctl: 0,5 с CPU на вызов в cgroup брокера. - Профиль
uploadsиtest_reconcile_under_loadкопят задания: первый без worker, второй 16 загрузок в секунду при потолке ~4/с. С пределом по умолчанию они мерили бы предел; это решение 13. - У файлов на границе байтов первым упирается S3, и он общий: выше ~8–9,6 загрузок/с клиент видит 429 от мест и ответ 3–6 с, а worker в это же время падает с 2,9 до ~0,6 готовых/с. Значит, «перестаёт ускоряться» — не только CPU worker: приём может отнять у обработки её ресурс, и предел заданий — единственное, что это останавливает.
- Нехватка памяти контейнера опаснее, чем выглядит: ядро убивает процессы обработки сериями и доходит до процесса 1 worker (подтверждено журналом ядра в одном прогоне из пяти, ещё в одном — те же признаки). Настройка, которая не помещается в лимит, — это не только повторы, но и остановка всего worker до перезапуска и ожидание аренды.
- Короткая ячейка на свежем стенде не видит рост памяти S3 с накопленными объектами: случай на старом стенде метка не воспроизведёт; ограничение названо (решение 12).
Goals / Non-Goals
Goals:
- Весь трек 1: ≥3 настройки на нескольких классах, throughput, очередь, p95 до
ready, RSS, backpressure, ограничение принятой работы, восстановление, компромисс latency и ресурсов — с гипотезами до меток и повторяемой командой. - Предел принятой работы без новой схемы и без лишнего шага с PostgreSQL.
- Прежние механизмы не меняются: места загрузки, цепочка сроков LB, outbox, аренда, fencing, сверка,
rolling_update.
Non-Goals (сознательно, сверх proposal.md):
- смена значений
concurrency,prefetchи лимитов контейнера заранее: решение после метки по правилу решения 12; - ограничение по байтам и пикселям, предел на чат или пользователя (решение 1);
- замена процесса на задание forkserver: цена запуска названа пробой и меткой, замена — отдельное изменение;
- новая схема, новые индексы, новые значения
error_code.
Decisions
1. Граница принятой работы — предел незавершённых заданий, 429
Что считается: задания queued и processing — в том числе ожидающие следующей попытки и ещё не опубликованные. Именно эта работа уже обещана клиенту ответом 202, занимает staging и ждёт worker. pending не считается: его ответа ещё нет, он ограничен местами. failed и succeeded не считаются: работа кончилась, у failed staging держит срок хранения.
Что видит клиент: 429 rate_limited, формат ошибки, Retry-After, сразу, без чтения тела и ожидания места. Ни строки, ни объекта. Это та же форма, что у занятых мест: клиент обязан уметь её и так. Повтор — новая загрузка: Idempotency-Key не нужен, отклонённая ничего не сохранила.
Контракт. contracts/openapi.json: у uploadAttachment объявлены 429 с заголовком Retry-After — положительное целое, и 503 «Зависимость недоступна». contracts/README.md: «429 rate_limited», «Факультативный … rate limiting» не становится обязательным, но допустим. Рубрика трека прямо требует ограничения принятой работы. Противоречие одно, мягкое: 429 описан как «ограничение частоты запросов», а здесь ограничено количество работы; и уровень 3 говорит о 202 при остановленном worker. Строгая трактовка, которая проходит публичные тесты: у предела — 429, ниже него — 202 при любом состоянии брокера, relay и worker. make test и tests/resilience.py загружают единицы файлов. Вопросы преподавателю — QUESTIONS.md. Другой ответ меняет строку DOMAIN_ERRORS и сценарии.
Почему не 503: зависимость жива, реплика готова, LB и монитор не должны видеть отказ; 503 смешал бы перегрузку с падением S3.
| Вариант | Почему нет |
|---|---|
| Нет предела, копить до диска | рубрика; срок ожидания растёт без границы, рекомендовать нечего: проба 8/с против 3/с — +5 заданий в секунду, за час 18 000 заданий и 1,7 часа разбора |
| Возраст старейшего незавершённого | остановка worker дольше порога закрыла бы приём целиком: сценарий защиты «worker остановлен → 202» стал бы зависеть от часов; число принятого предсказуемо и объяснимо |
| Байты или пиксели в работе | точнее по ресурсам: lp стоит втрое дороже s при том же счёте. Но нужен SUM по строкам с чтением heap на каждую загрузку вместо счёта по индексу, а пикселей в строке нет; вместо этого предел выбран по худшему классу (решение 2), ограничение названо |
| Предел на чат или пользователя | справедливость, а не ограничение работы: нет индекса владельца у задания, новая схема; вне трека, ограничение названо |
| Ждать снижения счёта вместо отказа | работа уходит за секунды и минуты, держать соединение и место нельзя; для этого уже есть короткая очередь мест |
Проверять после тела, перед pending |
клиент передаёт 10 MiB ради отказа; реплика читает и считает SHA-256 зря |
Жёсткий предел в транзакции queued |
счёт под блокировкой на каждую фиксацию и компенсация записанного объекта ради точности ±40 из 250 |
2. Значения: предел 250, Retry-After 5
Предел 250. Цель — ограничить срок, а не только число: ожидание при заполненном пределе = предел / потолок. Самый дорогой законный класс — lp, 0,92/с: 250 — это ~270 с. Сверху его ограничивает [relay] republish_after_seconds (300 с): ожидание в очереди короче порога потерянного сообщения, и копий не будет и при prefetch больше конкуренции. На остальных классах — 85–110 с. Объём staging при заполненном пределе — не больше 250 × 10 MiB ≈ 2,4 ГиБ плюс превышение. Значение — настройка [uploads] max_unfinished_jobs (ge=0, 0 — без предела): при другом числе worker предел другой, правило пересчёта — в REPORT.md. Правило и порог проверяет метка: гипотезы H4 и H5. Предел меньше max_published_backlog (1000): при значениях по умолчанию очередь брокера вмещает весь бэклог, а max_published_backlog остаётся страховкой на случай большего предела; менять его поводов нет (пробы: сообщение стоит брокеру меньше килобайта).
Retry-After 5 — константа UPLOAD_BACKLOG_RETRY_AFTER_SECONDS в src/utils/constants.py, рядом с UPLOAD_RETRY_AFTER_SECONDS (1 с): настройкой не заводится, между установками не различается. За 5 с worker завершает 4–15 заданий, повтор через секунду почти всегда получил бы тот же 429, а простоя не будет: при заполненном пределе работы на десятки секунд. Ровный повтор без случайной добавки — ограничение клиента, в ответе контракт добавки не предусматривает.
3. Проверка в коде
- Порт и SQL:
AbstractAttachmentJobRepository.count_unfinished(*, limit: int) -> int: сумма трёх подзапросов «первыеlimitстрок группы» по существующим частичным индексам, состояния —literal(..., literal_execute=True), как у соседних выборок, иначе общий план — Seq Scan. Докстринг порта: «сумма не меньшеlimitтогда и только тогда, когда незавершённых не меньшеlimit»: счёт на группу обрывается на пределе, и цена не растёт с превышением. Одинexecute— правилоrepo-layer.md. Фейкservice-tests/fakes/repos.py, строкаservice-tests/repo_contract.py, строкаtest_status_is_a_constant_in_statement. Миграции и нового индекса нет. - Сервис:
AttachmentService.uploadв том же первом блоке единицы работы:require_member→ 415 → 413 →count_unfinished. Проверки типа и размера переезжают внутрь блока: без соединения они не берут ничего (выдача ленивая, при попадании в кэш — ноль обменов), а блок на загрузке остаётся один. Поэтому молчание реплики до тела прежнее (2 × request_timeout_seconds + wait_timeout_seconds= 17 с <timeout server30 с), цепочка LB и граница B уборщика не меняются. Приmax_unfinished_jobs == 0запроса нет. - Исключение:
UploadBacklogFull(src/core/exceptions/attachment.py), строка вDOMAIN_ERRORS(429rate_limited) иRETRY_AFTER(errors.py), сообщение «Too many attachments are waiting for processing, retry later». - Журнал:
info«Rejected attachment» сreason=backlog,unfinished,limit, как у прочих отказов; «Started API» —uploads_max_unfinished_jobs. Метка сверяет число 429 с числом таких записей. - Что со временем отказа: отказ не занимает места, поэтому посторонний поток 429 не вытесняет живые загрузки, а ожидающая в очереди мест загрузка не считается заново.
Превышение предела — только в полёте: загрузка прошла счёт, ждёт место до 5 с и идёт до 30 с тела. На стенде 2 × (4 + 16) = 40, при замене реплик 60. Жёсткой границы нет намеренно (решение 1).
Смесь версий: прежние реплики предел не считают; новая схема не нужна. Новый образ с прежним уборщиком и worker совместим.
4. Цепочка сдерживания
| Уровень | Что ограничивает | Значение | Что видит клиент | Где видно |
|---|---|---|---|---|
| Места загрузки реплики | память приёма, одновременные загрузки | 4 + 16, ожидание 5 с | 429, Retry-After: 1 |
журнал busy, k6 |
| Предел заданий (новое) | принятая работа, срок ожидания, staging | 250 | 429, Retry-After: 5, сразу |
журнал backlog, k6, счёт незавершённых |
Шлюз S3, 1 CPU, concurrentUploadLimitMB 64 — общий с worker |
запись байтов приёма и обработки | 1 CPU, 64 МБ | загрузка дольше, до 3–6 с на m; за сроком вызова — 503; готовых/с падает |
CPU S3, p95 загрузки, готовых/с в окне |
| Outbox | ничего: копит намерения | — | queued |
outbox, возраст |
max_published_backlog |
очередь брокера | 1000 | queued |
published, «Relay backlog is full» |
| Предел памяти брокера | издатель получает отказ по сроку | 400 МиБ | queued |
журнал relay; пробы: нагрузкой не достигается |
prefetch |
выдача worker | 2 | queued |
messages_unacknowledged |
concurrency |
работа в процессе | 2 | processing |
processing, CPU |
| Лимиты процесса и контейнера | память и CPU на задание | 450 МиБ, 15 с CPU, 1 ГБ | дольше до ready; failed при исчерпании |
oom_kill, render_killed, failed |
Работа перестаёт приниматься на первых двух уровнях, перестаёт ускоряться — на CPU worker (concurrency сверх двух при 1 CPU) и, для тел у границы байтов, на CPU S3, причём там приём отнимает ресурс у обработки: предел заданий ограничивает и это. За входом клиент видит только дольше неизменный queued. Метка показывает это по уровням: ячейки матрицы — от outbox до concurrency, блок «приём» — S3, места и затем предел, блок «предел» — новый уровень отдельно. Предел памяти брокера и max_published_backlog при значениях по умолчанию нагрузкой не достигаются (пробы, решение 2): их работу доказывают прежние test_broker_memory_alarm и test_published_backlog_limit.
5. Настройки и классы
Настройки (concurrency, prefetch): (1, 1) — меньше памяти, простаивает на S3 и PostgreSQL; (2, 2) — значения по умолчанию; (4, 4) — больше конкуренции, чем CPU, и на lp больше памяти, чем лимит; (2, 256) — большой prefetch. Значение 256 больше любого бэклога ячейки: очередь брокера целиком уходит в один worker.
Классы — bench/make_images.py в контейнере на образе стенда (--network none, Pillow образа, зерно Profile.queue_image_seed = 20261101, файлы проб), файлы — в .work/, размеры и SHA-256 — в паспорте, больше лимита контракта — отказ до стенда:
| Класс | Файл | Зачем | λ низкая / высокая, /с |
|---|---|---|---|
s |
JPEG 1600 × 1200, q85 | мало пикселей: цена процесса и декодирования | 1,5 / 8 |
m |
PNG RGB из шума 1024 × 3409, IDAT zlib уровня 1, как тело 10 MiB профиля uploads |
граница байтов: ввод-вывод, S3, SHA-256 | 1,5 / 6 |
lj |
JPEG 8000 × 5000, q88 | граница пикселей с draft: мало памяти |
1,2 / 6 |
lp |
PNG RGBA 8000 × 5000, значащие 4 бита на канал, плавная альфа | обе границы: больше всего памяти и CPU | 0,5 / 2,5 |
Построение, как на пробе: канал — Image.frombytes("L", …, random.Random(зерно).randbytes(…)) низкого разрешения, растянутый BICUBIC (64 ячейки по ширине), плюс такое же поле 512 ячеек, поделённое на 6, плюс плитка шума 512 × 512 амплитуды A, повторённая на всё поле (ImageChops.add); зёрна каналов — зерно + номер, + 10 + номер, + 20 + номер. s: зерно, A = 24, subsampling="4:2:0". lj: зерно + 200, A = 24. lp: зерно + 200, без плитки, point(v & 0xF0) на каналах; альфа — поле 64 ячеек зерна + 300, 128 + v // 2, тоже 4 бита; compress_level=6. m: uploads.png_noise(3409, зерно + 3409).
Ни один файл не тривиален для декодера: lp — настоящий inflate и Lanczos на 160 МБ пикселей и WebP с альфой 479 КиБ, lj — настоящий IDCT, m — масштабирование шума. Низкая λ — половина потолка настройки по умолчанию, высокая — 2–2,7 потолка, не выше того, что принимают реплики и S3. Одна и та же λ для всех настроек класса: сравниваются настройки при равной нагрузке.
Ячейки матрицы — 12 конфигураций: (2, 2) и (4, 4) на всех четырёх классах; (1, 1) на m и lp (на классах с заметным вводом-выводом и большей памятью; s проба показала рядом с (2, 2)); (2, 256) на s и lp (самый короткий и самый длинный процесс). Вместе с блоками решения 8 — 19 конфигураций × 3 повтора = 57 ячеек, круги: на круге — перестановка всех конфигураций от зерна Profile.order_seed, первая ячейка круга не равна последней прошлого (overload.plan_cells, как scaling.plan_cells). Модуль называется bench/overload.py, а не queue.py: каталог скрипта стоит первым в sys.path, и queue.py затенил бы модуль stdlib, который импортируют concurrent.futures и logging.handlers. План — в meta.json до первой ячейки.
6. Окна нагрузки
Ячейка — свежий стенд (kill, down -v, затем Stand.start), пользователь и чат (prepare.js), разогрев: 12 файлов s до ready — они же готовые байты контрольного потока (downloads.json). Затем:
| Окно | Длительность | Загрузки | Зачем |
|---|---|---|---|
before |
10 с | низкая λ | задержка и ресурсы ниже потолка |
over |
20 с (блоки предела и рестартов 25 с, приёма 45 с) | высокая λ | рост очереди |
recovery |
до нуля незавершённых, не дольше 420 с | нет | разбор очереди |
after |
10 с | низкая λ | задержка вернулась |
Открытая модель: constant-arrival-rate k6 (bench/k6/queue.js), сценарий на окно, timeUnit: "10s" для дробной λ. VU создаются заранее и не прибавляются (queue_pre_vus: окно over 20, у блока «приём» 80, окна ниже потолка 4): тело — open на VU, создание на ходу с телом 10 MiB теряет итерации (проба: 33–36 при 8 заранее и 60–80 пределе), а 80 VU — это уже ~2,7 ГиБ k6 при запасе ВМ. Ответ не повторяется: 429 — отказ, недосланные итерации — dropped_iterations, пометка. Строка на загрузку: q,<окно>,<отправка мс>,<длительность мс>,<статус>,<Retry-After>,<X-Instance-Id>,<id> в файл консоли, полнота — сверка с итерациями. Момент приёма — отправка + длительность по часам ВМ, как в профилях failover и uploads.
Контрольный поток — готовый bench/k6/background.js (полнота reconcile.line_problems, остановка SIGINT): запись 10/с, чтение истории 10/с, скачивание готовых 5/с. Запущен до before, остановлен после after. Числа — ниже потолка API в разы: он меряет влияние перегрузки, а не нагружает.
7. Метрики и определения
Очередь — три места и общий счёт. Каждую секунду:
| Поле | Что считаем | Откуда |
|---|---|---|
outbox |
queued, published_at IS NULL, срок наступил: relay ещё не передал |
PostgreSQL |
waiting |
queued, published_at IS NULL, срок не наступил: пауза следующей попытки |
PostgreSQL |
published |
queued, published_at есть: брокер подтвердил, никто не взял |
PostgreSQL |
broker_ready |
messages_ready: лежит в брокере |
метрики брокера |
broker_unacked |
messages_unacknowledged: выдано worker, не подтверждено |
метрики брокера |
processing |
взято, идёт аренда | PostgreSQL |
prefetched |
max(0, broker_unacked − processing): у worker, но ждёт места конкуренции |
вычисляется |
unfinished |
outbox + waiting + published + processing: то, что считает предел |
PostgreSQL |
oldest_s |
возраст старейшего незавершённого | PostgreSQL |
staging_ready |
ready с необнулённым staging_key: долг очистки |
PostgreSQL |
В строку ячейки — пики и значения на конце окна; в timeline.csv — посекундно. queue_wait_ms из журнала worker (от подтверждения брокером до взятия) — p50 и p95 по окнам: то, сколько задание провело собственно в очереди брокера и worker.
Throughput — готовых в секунду: вложения с updated_at статуса ready в окне over и в окне recovery, делённые на длину окна. Время до ready — updated_at у ready минус момент ответа 202; p50, p95, p99 по окну прихода (before, over, after); для перцентилей before и after повторы сводятся вместе: заданий в них единицы и десятки. Восстановление — от последней загрузки окна over до нуля незавершённых. failed — по error_code и причине.
RSS и память: VmHWM процесса 1 worker (/proc/1/status, docker exec в конце ячейки), render_peak_kib журнала — p50 и наибольший, memory.peak, наибольшие memory.current и anon контейнера, oom_kill (memory.events). memory.peak не нуждается в сбросе: контейнер новый в каждой ячейке; у перезапущенного worker — наибольшее по жизням (решение 10), VmHWM — последней жизни. CPU и троттлинг — ядер, доля и мс троттлинга (cpu.stat) worker, S3, PostgreSQL, реплик, relay, брокера, уборщика, LB по окнам, reconcile.window_cpu; CPU worker на задание — за всю ячейку. Брокер: наибольшая memory.current cgroup; сработавший предел памяти виден как отказ в журнале relay.
Журналы (docker logs, только разбор, в метку не копируются): worker — «Started worker» (сверка настроек), «Started job attempt» (queue_wait_ms, redelivered), «Attachment became ready» (render_ms, render_peak_kib, duration_ms), «Retrying job», «Attachment failed», «Skipped job message»; relay — сумма published, republished, recovered, «Relay backlog is full»; реплики — «Rejected attachment» по reason; уборщик — «Finished staging cleanup pass».
8. Блоки сверх матрицы
| Блок | Конфигурация | Что меряет | Что ждём по пробе |
|---|---|---|---|
gate-on |
s, (2, 2), 20/с, 25 с, предел по умолчанию |
плато незавершённых, 429, задержку | плато 250, 429 ~180, p95 до ready и восстановление ~85 с |
gate-off |
то же, UPLOADS__MAX_UNFINISHED_JOBS=0 |
рост без предела | пик ~430, p95 и восстановление ~145 с |
accept |
m, (2, 2), 15/с, 45 с, предел по умолчанию |
цепочку приёма: S3, места, затем предел; что с worker | 429 busy с ~10-й секунды, backlog с ~35-й, S3 у 1 CPU до предела, ~0,6 готовых/с до него, пик 250–290 |
w2-p2 |
s, (2, 2), второй worker в конце over |
ускорение от ресурса | ~5,4/с вместо ~3/с |
w2-p256 |
s, (2, 256), то же |
простой второго worker | второй берёт 0 заданий |
kill-worker |
s, (2, 2), 8/с, 25 с, KILL и запуск в середине |
не теряем, аренда | две попытки у 2 заданий |
restart-broker |
s, (2, 2), 8/с, 25 с, compose restart в середине |
не теряем, outbox растёт на время рестарта | попыток сверх одной нет |
Второй worker — docker compose run -d --no-deps --name mtusi-bench-worker-2 worker с тем же override; момент запуска — конец over, а не середина: новые сообщения во время over брокер делил бы поровну и смазывал бы опыт, а реальный ответ оператора на перегрузку — запуск после обнаружения. Базовая линия без второго worker — ячейки матрицы (s, (2, 2)) и (s, (2, 256)). Доля заданий второго — по его журналу. Лимиты те же, бюджет — решение 10.
Копии при prefetch больше конкуренции (проба: 188 на 150 заданий при пороге 15 с) в метку не входят: опыт требует менять порог, а на значениях по умолчанию при пределе 250 бэклог короче порога. Механизм уже назван в REPORT.md, эффект нулевой, и его закрывает правило prefetch = concurrency решения 12. При (2, 256) в матрице число копий пишется как есть (ждём 0).
9. Граница чёрного ящика
Генератор — только HTTP через LB. Истина о готовности — GET /attachments/{id}: после окна after и разбора очереди bench/k6/queue_sweep.js запрашивает метаданные каждого принятого вложения (shared-iterations, ids из строк k6): статус, error_code, число вариантов, updated_at; у выборки (10 на ячейку, от зерна) скачивает оригинал и три варианта и сверяет SHA-256 с метаданными. Живой опрос не нужен: updated_at у ready не меняется после фиксации (clear_staging_key его не трогает, сценарий «Готовое вложение не откатывается»), а нагрузки опроса на API в замере не будет. Новые исключения из границы чёрного ящика, только у этого профиля и только на чтение:
psql \watchсэмплера — счётчики задач выше и чтение SQL в конце ячейки: одно задание на вложение, три варианта наready, попытки, причины (pg_stat_*не нужны). Данных и схемы оркестратор не меняет;- метрики брокера по HTTP в сети стенда;
- журналы контейнеров, разбор без копирования.
10. Стенд и сэмплер
bench/queue.compose.yml(статический, третий-fтолько у этого профиля): уrabbitmq— read-only файлыbench/rabbitmq/enabled_pluginsиbench/rabbitmq/91-bench.conf(collect_statistics_interval = 1000). Порт 15692 — только сеть стенда: порты сброшены вbench.compose.yml. У прочих профилей и рабочего стенда плагина нет. Окружение настроек —.work/variant.compose.yml, как уuploads:WORKER__CONCURRENCY,WORKER__PREFETCH,UPLOADS__MAX_UNFINISHED_JOBS.- Перезапуск worker —
restart: unless-stoppedвqueue.compose.yml, как на рабочем стенде, а не"no"изbench.compose.yml: проба — ядро убивает процесс 1 при (4, 4) наlp, и без перезапуска ячейка простояла бы до срока окна с ложнымиstuck. Столбецworker_restarts—.RestartCount, пометкаworker_restart. Перезапуск сбрасывает cgroup того же контейнера:memory.peakи наибольшаяanon— наибольшее по жизням,oom_kill— сумма, CPU — разности внутри жизни. У S3 остаётся"no": его гибель — аномалия, она должна быть видна пометкойstorage_down, а не пережита.docker killблокаkill-workerдемон считает ручной остановкой, запуск — явныйdocker start; успей он раньше —startничего не меняет. Stand.startприis_queue: S3 и bootstrap, брокер, реплики и LB, relay, уборщик и worker--no-deps. Уборщик работает: иначе staging копился бы мимо рабочего поведения; плановая сверка выключена (bench.compose.yml).Stand.stop()иleftovers()— ещёmtusi-bench-worker-2,mtusi-bench-images. Передdown—compose kill: S3 иначе останавливается ~15 с.sampler.sh, режимqueue: раз в секунду — обход cgroup, какscan(cg),vm,lb; новые строкиmp <нс> <id12> <memory.peak> <anon> <oom_kill>иmq <нс> <ready> <unacked>(/dev/tcp/rabbitmq/15692, HTTP/1.0, фильтр по имени очереди; брокер недоступен —mq <нс> missing). В фонеpsql \watch— строкаjobsс полями решения 7, один запрос в секунду на маленькой таблице свежего стенда. Контейнер:--cgroupns host, сеть стенда,--env POSTGRES_PASSWORD, 0,25 CPU / 128 МиБ. Разбор —bench/overload.py,cgиvm—scaling.parse_samples. Роли —Stand.container_map(): второй worker и контейнер после рестарта видны сами; сторож — тиков нет 3 с в нагрузке — отказ, как уfailover.- Готовность к сравнению:
limitsчитаются у запущенных контейнеров, на все ячейки одни (кроме второго worker). Запись «Started worker» сверяется с ячейкой: расхождение — отказ. - Бюджет: CPU реплики 2 + PostgreSQL 2 + LB 1 + Valkey 0,5 + S3 1 + брокер 1 + relay 0,25 + worker 1 (второй ещё 1) + уборщик 0,25 + сэмплер 0,25 = 9,25–10,25 из 12; память лимитов 5–6 ГиБ плюс k6 до ~2,7 ГиБ на блоке приёма из 7,75: занято по пробам ~3,5 ГиБ без k6, сумма лимитов до конца не выбирается.
vm_warningsсчитает эти роли, сумма CPU больше ВМ — код 2 до стенда, какlevel4_budget. Посторонние контейнеры — в паспорт.
11. Достоверность и шум
Пометки строки (flags): oom — oom_kill > 0; worker_restart — ядро завершило процесс 1, контейнер перезапущен; lost — принято, а метаданных нет; stuck — не ready и не failed к концу; duplicate — заданий на вложение больше одного или вариантов не три; sha_mismatch; not_recovered — срок окна recovery вышел; failed — есть failed; dropped — недосланные итерации; lb_down — реплика выходила из LB; host_swap; storage_down. lost, stuck, duplicate, sha_mismatch дают ненулевой код команды в конце метки (ячейки сняты, отказ — на всю метку): замер, где система потеряла работу, — это результат, а не сбой команды, но зелёной метка быть не должна. oom, worker_restart и failed — результат настройки.
Шум. Объявлено заранее: разброс — min–max трёх повторов одной конфигурации; разница двух конфигураций считается эффектом, только если их разбросы не пересекаются и разница медиан больше наибольшего разброса пары; иначе пишется «в пределах шума». На пробах разброс трёх повторов — 1–8 % по throughput и до 3 % по памяти («Шум и цена стенда»): допуски гипотез ниже шире него. Отдельной метки A/A нет: это умножило бы время, а настройка по умолчанию повторяется в каждом круге и служит опорой.
Хост — bench.md: перед меткой рабочий стенд make stop, питание от сети. Прирост Swapouts за ячейку — пометка host_swap: настоящая помеха, такая метка переснимается под новым именем, если задетые ячейки входят в выводы; каталог метки не перезаписывается. Прочие предупреждения о хосте, явно не влияющие на замер, прогон не останавливают (указание пользователя 2026-10-31).
12. Гипотезы, правило рекомендации и значения по умолчанию
Записываются в REPORT.md и коммитятся раньше меток замера. Числа — из проб выше. Вердикт считает bench/overload.py, в сводке: «подтверждено», «нет», «нет данных».
| № | Гипотеза | Подтверждено, если |
|---|---|---|
| H1 | Потолок при 1 CPU — CPU worker; конкуренция сверх двух его не поднимает | на всех классах медиана throughput окна recovery (4, 4) / (2, 2) ≤ 1,05; CPU worker в окне over при c ≥ 2 ≥ 0,85 ядра; на m и lp (1, 1) / (2, 2) ≤ 1,0 |
| H2 | Обработка задания дольше пропорционально конкуренции, память растёт на пик процесса | duration_ms p50 (4, 4) / (2, 2) ≥ 1,5 на всех классах; memory.peak (2, 2) < 1 ГБ без oom на всех классах; (4, 4) на lp: memory.peak ≥ 95 % лимита во всех повторах, oom_kill > 0 хотя бы в одном (пробы: в трёх прогонах из четырёх); (4, 4) на lj: без oom, пик ≤ 500 МиБ |
| H3 | Большой prefetch не меняет throughput одного worker и прячет очередь от брокера и второго worker | (2, 256) / (2, 2): throughput в [0,85; 1,15], p95 до ready в [0,8; 1,25] на s и lp; пик broker_ready ≤ 10 % пика незавершённых у (2, 256), ≥ 70 % у (2, 2); блок второго worker: доля второго среди заданий, завершённых после его запуска, ≥ 30 % при prefetch 2 и ≤ 5 % при 256, восстановление p256 / p2 ≥ 1,4 |
| H4 | Задержка под перегрузкой — это очередь | на всех ячейках матрицы без oom p95 до ready окна over в [0,8; 1,25] × пик незавершённых / throughput |
| H5 | Предел ограничивает принятую работу и срок ожидания | gate-on: пик незавершённых ≤ 290, 429 > 0, у всех Retry-After 5, 5xx нет, 429 = записи backlog; gate-off: пик ≥ 375; gate-on / gate-off: p95 до ready и восстановление ≤ 0,75; p95 до ready gate-on в [0,8; 1,25] × предел / throughput; загрузка before p50 gate-on − gate-off ≤ 3 мс (проба A/B: +0,9 мс) |
| H6 | Восстановление: система приходит в норму сама и никого не теряет | во всех ячейках lost, stuck, duplicate, sha_mismatch нет; восстановление ≤ 1,3 × пик незавершённых / throughput окна over (матрица без oom, предел); p95 after ≤ 1,5 × p95 before по конфигурации; failed только при oom и только retry_exhausted |
| H7 | Перегрузка очереди не задевает остальной API | во всех окнах всех ячеек, кроме accept: p95 записи и чтения ≤ 200 мс, скачивания ≤ 500 мс; 5xx контрольного потока нет; lb_down нет |
| H8 | Рестарты под перегрузкой не теряют работу | kill-worker: всё ready, заданий с повторной попыткой ≤ 2, очередь разобрана не позже большего из «конец over + 1,3 × пик / throughput» и «KILL + аренда 70 с + 15 с»; restart-broker: всё ready, заданий с повторной попыткой нет, 5xx на загрузке нет, восстановление ≤ 1,3 × пик / throughput + 15 с |
| H9 | Приём ограничен S3, местами и затем пределом, а не падением; S3 общий с worker | accept: первый 429 busy раньше первого backlog, оба есть, 5xx нет; CPU S3 в первые 30 с окна ≥ 0,85; принято за окно / длина окна ≥ 6/с (λ m в матрице); пик незавершённых ≤ 290; готовых/с в окне ≤ 1,5 при ≥ 2,4 в окне восстановления; контрольный поток: запись и чтение p95 ≤ 200 мс, скачивание ≤ 1 с, без 5xx |
Правило рекомендации (считается в сводке, вывод — в REPORT.md): кандидат — настройка без oom и failed ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а prefetch равен конкуренции: большему нечего добавить (H3). Значения по умолчанию меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором make bench_queue_quick, а не переснятие. По пробам ждём, что (2, 2) остаётся: (1, 1) теряет 12–15 % на lp и m, (4, 4) упирается в память. Компромисс latency и ресурсов — вывод из таблиц метки: что даёт память при той же скорости, что даёт CPU (второй worker), и при каких условиях поднимать конкуренцию: concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса). Формула — гипотеза в отчёте, её члены — числа метки.
Ограничения метода — в отчёт дословно по метке:
- один хост и ВМ Docker Desktop (arm64, 12 CPU, 7,75 ГиБ): лимит 1 CPU — квота CFS, а не отдельное ядро; генератор и посторонние контейнеры на той же ВМ, доля их CPU видна по
vm; - один worker; второй — только в своём блоке и на классе, где S3 не узкое место: общая формула масштабирования не утверждается;
- ячейка — один класс, один файл на все загрузки: смесь размеров и разброс содержимого не мерятся;
- окна короткие, 20–45 с перегрузки: многочасовая перегрузка, autovacuum под длинным оборотом и рост WAL не мерятся, проба — только 90 с оборота;
- открытая модель без повторов: поток клиентов, послушно повторяющих после
Retry-After, не мерится; отказ считается отказом; - PostgreSQL, relay и брокер в этих интенсивностях не упираются: их предел трек не определяет;
max_published_backlogи предел памяти брокера нагрузкой не достигаются (решение 4); - одна нода S3, staging и конечный префикс на одном диске ВМ; ячейки — на свежем volume, поэтому рост памяти S3 с накопленными объектами не мерится (проба на старом стенде —
KNOWN_ISSUES.md); - выборки
beforeиafterмалы наlp: повторы сводятся, p99 у малых выборок — только справочно; - завершение процесса 1 ядром при (4, 4) на
lpслучайно (пробы: один подтверждённый случай и один по тем же признакам из пяти прогонов): его частота из трёх повторов не следует, метка показывает, что работа не теряется.
13. Что ещё меняет предел
- Профиль
uploads: worker в нём нет, задания копятся;.work/variant.compose.ymlвсех его вариантов получаетUPLOADS__MAX_UNFINISHED_JOBS=0(спек, сценарий «Предел заданий не участвует»). Прежние метки не сравниваются (они и так не сравнивались, решение 16 архива). - Стенд отказов: у четырёх прежних API
UPLOADS__MAX_UNFINISHED_JOBS=0(run_failures.py):test_reconcile_under_load— 16 загрузок/с против ~4/с, остановленные worker других проверок. Пятый API — «узкий по заданиям»,BACKLOG_ENV=UPLOADS__MAX_UNFINISHED_JOBS=3→FAULT_BACKLOG_BASE_URL,FAULT_BACKLOG_ENV, фикстураbacklog_api,assert_backlog_stand;pytest -m faultбез него — отказ, как у остальных. make test_isolated,make student_test,driver.py: значение по умолчанию; единицы загрузок,reconcile-stress—upload_readyпо очереди, замкнутый контур: предела не достигают.
14. Файлы метки и цена
evidence/queue/<метка>/: meta.json (профиль, образы, классы и SHA-256, план, лимиты, окружение, host_state), cells.csv (строка на ячейку, новые столбцы — только в конец; готовая строка — признак для RESUME=1), timeline.csv (посекундно, с отметками окон), summary.md, throughput-by-setting.svg, p95-by-setting.svg, memory-by-setting.svg, backlog-gate.svg (plots.Svg), raw/<ячейка>-k6.json (итоги k6 без токенов). quick-queue-* — в .gitignore. RESUME=1 и блокировка — как у серий.
Время. Ячейка матрицы: стенд с уборкой ~30 с, разогрев ~5, окна 10 + 20 + ~39 (среднее восстановление по пробам, lp при (4, 4) — 40–80 с) + 10, конец ~8 = ~122 с; 12 × 3 = 36 ячеек — ~73 мин. Блоки: gate-off ~240 с, gate-on ~175, accept ~210, w2-* ~100–115, kill-worker и restart-broker ~140–150, вместе 7 × 3 = 21 ячейка — ~57 мин. Полная метка — чуть больше двух часов (~2 ч 10 мин) плюс сборка и файлы классов ~1 мин; перезапуск worker с ожиданием аренды добавляет ячейке до 70 с. queue_quick — s (2, 2), lp (4, 4), предел с UPLOADS__MAX_UNFINISHED_JOBS=40 и без него, kill-worker, w2-p256, по одному повтору, окна 5 + 10 + … + 5: ~11 мин.
15. Сценарий защиты и документы
Защита: шаг «для 5 — выбранный эксперимент» — make bench_queue_quick (~11 мин, заранее или на глазах) и разбор evidence/queue/baseline/summary.md: таблица настроек, плато предела, второй worker, рестарты. Новой команды драйвера нет: она повторяла бы профиль.
REPORT.md: «Трек 1 уровня 5» в таблице критериев; раздел экспериментов с гипотезами (до метки), методикой, определениями, таблицами, выводами; «Сервисы и лимиты», «Открытые вопросы», «Ограничения»: снимаются записи «Дорогие файлы тратят CPU до лимита», «Отставание очистки staging», «Цена процесса на задание», «Ограничения принятой работы на входе API нет» — заменяются измеренным; новое ограничение — завершение процесса 1 worker ядром при конкуренции, которая не помещается в лимит. Правила: bench.md (раздел профиля), worker.md, settings.md, api-contract.md, service-layer.md, repo-layer.md, logging.md, student-tests.md; AGENTS.md — статус лабы, команды, карта кода; config_example.toml. QUESTIONS.md — раздел этого change, вопросы переносятся в REPORT.md.
Покрытие сценариев
Сценарии спеков из CAPABILITIES; fault — make failure_checks, стенд с пятым API.
| Capability, сценарий | Проверка |
|---|---|
queue-overload «Предел достигнут», «Порядок проверок у предела», «Остальной API у предела», «Загрузки снова принимаются» |
test_backlog_limit, fault |
| «Завершённые задания не считаются» | test_backlog_ignores_finished, fault |
| «Ожидание следующей попытки считается» | test_backlog_counts_waiting_retry, fault |
| «Предел при остановленных брокере и relay» | test_backlog_without_broker, fault |
| «Превышение ограничено» | test_backlog_overshoot_bounded, fault |
| «Предел выключен» | test_backlog_off, fault |
| «Работа копится там, где положено», «Приём упирается в места загрузки», «Сначала места, затем предел», «Контрольный поток под перегрузкой», «Бэклог уходит за измеренное время», «Никого не теряем», «Время до готовности вернулось», «Worker убит под перегрузкой», «Брокер перезапущен под перегрузкой» | исключения сверки (нужна открытая нагрузка, счётчики и рестарт контейнера): make bench_queue → evidence/queue/baseline/summary.md |
attachments «Порядок проверок загрузки» |
прежние тесты; новый шаг — test_backlog_limit |
Вне сверки: service-configuration — service-tests (настройка), запись о старте — журнал пятого API в test_backlog_limit-наборе и make run_docker; load-benchmark — make bench_queue_quick, make bench_uploads_quick; health, job-outbox, message-broker — прежние тесты, текст уточнён.
Risks / Trade-offs
- [Предел один на стенд: один клиент может занять его целиком] → ограничение названо; места загрузки ограничивают скорость такого клиента; справедливость — отдельная тема вне трека.
- [Счёт — по числу, а
lpвтрое дорожеs] → значение выбрано по худшему классу, у мелких файлов предел консервативен; видно в таблицах. - [Предел отклоняет загрузки при остановленном worker] → это и есть граница; текст, история, метаданные, готовые байты и
/health/readyработают (сценарий),make replayне задействован; при длинном простое оператор видитbacklogв журнале. - [
Retry-Afterбез случайной добавки: клиенты могут повторять разом] → у них 5 с; отказ — один запрос к PostgreSQL, 1,9 мс CPU реплики и 0,3 мс PostgreSQL (проба), ~1 000 отказов/с на двух репликах; места не занимает. - [Счёт идёт в первом блоке: загрузка, попавшая в кэш чата, теперь берёт соединение] → +0,9 мс p50, +0,8 мс CPU реплики и +0,4 мс PostgreSQL на самой дешёвой загрузке (проба A/B, оценка сверху);
[database]срок прежний; шаг прежний, цепочка LB та же. - [Приём на границе байтов отнимает S3 у worker: ~0,6 готовых/с вместо 2,9] → предел заданий останавливает это на 250, но не раньше ~35 с такой нагрузки; места и
concurrentUploadLimitMBпока делят ресурс как есть. Отдельный приоритет обработки — вне трека, вывод — по метке. - [Ядро может убить процесс 1 worker, если конкуренция не помещается в лимит] → работа не теряется, контейнер перезапускается, задания возвращаются по аренде (до 70 с); значение по умолчанию на всех классах помещается; правило подбора конкуренции —
worker.md. - [S3 на долго живущем стенде подходит к лимиту памяти] → вне метки,
KNOWN_ISSUES.mdс предложением; рабочий стенд перезапускает его сам, а бюджет задания переживает короткий рестарт. - [Плагин метрик брокера только в профиле] → паспорт называет; простой + 0,1 % ядра, файлы конфигурации только у этого профиля; рабочий стенд не меняется.
- [Метка ~2 ч 10 мин на ноутбуке] →
caffeinate,RESUME=1, предупреждения о хосте; порядок кругами размазывает дрейф хоста по конфигурациям. - [Одна λ на все настройки: у (1, 1) и (4, 4) очередь больше] → это и меряется;
recoveryограничен 420 с,not_recovered— пометка. - [Малые выборки
beforeиafterуlp: 4–5 заданий] → повторы сводятся; вывод только с разницей больше разброса, в отчёте названо. - [Заливка одним и тем же файлом класса] → дедупликации в приложении и в S3 нет; разнообразие контента не проверяется, это ограничение синтетики, названо.
- [Один worker и один хост: второй worker на той же ВМ, S3 один] → блок
w2-*— наs, где S3 не узкое место (0,09 ядра); общая формула масштабирования не утверждается.
Migration Plan
- Шага оператора нет: секретов и схемы не прибавилось; существующий
config.toml— значение по умолчанию. - Вперёд:
make rolling_update. Смесь реплик безопасна: прежние предел не считают. - Откат:
make rolling_update COMMIT=<прежний> MIGRATE=0. Данные не менялись. - После проб в scratchpad остаётся
track1/(кандидаты, скрипты, журналы). Контейнеры, сети и образы проектаq1probeудалены. Остались его volumesq1probe_postgres_data,q1probe_rabbitmq_data,q1probe_s3_data: при уборке автопроверка отказала в команде сdocker compose … down -v, обход не применялся; удалить вручную —QUESTIONS.md, «Для пользователя после прогона».
Уточнения apply
-
oom_kill— сумма по жизням плюс перезапуски. Наmake bench_queue_quick(lp, (4, 4)) контейнер перезапустился, а счётчик показал 0: ядро завершает процесс 1, cgroup уходит раньше следующего тика, и прочитать счётчик умершей жизни нельзя. Перезапуск по политикеunless-stoppedбывает только при аварийном выходе,docker killблокаkill-workerдемон считает ручной остановкой, поэтому перезапуск считается завершением ядром, и ячейка получаетoom. Причина перезапуска в метке не проверяется отдельно:.State.OOMKilledпосле нового старта сброшен. -
Доля второго worker — только разбор накопленного: от его запуска до нуля незавершённых. Окно
afterприходит после разбора и делится поровну при любомprefetch; с ним доля приprefetch256 была 6,7 % при нуле заданий из бэклога, и H3 ложно не подтверждалась бы. Порог H3 (≤ 5 %) не менялся, уточнено только, какие задания считаются, — как и сказано в таблице решения 8: «второй берёт 0 заданий». -
CPU за окно — с линейной интерполяцией на краях. Разность только по отсчётам внутри окна при тике ~1,1 с занижала CPU на ~10 %, и H1 на 10-секундном окне давала 0,84 вместо ~0,95. Порог H1 не менялся.
-
Прокрутка блоков до метки: в
queue_quickнетaccept,restart-brokerиw2-p2, поэтому они один раз проверены скриптом в scratchpad поверхrun.mainс подменённым набором конфигураций (меткаquick-queue-blocks-*, в git не идёт). Изменений в инструментах это не требует. -
second_jobs— столбец решения 8;broker_refused— число проходов relay с неподтверждёнными сообщениями: так сработавший предел памяти виден в метке без разбора текста журнала. -
Журнал пятого API в тесте: добавлено действие hook
backlog-api-log, которого нет в задаче 4.2: сценарий «журнал реплики называет отказ» и запись о старте проверяются вtest_backlog_limit, как обещает раздел «Покрытие сценариев». -
Красное в
make student_testшире, чем ждёт задача 7.2:test_exclusion_evidence_existsназывает не толькоevidence/queue/baseline/summary.md, но иevidence/auth/passwords-and-tokens.md,evidence/cache/hits.md,evidence/idempotency/replay-after-restart.md. Их нет и на5b5f59a: не следствие этого change. Стадия apply вevidence/не пишет, снять их — до отчёта (QUESTIONS.md, «Для пользователя после прогона»).
Open Questions
Вопросы преподавателю — QUESTIONS.md, раздел track1-queue-overload: ни один не меняет подход и задачи; другой ответ меняет строку таблицы ошибок и сценарий.