Системный дизайн бронирования билетов: резерв мест, конкурентность и очередь ожидания

Как спроектировать сервис продажи билетов уровня Ticketmaster: резерв места с TTL, защита от двойной продажи, оплата, карта зала, виртуальная очередь ожидания и пиковые продажи.

14 мин чтениясистемный дизайн · конкурентность · базы данных · python

Коротко

ВопросРешение в этом разборе
Главный инвариантОдно место продаётся ровно одному покупателю
Как держим местоВременный резерв с TTL (обычно 5–10 минут), пока человек платит
Как избегаем гонокАтомарный условный UPDATE ... WHERE status = 'free' в ACID-базе, без распределённых блокировок
Что делать с пикомВиртуальная очередь ожидания перед сайтом: пускаем столько, сколько выдержит бронирование
Что масштабируем отдельноКаталог и карту зала (чтение, кэш) и бронирование (запись, строгая согласованность)
  • Задача выглядит как CRUD, но интервьюер проверяет одно: как вы поведёте себя, когда 100 000 человек одновременно жмут на одно и то же место.
  • Резерв — это не блокировка в памяти, а состояние строки в базе со сроком годности. Просроченный резерв просто считается свободным, отдельный «уборщик» не обязателен.
  • Очередь ожидания нужна не для красоты: она превращает непредсказуемый всплеск в ровный поток, который база точно переварит.

Шаг 1. Требования

Начните с уточнений. Под «Ticketmaster» могут понимать что угодно — от кинотеатра до стадиона на 80 000 мест.

ВопросОтвет интервьюераЧто это меняет
Места с номерами или танцпол?и то, и другоедве модели инвентаря: конкретное место и счётчик
Можно выбрать место на схеме?да, плюс кнопка «лучшие доступные»нужна карта зала с почти актуальной занятостью
Сколько мест в одном заказе?до 6резерв нескольких мест должен быть атомарным
Сколько времени на оплату?10 минутTTL резерва, таймер на клиенте
Бывают продажи «на хайпе»?да, стадионные туры распродаются за часочередь ожидания, защита от ботов
Перепродажа, динамические цены?вне рамокне усложняем

Нефункциональные требования назовите сами:

  • Никакой двойной продажи. Это жёсткий инвариант: два человека с билетами на одно место у входа — инцидент.
  • Строгая согласованность для бронирования, eventual consistency для просмотра. Схема зала может отставать на пару секунд: максимум человек кликнет в место, которое уже заняли, и получит понятную ошибку.
  • Честность. Кто раньше пришёл, тот раньше выбирает. Боты не должны выкупать всё за секунды.
  • Доступность под пиком. Лучше показать «вы в очереди, ожидание 12 минут», чем отдать 502.

Шаг 2. Оценка нагрузки

Допущения для крупной площадки:

  • 50 000 событий в день по всей системе, в среднем 2 000 мест на событие.
  • Обычный день: 2 млн проданных билетов в сутки.
  • Горячее событие: стадион на 60 000 мест, на старт продаж пришли 2 млн человек.
ПараметрРасчётРезультат
Средний поток бронирований2 млн / 86 400около 25 в секунду
Строк в таблице мест в день50 000 × 2 000100 млн
Желающих на одно горячее место2 млн / 60 000больше 30
Запросов к карте зала на старте2 млн × обновление раз в 5 соколо 400 000 в секунду

Выводы:

  1. Средняя нагрузка смешная. Систему ломает не она, а несколько горячих событий в год.
  2. Чтение и запись несоизмеримы. Смотрят карту зала в тысячи раз чаще, чем бронируют. Их надо разделить.
  3. На одно место претендуют десятки людей. Значит, конфликты не редкость, а норма, и стратегия «попробовать и откатить» должна быть дешёвой.

Как прикидывать такие цифры, разобрано в статье про оценки на салфетке.

Шаг 3. API

GET /events?city=...&date=... — каталог, поиск GET /events/{id}/seatmap — схема зала и занятость POST /events/{id}/holds — зарезервировать места { "seats": ["A5", "A6"] } -> { "hold_id", "expires_at" } DELETE /holds/{hold_id} — отпустить резерв POST /holds/{hold_id}/checkout — перейти к оплате Idempotency-Key: <uuid> GET /orders/{id} — статус заказа и билеты

