{"canonical_url":"https://engineer.company/uk/notes/selling-limited-stock-without-overselling/","content_markdown":"# Продати останній квиток рівно один раз\n\n2026-10-13\n\nПід час флеш-розпродажу мільйон людей одночасно намагається купити десять тисяч\nодиниць товару. Цікавий збій тут не той, коли магазин падає, а той, коли магазин\nпрацює й продає десять тисяч сорок одиниць. Перша реакція — «база замала,\nшардуймо її» — відповідає на питання, якого ніхто не ставив. Справа ніколи не\nбула в розмірі бази. Кожен покупець писав у\nтой самий рядок *(увесь інцидент живе в одному рядку)*.\n\nТут ми розбираємо проблему ще до того, як вона трапиться в проєкті: звідки\nбереться стеля, яка єдина інструкція усуває більшу її частину і що будувати,\nколи однієї бази справді замало.\n\n## Один рядок, усі покупці\n\nДвадцять мільйонів рядків, розкладених по кластеру, — розв'язана задача. Один\nрядок, який мусить змінити кожен запит, — ні, і додаткові машини на нього не\nвпливають, бо рядок живе на одній із них. Розподілені сховища прямо про це\nпишуть: DynamoDB дає одному розділу близько 1 000 одиниць запису на секунду, і\nкожен запис для одного товару потрапляє в розділ цього товару, скільки б інших\nрозділів не було.\n\nЗа цією закономірністю стоїть теорема. Бейліс і колеги називають інваріант\nінваріантно-конфлюентним, коли репліки можуть приймати записи незалежно одна від\nодної й усе одно зливатися в коректний стан. `stock \u003e= 0` — хрестоматійний\nприклад інваріанта, який таким не є: дві репліки, кожна з яких бачить останню\nодиницю, продадуть її обидві, і жодне злиття не скасує другий продаж. Щоб ніколи\nне продати більше, ніж є, потрібна координація. Питання лише в тому, скільки\nцієї координації оплачує кожен продаж.\n\n## Число, яке все вирішує\n\nСтеля для одного товару — це приблизно кількість продажів за одне блокування,\nподілена на час його утримання:\n\n```text\nмакс. продажів/с на товар ≈\n  продажів за одне блокування ÷ час утримання блокування\n```\n\n| Що тримає рядок          | Стеля на рядок |\n| ------------------------ | -------------- |\n| Блокування, потім оплата | ~2/с           |\n| Блокування, потім логіка | ~100–200/с     |\n| Один умовний `UPDATE`    | ~500–2 000/с   |\n| Пакети по 100 на коміт   | ~50 000/с      |\n| Один записувач у пам'яті | ~100 000+/с    |\n\nЦе порядки величин, а не бенчмарки: залізо зсуває цифри, але не саму картину.\nБільшу частину короткого блокування займає коміт, що чекає, поки журнал\nзапишеться на диск, тому пакетування й дає виграш у два порядки: сто продажів\nділять один скид на диск.\n\nЛишаються чотири важелі, і кожен дизайн нижче тягне за один із них:\n\n1. **Тримати блокування коротше** — одна інструкція, нічого мережевого\n   всередині.\n2. **Робити більше за одне блокування** — пакетувати списання.\n3. **Мати більше блокувань** — розділити запас між кількома ключами.\n4. **Надсилати до блокування менше запитів** — відвертати більшість покупців,\n   перш ніж вони до нього дійдуть.\n\nОстанній важить більше, ніж здається. З мільйоном покупців і десятьма тисячами\nодиниць 990 000 запитів мусять отримати відмову. Відмови — це більша частина\nтрафіку, тож «розпродано» має бути найдешевшою відповіддю системи: зала\nочікування перед розпродажем, шлюз, що пропускає приблизно стільки покупців,\nскільки є одиниць, прапорець `sold_out`, який CDN віддає, нікого не питаючи, і\nобмеження частоти запитів на обліковий запис.\n\n## Спершу виправте одну базу\n\nВерсія, яка ледве повзе або продає більше, ніж є, зазвичай має такий вигляд:\n\n```sql\nBEGIN;\nSELECT available FROM inventory\n WHERE item_id = :item FOR UPDATE;\n-- застосунок перевіряє число\n-- і, можливо, викликає платіжний сервіс\nUPDATE inventory SET available = :new\n WHERE item_id = :item;\nCOMMIT;\n```\n\nБлокування правильне. Неправильне те, що воно охоплює: кожна мілісекунда, яку\nзастосунок проводить між `SELECT` і `UPDATE`, — це мілісекунда, яку чекає\nнаступний покупець. Без `FOR UPDATE` гірше. Двоє покупців читають 1, обидва\nпишуть 0, і одну одиницю продано двічі.\n\nВиправлення — об'єднати перевірку і списання в одну інструкцію:\n\n```sql\nUPDATE inventory\n   SET available = available - :qty\n WHERE tenant_id = :tenant\n   AND item_id = :item\n   AND available \u003e= :qty\nRETURNING available;\n-- повернувся рядок: зарезервовано. жодного: розпродано.\n```\n\nУ PostgreSQL на рівні READ COMMITTED другий покупець, який дістався рядка,\nпоки його тримає перший, чекає, а тоді знову перевіряє умову `WHERE` на рядку,\nякий закомітив перший. Якщо той продаж забрав останню одиницю, умова не\nвиконується, і другий покупець не отримує жодного рядка — розпродано — замість\nвід'ємного числа. На REPEATABLE READ чи SERIALIZABLE другий покупець натомість\nотримує помилку серіалізації: це безпечно, але перетворює конкуренцію на\nповтори; READ COMMITTED — саме той рівень, під який написано цю інструкцію.\nInnoDB у MySQL дає той самий результат, бо `UPDATE` там читає\nостанній закомічений рядок на будь-якому рівні. Додайте ще й обмеження, щоб\nпомилка деінде в коді спричиняла явний збій, а не продаж запасу, якого немає:\n\n```sql\nALTER TABLE inventory\n  ADD CONSTRAINT available_not_negative\n  CHECK (available \u003e= 0);\n```\n\nДалі решта роботи в межах однієї бази, приблизно в порядку віддачі:\n\n- **Нічого зовнішнього всередині транзакції.** Жодного виклику оплати, жодного\n  HTTP-запиту, жодного надісланого повідомлення. Їм місце до транзакції або\n  після неї.\n- **Гарячий рядок — останнім.** Спершу вставте замовлення й усе інше, щоб\n  блокування на рядку, за який конкурують, трималося лише впродовж останньої\n  інструкції та коміту.\n- **Жодного оптимістичного блокування на гарячому лічильнику.** Стовпець версії\n  перетворює конкуренцію на повтори, а під час розпродажу повтори і є\n  навантаженням.\n- **Читання — з іншого місця.** «Залишилося 12» на сторінці товару може йти з\n  репліки чи кешу, що відстає на секунду. Лише продажу потрібна основна база.\n- **Дайте запасу окрему базу,** щоб розпродаж ніколи не стояв у черзі за\n  каталогом до того самого диска.\n- **Пул з'єднань.** Сто тисяч покупців мають перетворюватися на кілька десятків\n  з'єднань через PgBouncer, а не на тисячі бекендів у черзі до одного\n  блокування.\n\nЗ місцями все інакше: кожна одиниця унікальна, тож потрібна інша інструкція.\nКожне місце — це рядок, і покупець пропускає рядки, які тримає інша транзакція,\nзамість того щоб чекати, доки їх звільнять:\n\n```sql\nUPDATE seats\n   SET held_by = :order,\n       held_until = now() + interval '10 min'\n WHERE id = (\n   SELECT id FROM seats\n    WHERE event_id = :event\n      AND sold_at IS NULL\n      AND (held_until IS NULL\n           OR now() \u003e held_until)\n    LIMIT 1\n    FOR UPDATE SKIP LOCKED)\nRETURNING id;\n```\n\nРезерв, що сплив, просто знову вільний, тож для правильної відповіді не потрібен\nжоден фоновий процес прибирання. А `now()` — це годинник бази, тож сервери\nзастосунку, чиї годинники розходяться, не можуть розійтися в тому, коли резерв\nсплив.\n\nБагатьом магазинам цього розділу й досить. Зробіть це раніше за все, що нижче,\nбо шардування — двері, які відчиняються в один бік: увійти легко, вийти дорого.\n\n## Спершу резерв, потім оплата\n\nПокупець, що взяв останню одиницю й покинув форму оплати карткою, її не купив.\nТож продаж — це не один запис, а короткий життєвий цикл:\n\n```text\nAVAILABLE → HELD, на хвилини → SOLD\n                             → RELEASED\n```\n\n- **Резерв прив'язаний до запиту, а не до спроби.** Кожне оформлення має ключ\n  ідемпотентності, а таблиця резервів має\n  `UNIQUE (tenant_id, idempotency_key)`, тож повторний клік отримує вже\n  наявний резерв, а не ще одну одиницю. Тут є підступна деталь PostgreSQL:\n  `INSERT ... ON CONFLICT DO NOTHING RETURNING id` нічого не повертає, коли\n  рядок уже існував, тож «рядок не повернувся» означає «знайди його», а не\n  «не вдалося».\n- **Кожен перехід умовний.** Підтвердження продажу переводить резерв із `held`\n  у `sold` лише якщо він досі `held`, а звільнення повертає запас, лише\n  якщо його власне оновлення змінило рівно один рядок. Звільнення, що\n  спрацювало двічі — скажімо, тайм-аут і кнопка скасування, — повертає\n  одиницю один раз.\n- **Резерви спливають за хвилини.** Зазвичай за п'ять–десять. Продовжте резерв\n  один раз, коли починається оплата, щоб покупець із повільною оплатою не\n  втратив одиницю, за яку саме платить.\n- **Обмежте кількість одиниць на покупця вже під час резерву,** щоб один\n  обліковий запис не тримав увесь запас, поки вагається.\n\nВ основі всього цього — один рядок, найкорисніший у всьому дизайні:\n\n```text\navailable + held + sold = total\n```\n\nРівність справджується після кожної транзакції, її перевіряє один запит, і\nколи вона перестає справджуватися, десь продали зайве чи загубили одиницю, — і\nви дізнаєтеся про це раніше за клієнта.\n\n## Коли однієї бази замало\n\nІноді її справді замало: багато орендарів, багато розпродажів одночасно, кілька\nрегіонів. Структура, яка масштабується, тримається одного правила — кожен товар\nмає рівно одного власника свого запасу, сервіс запасів, і ніхто інший не\nвирішує — і шардує цей сервіс за `(tenant_id, item_id)`, щоб записи одного\nтовару ніколи не охоплювали двох шардів. Найбільші орендарі отримують власні\nкомірки, щоб їхній розпродаж не забирав ресурси в інших. Синхронним має бути\nлише резервування; усе після нього може бути повідомленням.\n\nДля гарячого товару всередині шарда є чотири інструменти, і кожен тягне за один\nіз важелів вище.\n\n**Шлюз попереду.** Лічильник у Redis, який зменшує Lua-скрипт так, що перевірка\nі списання — один крок, пропускає приблизно стільки покупців, скільки є одиниць,\nа решту відвертає за мікросекунди. Остаточно вирішує не він. Redis реплікує\nасинхронно, тож після перемикання на репліку нова основна може забути частину\nпропусків і впустити трохи забагато. Рішення все одно ухвалює умовний `UPDATE`\nбази, а процес звірки відновлює шлюз за числом із бази.\n\n**Розділіть запас.** Десять тисяч одиниць можна поділити на сотню сегментів по\nсто, кожен своїм рядком або своїм шардом, і кожного покупця скеровують в один:\nсто блокувань замість одного. Ідея стара — escrow-транзакції О'Ніла 1986 року,\nпотім демаркаційний протокол Барбари та Гарсія-Моліни, потім обмежені лічильники\nБалегаша й колег — і єдина її справжня ціна — хвіст. Сегмент покупця спорожнів,\nа в інших ще є запас, тож або спробуйте інший сегмент, або перенесіть залишки, а\nпід кінець розпродажу знову зведіть усе в один. Та сама ідея дає кожному регіону\nвласну квоту, щоб більшості продажів не доводилося питати дозволу через океан.\n\n**Один записувач на товар.** Кладіть кожен запит на товар в один розділ Kafka,\nякий читає один споживач: він тримає число в пам'яті й комітить свої рішення\nпакетами. Один потік і жодних блокувань — архітектура в стилі LMAX. Запити мають\nідентифікатор, і записувач відкидає той, щодо якого вже ухвалив рішення, бо\nчерга може доставити повідомлення двічі.\n\n**Одиниці як рядки.** Коли одиниць небагато і вони унікальні — місця, нумеровані\nвидання, — створіть по рядку на кожну заздалегідь і забирайте їх через\n`SKIP LOCKED`, як вище, або тримайте ідентифікатори одиниць у множині Redis і\nберіть одну через `SPOP`. Тоді не лишається лічильника, за який битися.\n\n## Решта оформлення\n\nОплата, замовлення й квитанція — окремі системи, і жодна транзакція їх не\nохоплює. Двофазний коміт — хрестоматійна відповідь, але тут хибна: він блокує,\nпоки будь-який учасник повільний, додає обміни повідомленнями на найгарячіший\nшлях, а платіжні сервіси в ньому не беруть участі. Із задачею впорається сага —\nпослідовність локальних кроків, кожен зі своїм кроком відкату:\n\n```text\n1. резерв запасу          відкат: звільнити резерв\n2. замовлення в очікуванні  відкат: скасувати його\n3. продовжити резерв      (спливе сам)\n4. авторизувати оплату    відкат: анулювати\n5. підтвердити HELD → SOLD\n6. списати оплату\n```\n\nОскільки оплату спершу авторизують, а списують наприкінці, платіж, що надійшов\nуже після того, як резерв сплив, анулюють, а не повертають: гроші так і не\nбуло списано. Кожен крок записує своє повідомлення в таблицю outbox у тій самій\nтранзакції, що й зміну, про яку воно сповіщає, а change data capture його\nпублікує, тож між «збережено» і «надіслано» нічого не губиться. Кожен споживач\nідемпотентний, з ідентифікатором замовлення як ключем. Повідомлення приходять\nщонайменше один раз, а завдяки ідемпотентності кожне фактично обробляється\nодин раз.\n\nРозподіленому блокуванню тут не місце ніде. Думка Клеппмана в тому, що власник\nблокування може зависнути довше, ніж триває його оренда — збирання сміття,\nпризупинена віртуальна машина, — і далі писати, а ліки від цього —\nfencing-токен, який перевіряє сховище. Але сховище, яке вміє перевірити токен,\nуміє перевірити й `available \u003e= :qty`, і тоді блокування йому ніколи не було\nпотрібне.\n\n## Поставте товар на паузу, але не продавайте понад залишок\n\nУзгодженість і доступність обирають для кожного питання, а не для системи\nзагалом. «Чи можна продати цю одиницю?» мусить бути узгодженим: коли власник\nзапасу товару недосяжний, цей товар перестає продаватися. Усе інше — каталог,\nпозначка «залишилося 3», історія замовлень — може лишатися доступним і трохи\nзастарілим.\n\nНайнепомітніше зайву одиницю продають під час перемикання на репліку. За\nасинхронної реплікації основна база підтверджує продаж і падає, перш ніж репліка\nйого отримала; репліку підвищують, продажу немає, і одиницю продають знову.\nВиправлення — надійно записати продаж більш ніж на одну машину, перш ніж його\nпідтвердити: синхронний standby у PostgreSQL (`synchronous_commit` із\n`synchronous_standby_names`) або сховище на Raft. Це додає затримку до кожного\nкоміту, а отже, подовжує саме той час утримання блокування, на який ділять у\nформулі стелі, — і пакетування та шлюз цю затримку компенсують. І обмежте паузу:\nшард, що впав, має зупиняти товари на ньому, а не весь магазин.\n\n## Як це довести\n\nУсе це варто перевірити самим — і наші слова теж.\n\n- **Стежте за інваріантом.** Запускайте `available + held + sold = total` за\n  розкладом, будуйте графік і піднімайте тривогу на будь-яке розходження. Нуль\n  продажів понад залишок — це ціль рівня обслуговування (SLO) з алертом, а не\n  надія.\n- **Влаштуйте гонку навмисно.** Десять тисяч одночасних покупців на сто\n  одиниць, у тестах, з перевіркою: продано рівно сто і жодного числа нижче\n  нуля.\n- **Ламайте все під час гонки.** Вбийте основну базу, розріжте мережу,\n  призупиніть процес — у дусі Jepsen — і перевірте інваріант після цього.\n- **Перевірте відмови під навантаженням.** Шлях «розпродано» мусить лишатися\n  швидким, коли це 99% трафіку, і периферія мережі (edge) мусить його\n  витримати.\n- **Зберіть метрики на одній панелі:** очікування блокувань, резерви, що\n  спливли, і розрив між числом шлюзу та числом бази.\n\n## У якому порядку\n\n1. Спершу виміряйте. `pg_stat_statements` і очікування блокувань покажуть, чи\n   проблема взагалі в гарячому рядку.\n2. Зробіть запис однією умовною інструкцією.\n3. Скиньте навантаження: зала очікування, шлюз, закешоване «розпродано».\n4. Дайте запасу власний сервіс і власного власника.\n5. Шардуйте за `(tenant_id, item_id)`, і лише якщо перших чотирьох замало.\n6. Додайте режим гарячого товару, сегменти чи один записувач, для розпродажу,\n   про який ви знаєте заздалегідь.\n7. Регіони — наостанок, із квотами.\n\n## Що ми порадили б тим, хто йде слідом\n\n- **Шардування відповідає на інше питання.** Воно розносить багато рядків, а\n  розпродаж, що продав більше, ніж мав, — це один рядок. З'ясуйте, що з цього у\n  вас, перш ніж будувати.\n- **Зробіть перевірку і списання однією інструкцією.** Більша частина відстані\n  між «усе гаразд» і «продано більше, ніж є» — це час між читанням числа і його\n  записом.\n- **Більша частина трафіку — це відповідь «ні».** Зробіть відмову найдешевшою\n  операцією системи.\n- **Краще пауза, ніж продаж понад залишок.** Товар, що на тридцять секунд\n  перестав продаватися, — це вибачення. Товар, проданий двічі, — це повернення\n  коштів, черга в підтримці й клієнт, який запам'ятає.\n- **Запишіть інваріант і стежте за ним.** Це один рядок, і лише він показує,\n  що дизайн працює в продакшні, а не тільки на рев'ю.\n\n## Джерела\n\n- [PostgreSQL: ізоляція Read Committed](https://www.postgresql.org/docs/current/transaction-iso.html#XACT-READ-COMMITTED)\n- [PostgreSQL: `FOR UPDATE` і `SKIP LOCKED`](https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE)\n- [PostgreSQL: синхронна реплікація](https://www.postgresql.org/docs/current/warm-standby.html#SYNCHRONOUS-REPLICATION)\n- [Bailis et al., Coordination Avoidance in Database Systems](https://www.vldb.org/pvldb/vol8/p185-bailis.pdf)\n- [Balegas et al., Extending Eventually Consistent Cloud Databases for Enforcing Numeric Invariants](https://arxiv.org/abs/1503.09052)\n- [Martin Kleppmann: How to do distributed locking](https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html)\n- [Martin Fowler: The LMAX Architecture](https://martinfowler.com/articles/lmax.html)\n- [DynamoDB: проєктування ключів розділу](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-design.html)\n- [DynamoDB: розділи й розподіл даних](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.Partitions.html)\n- [microservices.io: Saga](https://microservices.io/patterns/data/saga.html)\n- [microservices.io: Transactional outbox](https://microservices.io/patterns/data/transactional-outbox.html)\n- [Redis: реплікація](https://redis.io/docs/latest/operate/oss_and_stack/management/replication/)\n- [Jepsen](https://jepsen.io/)\n\n\u003chttps://engineer.company/uk/notes/selling-limited-stock-without-overselling/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Флеш-розпродаж продає більше, ніж є на складі, через один гарячий рядок, а не через завелику базу. Це зупиняють умовний запис, резерви з терміном дії і сага.","formats":{"gemtext":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/index.gmi","gopher":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/gophermap","html":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/","json":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/index.json","markdown":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/index.md","pdf":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/index.pdf"},"kind":"page","language":"uk","title":"Продати останній квиток рівно один раз","url":"https://platform.engineer.company/uk/notes/selling-limited-stock-without-overselling/","version":1}