Оценки на салфетке для system design интервью: QPS, хранилище, трафик и числа задержек

Как быстро оценить QPS, объём хранилища, трафик и число серверов на system design интервью: опорные числа, степени двойки, задержки, закон Литтла и четыре разобранных примера.

15 мин чтениясистемный дизайн · собеседования · масштабирование · python

Коротко

Что оценитьФормулаОпорное число
Средний QPSдействий в день / 10510^51 млн в день ≈ 12 в секунду
Пиковый QPSсредний × 2–3 (для событий ×10)—
Хранилищезаписей в день × размер × дни × реплики1 год ≈ 400 дней, если нужно быстро
ТрафикQPS × размер ответа × 81 Гбит/с = 125 МБ/с
ОдновременноQPS × время ответа (закон Литтла)10K QPS × 100 мс = 1000 запросов
  • Цель оценки — не точный ответ, а порядок величины: один сервер или сто, гигабайты или петабайты. От этого зависит архитектура.
  • Округляйте смело: 86 400≈10586\,400 \approx 10^5, 210≈1032^{10} \approx 10^3. Ошибка в 15% ничего не меняет, а считать становится в разы проще.
  • Записывайте допущения вслух и на доске. Интервьюер проверяет ход рассуждений, а не арифметику.
  • Каждое число должно привести к решению: «400 ГБ в день — значит, через год шардирование неизбежно».

Общий план system design интервью и место оценок в нём разобраны в статье о подходах к system design. Здесь — только сама техника счёта: какие числа держать в голове, как округлять и как это выглядит на реальных задачах.

Зачем считать, если всё равно приблизительно

На интервью оценка нужна, чтобы ответить на несколько вопросов, которые определяют дизайн:

  • Поместится ли в одну машину? Если данные — 50 ГБ, а нагрузка — 500 QPS, хватит одной базы с репликой, и шардирование будет оверинжинирингом.
  • Что узкое место — чтение, запись, диск или сеть? Сервис с соотношением чтения к записи 100:1 и сервис 1:1 проектируются по-разному.
  • Нужен ли кэш и сколько памяти он займёт?
  • Нужен ли CDN? Если исходящий трафик — десятки терабит в секунду, без него никак.

Отсюда главное правило: не считайте то, что не повлияет на решение. Если вы потратили пять минут на оценку трафика метаданных, а он в итоге составил 40 Мбит/с, это время можно было потратить на дизайн.

Опорные числа

Время

ВеличинаТочноНа салфетке
Секунд в сутках86 40010510^5
Секунд в месяце2 592 0002.5⋅1062.5 \cdot 10^6
Секунд в году31 536 0003⋅1073 \cdot 10^7

Из этого выводятся удобные пересчёты, которые стоит запомнить:

  • 1 млн событий в сутки ≈ 12 в секунду;
  • 100 млн в сутки ≈ 1 200 в секунду;
  • 1 млрд в сутки ≈ 12 000 в секунду.

Деление на 10510^5 вместо 86 400 даёт ошибку около 14% в меньшую сторону. Для оценки порядка это нормально. Если хочется точнее, то и на 86 400 можно разделить в уме, но не стоит.

Степени двойки и размеры

СтепеньТочноПримерноНазвание
2102^{10}1 024тысячаKB
2202^{20}1 048 576миллионMB
2302^{30}1 073 741 824миллиардGB
2402^{40}≈ 1.1⋅10121.1 \cdot 10^{12}триллионTB
2502^{50}≈ 1.13⋅10151.13 \cdot 10^{15}квадриллионPB

Несколько границ, которые всплывают в задачах:

  • 231−1≈2.12^{31} - 1 \approx 2.1 млрд — максимум знакового int32. Если генерировать 400 млн идентификаторов в сутки, такой счётчик переполнится примерно за 5 дней. Поэтому для ID берут int64.
  • 232≈4.32^{32} \approx 4.3 млрд — все адреса IPv4.
  • 264≈1.8⋅10192^{64} \approx 1.8 \cdot 10^{19} — пространство int64; на практике бесконечность.
  • 627≈3.5⋅101262^7 \approx 3.5 \cdot 10^{12} — количество коротких ссылок из 7 символов base62. Подробно этот расчёт есть в дизайне URL-сокращателя.

На салфетке все приставки десятичные: 1 KB = 1000 байт. Разница с двоичными на уровне ТБ — около 10%, она утонет в остальных допущениях.

Типичные размеры данных