Резерв — отдельный ресурс со своим идентификатором и сроком годности. Это упрощает всё остальное: оплата ссылается на hold_id, таймер на клиенте показывает expires_at, повторный клик не создаёт второй резерв. Заголовок Idempotency-Key на оплате защищает от двойного списания при ретраях, подробнее — в статье об идемпотентности.

Шаг 4. Модель данных

Место в рамках события проходит через маленький конечный автомат:

free ──hold──> held ──pay──> sold ^ │ └──expire/cancel┘

Минимальная схема:

CREATE TABLE seats ( event_id BIGINT, seat_id TEXT, -- 'A5', 'сектор 12, ряд 3, место 7' status TEXT NOT NULL, -- free / held / sold holder TEXT, -- id резерва или пользователя hold_until TIMESTAMPTZ, version INT NOT NULL DEFAULT 0, PRIMARY KEY (event_id, seat_id) ); CREATE TABLE orders ( order_id UUID PRIMARY KEY, event_id BIGINT, user_id BIGINT, seats TEXT[], status TEXT, -- pending / paid / failed / refunded created_at TIMESTAMPTZ );

Строки мест создаются при публикации события: для зала на 2 000 мест это 2 000 строк. Для стадиона — 60 000, тоже нормально.

Танцпол без номеров устроен иначе: вместо строк мест — счётчик.

UPDATE ga_inventory SET available = available - :qty WHERE event_id = :id AND available >= :qty;

Если затронута одна строка — места есть. Но счётчик — это одна горячая строка, за которую бьются все. На пике её режут на несколько «вёдер» по 1 000 билетов и раздают покупателей по вёдрам.

Шаг 5. Резерв места: где возникает гонка

Наивный код выглядит так:

seat = db.query("SELECT status FROM seats WHERE ...") if seat.status == 'free': db.execute("UPDATE seats SET status = 'held' ...")

Между SELECT и UPDATE другой запрос успевает прочитать тот же free. Оба обновят строку, оба получат «успех», место продано дважды. Это классическая гонка check-then-act, и на интервью её ждут именно здесь.

Варианты решения:

ПодходКак работаетМинусы
SELECT ... FOR UPDATEстрока блокируется до конца транзакцииочередь из 30 ждущих транзакций на одной строке, долгие локи
Оптимистическая блокировка по versionUPDATE ... WHERE version = :v, при 0 строк — повторпри высокой конкуренции много пустых попыток
Условный UPDATE по статусуUPDATE ... WHERE status = 'free', проверка и запись — одно действиепочти нет; это и есть рекомендуемый вариант
Распределённая блокировка в RedisSET lock:seat NX PX, потом запись в базулишний компонент, проблемы с TTL и failover

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

Ниже рабочая модель на SQLite. 50 потоков одновременно пытаются занять место A5:

import sqlite3 import threading import time DB = 'tickets.db' def setup(): conn = sqlite3.connect(DB) conn.executescript(''' DROP TABLE IF EXISTS seats; CREATE TABLE seats ( event_id INTEGER, seat_id TEXT, status TEXT NOT NULL DEFAULT 'free', -- free / held / sold holder TEXT, hold_until REAL, version INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (event_id, seat_id) ); ''') conn.executemany( 'INSERT INTO seats (event_id, seat_id) VALUES (1, ?)', [(f'A{i}',) for i in range(1, 11)], ) conn.commit() conn.close() def hold_seat(conn, event_id, seat_id, user, ttl=600): now = time.time() # Атомарный условный UPDATE: место свободно или чужой резерв истёк cur = conn.execute( '''UPDATE seats SET status = 'held', holder = ?, hold_until = ?, version = version + 1 WHERE event_id = ? AND seat_id = ? AND (status = 'free' OR (status = 'held' AND hold_until < ?))''', (user, now + ttl, event_id, seat_id, now), ) conn.commit() return cur.rowcount == 1 def confirm(conn, event_id, seat_id, user): # Продаём, только если резерв всё ещё наш и не истёк cur = conn.execute( '''UPDATE seats SET status = 'sold' WHERE event_id = ? AND seat_id = ? AND status = 'held' AND holder = ? AND hold_until >= ?''', (event_id, seat_id, user, time.time()), ) conn.commit() return cur.rowcount == 1 setup() winners = [] lock = threading.Lock() def worker(user): conn = sqlite3.connect(DB, timeout=10) if hold_seat(conn, 1, 'A5', user): with lock: winners.append(user) conn.close() threads = [threading.Thread(target=worker, args=(f'user{i}',)) for i in range(50)] for t in threads: t.start() for t in threads: t.join() print('Резерв получили:', len(winners)) conn = sqlite3.connect(DB) print('Чужой confirm:', confirm(conn, 1, 'A5', 'intruder')) print('Свой confirm:', confirm(conn, 1, 'A5', winners[0])) # Резерв с истёкшим TTL перехватывается print('A6 user1:', hold_seat(conn, 1, 'A6', 'user1', ttl=-1)) print('A6 user2:', hold_seat(conn, 1, 'A6', 'user2')) print('A6 user1 confirm:', confirm(conn, 1, 'A6', 'user1'))

Вывод:

Резерв получили: 1 Чужой confirm: False Свой confirm: True A6 user1: True A6 user2: True A6 user1 confirm: False

Обратите внимание на последние три строки. user1 получил резерв, но его срок истёк, место перехватил user2, и попытка user1 подтвердить покупку отклонена. Проверка holder = ? AND hold_until >= ? в confirm обязательна: без неё опоздавший покупатель «продаст» себе место, которое уже принадлежит другому.

Несколько мест в одном заказе

Человек выбрал A5 и A6. Если A5 занять удалось, а A6 нет, резерв A5 надо отпустить. Проще всего сделать это одной транзакцией:

BEGIN; UPDATE seats SET status = 'held', holder = :hold_id, hold_until = now() + interval '10 minutes' WHERE event_id = :e AND seat_id = ANY(:seats) AND (status = 'free' OR hold_until < now()); -- если изменено строк меньше, чем len(:seats) — ROLLBACK, иначе COMMIT COMMIT;

Все места события лежат в одном шарде (шардируем по event_id), поэтому распределённая транзакция не нужна. Чтобы две транзакции, берущие пересекающиеся наборы мест, не попали в дедлок, места внутри запроса упорядочивают по seat_id.

Кнопка «лучшие доступные места»

Пользователю на танцпол не нужно выбирать, а на трибуну хочется сидеть рядом. Задача «найти kk свободных мест подряд в ряду» — это проход скользящим окном по ряду, O(n)O(n) на ряд:

def best_block(row, k): """Индекс начала первого блока из k подряд свободных мест или -1.""" run = 0 for i, seat in enumerate(row): run = run + 1 if seat == '.' else 0 if run == k: return i - k + 1 return -1 row = 'XX..X...XX....X' # X — занято, . — свободно print(best_block(row, 2)) # 2 print(best_block(row, 3)) # 5 print(best_block(row, 4)) # 10 print(best_block(row, 5)) # -1

В реальности ряды перебирают по убыванию «качества» (ближе к сцене и центру), а найденный блок сразу пытаются зарезервировать тем же условным UPDATE. Не получилось — кто-то успел раньше — ищем следующий.

Шаг 6. Истечение резерва

Резерв, за который не заплатили, должен вернуться в продажу. Есть три способа:

  1. Ленивое истечение. Просроченный held считается свободным прямо в условии UPDATE (как в коде выше). Ничего не надо запускать по расписанию, и место освобождается ровно в момент истечения.
  2. Фоновая уборка. Раз в минуту UPDATE seats SET status = 'free' WHERE status = 'held' AND hold_until < now(). Нужна, чтобы карта зала показывала правильную картину, а не «занято» на просроченных местах.
  3. Отложенные сообщения. При создании резерва в очередь кладут задачу «проверить через 10 минут». Удобно, если по истечении нужно ещё что-то сделать: отменить заказ, уведомить пользователя.

Хорошая комбинация — ленивое истечение для корректности плюс уборка для красоты карты. Тогда сбой уборщика не ломает продажи.