ОбъектРазмер
int64, timestamp8 байт
UUID16 байт в бинарном виде, 36 символов строкой
Символ ASCII / кириллица в UTF-81 / 2 байта
Строка с метаданными (пост, заказ)0,5–1 KB вместе с индексами
Аватар или превью10–50 KB
Фото со смартфона после сжатия1–3 MB
Минута видео 1080p (≈ 5 Мбит/с)≈ 40 MB

Биты и байты

Пропускную способность сети меряют в битах, объёмы данных — в байтах. Это классическая ловушка: 1 Гбит/с — это 125 МБ/с, а не гигабайт. Если в расчёте объём превращается в трафик, умножьте на 8.

Задержки, которые стоит знать

Таблица «Latency Numbers Every Programmer Should Know» восходит к Джеффу Дину и Питеру Норвигу. Абсолютные значения с тех пор изменились, особенно для SSD и сети, поэтому ниже — порядки для современного железа. Запоминать нужно не цифры, а разрыв между строками.

ОперацияПорядок
Обращение к кэшу L1~1 нс
Обращение к кэшу L2~4 нс
Обращение к оперативной памяти~100 нс
Последовательное чтение 1 MB из памятидесятки мкс
Случайное чтение 4 KB с NVMe SSDдесятки мкс
Круг по сети внутри дата-центра0,1–0,5 мс
Последовательное чтение 1 MB с NVMe SSD~0,3 мс
Позиционирование головки HDD5–10 мс
Последовательное чтение 1 MB с HDD~5 мс
Круг между Европой и восточным побережьем США70–100 мс

Что из этого следует для дизайна:

  • Память в сотни раз быстрее диска и сети. Поэтому горячие данные держат в кэше, а не читают каждый раз из базы.
  • Поход в соседний сервис стоит сотни микросекунд. Сто последовательных запросов к базе в обработчике (классическая N+1) — это уже десятки миллисекунд.
  • Межконтинентальный круг стоит около 100 мс, и физику не обогнать. Если пользователи по всему миру, статику отдают через CDN, а данные реплицируют по регионам.
  • Случайный доступ на HDD — на порядки медленнее последовательного. Отсюда популярность журналов и LSM-деревьев, где запись идёт последовательно.

Сколько выдерживает одна машина

Эти числа сильно зависят от железа и нагрузки, поэтому на интервью их стоит произносить как допущение: «предположим, что...». Но порядок знать полезно:

КомпонентПорядок нагрузки на один узел
Stateless веб-сервер с простой логикойтысячи RPS
Реляционная БД, простые запросы по индексутысячи–десятки тысяч QPS
Redis, операции get/setсотни тысяч ops/s
Сетевая карта сервера10–100 Гбит/с
Оперативная память сервераот десятков ГБ до нескольких ТБ

Если оценка выходит «3 000 QPS на запись в одну базу», это ещё одна машина с запасом. Если 300 000 QPS — без шардирования или кэша не обойтись.

Закон Литтла: сколько запросов одновременно

Часто забывают, что QPS сам по себе не говорит, сколько ресурсов держит система. Это показывает закон Литтла:

L=λ⋅W,L = \lambda \cdot W,

где λ\lambda — поток запросов в секунду, WW — среднее время обработки, LL — сколько запросов находится в системе одновременно.

Пример: 10 000 QPS при времени ответа 100 мс дают 10 000⋅0.1=1 00010\,000 \cdot 0.1 = 1\,000 одновременных запросов. Если каждый держит соединение с базой, понадобится пул примерно на тысячу соединений, а это уже повод для пулера или кэша. Если время ответа вырастет до секунды из-за медленной зависимости, одновременных запросов станет 10 000 — так деградация одного сервиса съедает потоки у всех, кто его вызывает.

Калькулятор на Python

Считать на интервью нужно в уме и на доске, но при подготовке полезно сверить себя. Вот небольшой калькулятор, который делает все стандартные пересчёты:

DAY = 86_400 def human(n, unit=""): """1234567 -> '1.2 M'. Десятичные приставки: на салфетке 1 KB = 1000 байт.""" for suffix, size in (("P", 1e15), ("T", 1e12), ("G", 1e9), ("M", 1e6), ("K", 1e3)): if n >= size: return f"{n / size:.1f} {suffix}{unit}" return f"{n:.0f} {unit}".strip() def napkin(dau, writes_per_user, reads_per_user, write_bytes, read_bytes, years=5, replicas=3, peak=3, latency_s=0.1): writes_day = dau * writes_per_user reads_day = dau * reads_per_user write_qps = writes_day / DAY read_qps = reads_day / DAY peak_qps = (write_qps + read_qps) * peak return { "write QPS": human(write_qps), "read QPS": human(read_qps), "peak QPS": human(peak_qps), "in-flight (Little)": human(peak_qps * latency_s), "ingress": human(write_qps * write_bytes * 8, "bit/s"), "egress": human(read_qps * read_bytes * 8, "bit/s"), "storage/day": human(writes_day * write_bytes, "B"), f"storage {years}y x{replicas}": human(writes_day * write_bytes * 365 * years * replicas, "B"), } # Лента: 200M DAU, 2 поста и 10 открытий ленты в день, # пост ~1 KB, страница ленты — 20 постов ~20 KB for key, value in napkin(200e6, 2, 10, 1_000, 20_000).items(): print(f"{key:>20}: {value}")
write QPS: 4.6 K read QPS: 23.1 K peak QPS: 83.3 K in-flight (Little): 8.3 K ingress: 37.0 Mbit/s egress: 3.7 Gbit/s storage/day: 400.0 GB storage 5y x3: 2.2 PB

Ниже тот же пример разобран так, как его стоит проговаривать на интервью.

Пример 1. Лента коротких постов

Допущения (проговариваем и записываем):

  • 200 млн DAU;
  • пользователь публикует в среднем 2 поста в день и открывает ленту 10 раз;
  • пост с метаданными — около 1 KB, страница ленты — 20 постов, то есть 20 KB;
  • храним 5 лет, коэффициент репликации 3, пик в 3 раза выше среднего.

Запись. 200⋅106⋅2=4⋅108200 \cdot 10^6 \cdot 2 = 4 \cdot 10^8 постов в день. Делим на 10510^5 — около 4 000 QPS (точно — 4 600). В пике — порядка 12–14 тысяч.

Чтение. 200⋅106⋅10=2⋅109200 \cdot 10^6 \cdot 10 = 2 \cdot 10^9 открытий ленты в день, то есть около 20 000 QPS, в пике — 60–70 тысяч. Чтений в 5 раз больше записей, а по объёму данных — в 100 раз: каждое открытие ленты читает 20 постов.

Хранилище. 4⋅108⋅1 KB=4004 \cdot 10^8 \cdot 1\ \text{KB} = 400 ГБ в день. За год ≈ 150 ТБ, за 5 лет ≈ 730 ТБ, с тремя репликами ≈ 2,2 ПБ. Медиа в это не входят, их считают отдельно и кладут в объектное хранилище.

Трафик. Исходящий: 23 000 × 20 KB ≈ 460 МБ/с ≈ 3,7 Гбит/с в среднем, в пике около 11 Гбит/с. Входящий — смешные 37 Мбит/с.

Кэш. Посты за последние сутки — 400 ГБ. Если держать их в памяти, это 7–10 узлов Redis по 64 ГБ с запасом на накладные расходы.

Выводы для дизайна:

  • текстовые данные не помещаются на одну машину через год — нужно шардирование, например по автору;
  • читается в основном свежее — кэш ленты окупится;
  • 4 000 записей в секунду — это много для одной базы, но не экстремально; главная сложность в разветвлении записи по лентам подписчиков, а не в самой записи. Как с этим справляются, разобрано в дизайне ленты новостей;
  • int32 для ID поста переполнится за 5 дней.

Пример 2. Фотохостинг

Допущения: 500 млн DAU, 10% из них загружают одно фото в день, средний размер — 2 MB. Плюс превью в нескольких размерах — ещё примерно 20%.

Запись. 500⋅106⋅0.1=5⋅107500 \cdot 10^6 \cdot 0.1 = 5 \cdot 10^7 фото в день, это около 500–600 загрузок в секунду. Для метаданных в базе — ерунда.

Хранилище. 5⋅107⋅2 MB=1005 \cdot 10^7 \cdot 2\ \text{MB} = 100 ТБ в день. За год — 36,5 ПБ оригиналов, с превью около 44 ПБ. С тройной репликацией это уже за сотню петабайт в год, поэтому в объектных хранилищах используют erasure coding с избыточностью около 1,5× вместо трёх полных копий.

Входящий трафик. 580 × 2 MB ≈ 1,2 ГБ/с ≈ 9 Гбит/с в среднем. Одной сетевой карте это под силу, но загрузки распределяют по многим узлам.

Вывод: метаданные и сами фото — две разные системы. Метаданные — обычная шардированная база, байты — объектное хранилище за CDN. Нагрузка на запись в QPS скромная, а главная проблема — объём.

Пример 3. Видеостриминг

Допущения: в пике 10 млн одновременных зрителей, средний битрейт 5 Мбит/с.