Часы. Время истечения считает база (now() на сервере БД), а не приложение. Иначе два сервера с расхождением часов в пару секунд по-разному решат, истёк ли резерв.

Резерв на сервере, таймер на клиенте. Таймер в браузере — только подсказка. Когда пользователь жмёт «оплатить» на 9:59, до сервера запрос дойдёт уже после истечения, и это нормально: ответ «время вышло, места снова в продаже» лучше, чем двойная продажа. Некоторые сервисы дают льготные 30–60 секунд, если оплата уже началась: hold_until продлевается при переходе в checkout.

Шаг 7. Оплата

Оплата — самый медленный и ненадёжный шаг. Внешний платёжный провайдер отвечает за секунды, а с 3-D Secure — за минуту. Держать транзакцию базы открытой всё это время нельзя.

Поэтому бронирование и оплата разделены:

  1. POST /holds/{id}/checkout создаёт заказ в статусе pending и продлевает резерв на время оплаты.
  2. Клиент платит через провайдера.
  3. Вебхук провайдера (или опрос статуса) переводит заказ в paid, места — в sold условным UPDATE с проверкой holder.
  4. Если места к этому моменту уже ушли (резерв истёк, а провайдер ответил через 20 минут), делаем автоматический возврат денег.

Это маленькая сага с компенсацией, про сам паттерн есть отдельная статья, а про устройство платежей — разбор платёжной системы. Вебхуки приходят повторно, поэтому их обработка тоже идемпотентна: повторный paid для уже оплаченного заказа ничего не меняет.

Билет выпускается после sold: генерируем уникальный штрихкод или QR, подписываем его, кладём в заказ и отправляем письмо асинхронно через очередь.

Шаг 8. Карта зала и каталог

Каталог (события, площадки, цены) — классическая read-heavy часть: реплики базы, поисковый индекс, CDN для картинок, кэш на минуты.

Карта зала сложнее: её занятость меняется каждую секунду. Решение — разделить статику и динамику:

  • Геометрия зала (секторы, ряды, координаты мест) не меняется и отдаётся с CDN.
  • Занятость — компактный битовый массив по местам события. 60 000 мест — это 60 000 бит, меньше 8 КБ. Его держат в Redis и отдают всем с кэшем на 1–2 секунды.
  • Обновления можно пушить через WebSocket или SSE, но на горячем событии проще и дешевле опрос раз в несколько секунд: подписка 2 млн соединений на одно событие — отдельная инженерная задача. Сравнение подходов — в статье WebSocket vs long polling.

Ключевая мысль, которую стоит проговорить: карта может врать, бронирование — нет. Источник истины — таблица seats, а кэш только помогает не кликать в заведомо занятые места.

Шаг 9. Виртуальная очередь ожидания

Теперь главное. В 10:00 открываются продажи стадионного тура, и приходят 2 млн человек. Если пустить всех сразу:

  • база бронирования получает сотни тысяч конфликтующих UPDATE в секунду на одни и те же 60 000 строк;
  • карта зала устаревает быстрее, чем обновляется, люди кликают в занятые места и повторяют попытки;
  • ретраи умножают нагрузку, сервис падает, а очередь из разочарованных людей — главный репутационный риск. Хрестоматийный пример — предпродажа The Eras Tour Тейлор Свифт в ноябре 2022 года, когда Ticketmaster не справился с наплывом покупателей.

Решение — комната ожидания (waiting room) перед бронированием:

Пользователь ──> Edge / CDN ──> Waiting room ──(пропуск)──> Сервис бронирования │ Redis: очередь, счётчик впущенных

Как она работает:

  1. До старта продаж все пришедшие попадают в «предбанник». В момент старта каждому присваивается случайная позиция: так честнее, чем по времени прихода, и бессмысленно держать открытыми 50 вкладок за час до старта.
  2. Позиции хранятся в Redis sorted set: ZADD queue:<event> <position> <user>. Позиция пользователя — ZRANK.
  3. Контроллер впуска с постоянной скоростью (например, 2 000 человек в минуту) выдаёт следующей пачке токен доступа: подписанный JWT с event_id, user_id и сроком жизни.
  4. Сервис бронирования принимает запросы только с валидным токеном. Проверка подписи без похода в базу стоит микросекунды.
  5. Клиент в очереди опрашивает свою позицию раз в 10–30 секунд, и ответы отдаются из Redis или даже кэшируются на edge.

Скорость впуска — главная ручка. Её подбирают не по тому, сколько выдержит сайт, а по тому, сколько людей реально успевают выбрать места: если впустить 50 000 человек на 60 000 мест, многие будут драться за лучшие сектора и упираться в конфликты. Часто впуск адаптивный: чем меньше осталось мест и чем больше активных сессий, тем медленнее. Когда места кончились — очередь честно сообщает «билетов нет», а не держит людей зря.

Это та же идея, что и ограничение частоты запросов, только с честным порядком: вместо 429 пользователь получает номер в очереди и время ожидания.

Шаг 10. Боты и перекупщики

Без защиты горячие билеты уходят скриптам за секунды. Слои защиты:

  • Лимит на аккаунт и карту: не больше 6 билетов на событие, проверка при оплате.
  • Верифицированные фанаты: регистрация заранее, отбор и персональные коды доступа на предпродажу.
  • Rate limiting по IP, аккаунту, устройству; капча при подозрительной активности.
  • Токен доступа привязан к сессии: его нельзя передать другому клиенту.
  • Короткий TTL резерва на горячих событиях: ботам невыгодно держать места «про запас».

Шаг 11. Масштабирование

  • Шардирование по event_id. Все места события в одном шарде, атомарный резерв нескольких мест остаётся локальной транзакцией. Подробнее — в статье о шардировании и репликации.
  • Горячий шард. Одно стадионное событие может перегрузить свой шард. Помогают очередь ожидания (главное) и вынос событий-хедлайнеров на выделенные узлы заранее: о старте продаж известно за недели.
  • Чтение с реплик для каталога и истории заказов, но не для проверки свободных мест перед резервом.
  • Redis вместо базы для резерва? Можно держать горячие места в Redis (SET seat:<e>:<s> <hold> NX EX 600) и синхронизировать с базой. Это быстрее, но появляются два источника истины и вопрос, что будет при failover Redis без синхронной репликации. Риски такого подхода хорошо видны на примере распределённых блокировок. На интервью лучше начать с базы и честно сказать, когда и зачем переходить на Redis.

Типичные ошибки

  • Check-then-act: SELECT статуса, потом UPDATE. Гонка гарантирована.
  • Резерв в памяти приложения. Перезапуск инстанса — и все резервы потеряны, а другой инстанс о них не знал с самого начала.
  • Нет проверки владельца при подтверждении. Истёкший резерв подтверждается и продаёт место, уже отданное другому.
  • Таймер только на клиенте. Сервер обязан сам знать hold_until.
  • Транзакция базы открыта на время оплаты. Локи держатся минутами, пропускная способность падает до нуля.
  • Карта зала читается из основной базы. Сотни тысяч запросов в секунду ложатся туда же, где идут резервы.
  • Нет плана на пик. Если вы не произнесли «очередь ожидания», интервьюер почти наверняка спросит сам.

Как рассказывать на собеседовании

  1. Требования: места с номерами и без, TTL резерва, лимит на заказ, ожидаемый пик. Сформулируйте инвариант: место продаётся один раз.
  2. Оценка: средняя нагрузка мала, проблема — горячие события; чтение на порядки больше записи.
  3. API и конечный автомат места free → held → sold.
  4. Конкурентность: покажите гонку check-then-act и решите её условным UPDATE. Упомяните FOR UPDATE и optimistic locking как альтернативы и почему они хуже.
  5. Истечение резерва, оплата как сага, идемпотентность вебхуков.
  6. Карта зала: статика на CDN, занятость в кэше, допустимая неточность.
  7. Очередь ожидания, токены доступа, защита от ботов.
  8. Шардирование по событию и что делать с горячим шардом.

Если на всё не хватает времени, приоритет такой: инвариант и условный UPDATE, затем TTL резерва, затем очередь ожидания. Эти три пункта и отличают продуманный ответ от схемы «клиент — сервер — база».

Потренироваться в спокойной обстановке

Все задачи