Исходящий трафик. 107⋅5⋅106=5⋅101310^7 \cdot 5 \cdot 10^6 = 5 \cdot 10^{13} бит/с = 50 Тбит/с.

Даже если один сервер отдаёт 100 Гбит/с, нужно минимум 500 серверов, работающих на пределе, а реально — в несколько раз больше, с запасом и распределением по регионам. Это сразу показывает, что задача решается CDN и кэшами у провайдеров, а не «большим кластером в одном дата-центре». Здесь не понадобились QPS и хранилище: одного числа хватило, чтобы определить архитектуру.

Пример 4. Сколько серверов приложения

Допущения: пиковая нагрузка 80 000 QPS (из примера 1), среднее время ответа 100 мс, один сервер держит 2 000 RPS.

  • Серверов: 80 000/2 000=4080\,000 / 2\,000 = 40. С запасом на отказ зоны и деплой — 50–60.
  • Одновременно в обработке, по закону Литтла: 80 000⋅0.1=8 00080\,000 \cdot 0.1 = 8\,000 запросов, то есть около 200 на сервер.
  • Если каждый запрос ходит в базу, 8 000 одновременных соединений не выдержит ни одна СУБД. Значит, нужен пулер соединений и кэш перед базой.

Такая цепочка — от QPS к серверам, от серверов к соединениям, от соединений к архитектурному решению — и есть то, ради чего оценку просят на интервью.

Как это выглядит на интервью

  1. Спросите или предложите масштаб. «Сколько пользователей? Если не знаете, возьму 100 млн DAU». Не тратьте время на споры о точном числе.
  2. Запишите допущения столбиком. Интервьюер может поправить одно из них, и вы пересчитаете за секунды.
  3. Считайте в степенях десятки. 2⋅108⋅2/105=4⋅1032 \cdot 10^8 \cdot 2 / 10^5 = 4 \cdot 10^3 — проще и безопаснее, чем 400 000 000 / 86 400 в уме.
  4. Округляйте результат до одной значащей цифры. «Около 5 тысяч QPS», а не «4 629».
  5. Сразу делайте вывод. Каждое число должно заканчиваться фразой «значит...».
  6. Укладывайтесь в 3–5 минут. Оценка — вход в дизайн, а не отдельный этап на полчаса.

Полезный приём — проверка здравым смыслом. Если вышло, что сервис заметок на 10 млн пользователей хранит эксабайт, где-то потерялся множитель 10310^3. Сравните с известными величинами: жёсткий диск — десятки терабайт, сервер — сотни гигабайт памяти, крупный дата-центр — десятки тысяч серверов.

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

  • Путать биты и байты. Трафик в Гбит/с, объёмы в ГБ: множитель 8 теряют постоянно.
  • Считать только среднее. Системы проектируют под пик. Для вечерних часов берут ×2–3, а для распродаж и прямых трансляций — в разы больше.
  • Забыть про репликацию и индексы. Сырые данные × 3 реплики × 1,3 на индексы и служебные данные — это уже вчетверо больше исходной оценки.
  • Не разделять чтение и запись. От их соотношения зависит, нужен ли кэш, реплики для чтения или очередь для записи.
  • Ложная точность. «Нам нужно 37,4 сервера» звучит подозрительно. «Порядка сорока, возьмём с запасом» — нормально.
  • Считать то, что ни на что не влияет. Объём логов авторизации в задаче про ленту никого не интересует.
  • Молчать во время счёта. Если вы ошиблись на порядок, но проговаривали шаги, интервьюер поправит. Если считали молча, он увидит только неверный ответ.

Шпаргалка

  • 1 сутки≈1051\ \text{сутки} \approx 10^5 с, 1 год≈3⋅1071\ \text{год} \approx 3 \cdot 10^7 с.
  • 1 млн в сутки ≈ 12/с, 1 млрд в сутки ≈ 12 000/с.
  • 210≈1032^{10} \approx 10^3, 220≈1062^{20} \approx 10^6, 230≈1092^{30} \approx 10^9.
  • int32 ≈ 2 млрд — мало для ID, int64 — с запасом.
  • 1 Гбит/с = 125 МБ/с.
  • Память ~100 нс, круг в дата-центре ~0,5 мс, межконтинентальный круг ~100 мс.
  • Одновременных запросов = QPS × время ответа.
  • Пик = среднее × 2–3, хранилище × 3 на репликацию.

С этими числами любая задача из разряда «спроектируйте X» начинается с двух минут уверенного счёта, а не с паузы и попытки вспомнить, сколько секунд в сутках.

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

Все задачи