Системный дизайн видеохостинга: загрузка, транскодирование, HLS и adaptive bitrate
Как спроектировать видеохостинг вроде YouTube на system design интервью: загрузка, транскодирование в лесенку битрейтов, HLS и DASH, adaptive bitrate, CDN, счётчики просмотров.
Коротко
| Вопрос | Решение в этом разборе |
|---|---|
| Нагрузка | около 12 тыс. просмотров в секунду, но главное — 10+ Тбит/с исходящего видео |
| Загрузка | напрямую в объектное хранилище по presigned URL, частями и с докачкой |
| Обработка | очередь → нарезка на куски → параллельное транскодирование в 5–6 качеств |
| Формат отдачи | HLS или DASH: сегменты по 4–6 секунд и плейлист со всеми качествами |
| Выбор качества | делает плеер, а не сервер: по скорости канала и заполненности буфера |
| Отдача | CDN с почти 100% попаданий для популярного, origin shield для длинного хвоста |
| Счётчики просмотров | события в очередь, агрегация пачками, шардированные счётчики |
Видеохостинг — удобная задача для интервьюера. Метаданные здесь простые: таблица видео, таблица пользователей, лайки. Сложность в другом — в объёме байтов. Кандидат, который начинает с выбора между PostgreSQL и Cassandra, тратит время не на то. Кандидат, который сразу говорит «видео отдаёт CDN, а мы думаем, как его туда положить и в каком виде», попадает в суть.
Общий порядок секции описан в статье про подходы к проектированию систем. Здесь он применён к видеохостингу целиком.
Шаг 1. Требования
| Вопрос | Ответ интервьюера | Что это меняет |
|---|---|---|
| Только VOD или ещё прямые трансляции? | только загруженные видео (VOD) | можно транскодировать заранее, а не на лету |
| Какие клиенты? | браузер, iOS, Android, Smart TV | нужны HLS для Apple и широкий набор качеств |
| Максимальный размер файла? | до 256 ГБ, до 12 часов | загрузка частями, докачка после обрыва |
| Как быстро видео становится доступным? | минуты после загрузки | транскодирование параллельно, а не одним процессом |
| Глобальная аудитория? | да | CDN обязательна, считаем трафик по регионам |
| Нужны рекомендации, комментарии? | нет, упомяни, где они были бы | фокус на конвейере видео и отдаче |
Нефункциональные требования:
- Старт воспроизведения быстрый: первый кадр меньше чем за 2 секунды на нормальном канале.
- Минимум пауз на буферизацию. Лучше показать 480p без остановок, чем 1080p с крутящимся кольцом.
- Загруженное видео не теряется никогда. Исходник храним с репликацией.
- Счётчик просмотров может отставать на минуты, но не должен накручиваться перезагрузкой страницы.
Шаг 2. Оценка нагрузки
Методика расчётов «на салфетке» подробно разобрана в отдельной статье. Допущения:
- 200 млн активных пользователей в день, каждый смотрит 5 видео.
- Средний просмотр длится 6 минут, средний отдаваемый битрейт — 2,5 Мбит/с.
- Загружают 500 часов видео в минуту. Это часто цитируемая публичная цифра YouTube; на интервью её можно назвать, но лучше уточнить у интервьюера.
- Исходник в среднем 10 Мбит/с, лесенка качеств в сумме — около 17 Мбит/с.
Считаем кодом, чтобы не ошибиться в нулях:
DAU = 200_000_000 VIEWS_PER_USER = 5 # просмотров в день AVG_WATCH_MIN = 6 # минут на просмотр AVG_BITRATE_MBPS = 2.5 # средний битрейт, который реально отдаём UPLOAD_HOURS_PER_MIN = 500 # часов видео загружают в минуту LADDER_MBPS = [0.4, 0.8, 1.5, 3, 4.5, 7] # 240p … 1080p, без исходника SOURCE_MBPS = 10 views_per_sec = DAU * VIEWS_PER_USER / 86_400 egress_tbps = DAU * VIEWS_PER_USER * AVG_WATCH_MIN * 60 * AVG_BITRATE_MBPS / 86_400 / 1e6 upload_hours_day = UPLOAD_HOURS_PER_MIN * 60 * 24 mb_per_hour = lambda mbps: mbps * 3600 / 8 source_pb_day = upload_hours_day * mb_per_hour(SOURCE_MBPS) / 1e9 ladder_pb_day = upload_hours_day * mb_per_hour(sum(LADDER_MBPS)) / 1e9 print(f"просмотров в секунду: {views_per_sec:,.0f}") print(f"исходящий трафик, среднее: {egress_tbps:.0f} Тбит/с") print(f"часов видео в сутки: {upload_hours_day:,}") print(f"исходники: {source_pb_day:.2f} ПБ/сутки") print(f"лесенка: {ladder_pb_day:.2f} ПБ/сутки") print(f"всё за год: {(source_pb_day + ladder_pb_day) * 365:.0f} ПБ")
просмотров в секунду: 11,574 исходящий трафик, среднее: 10 Тбит/с часов видео в сутки: 720,000 исходники: 3.24 ПБ/сутки лесенка: 5.57 ПБ/сутки всё за год: 3217 ПБ
Выводы, которые стоит проговорить вслух:
- 12 тыс. запросов метаданных в секунду — это мелочь. С ней справится реплицированная база с кэшем. Не тратьте на неё половину интервью.
- 10 Тбит/с в среднем и 20–30 Тбит/с в пик не отдаст ни один дата-центр. Без CDN задача не решается, и это первый архитектурный вывод.
- Около 3 эксабайт в год. Это объектное хранилище с erasure coding, а не диски на серверах. Сразу возникает вопрос, что хранить в горячем классе, а что переносить в холодный.
- Лесенка весит больше исходника. Поэтому редкие видео иногда не кодируют во все качества заранее: 1080p и выше делают, только когда видео начинают смотреть.
Шаг 3. Архитектура верхнего уровня
┌────────────┐ presigned URL ┌───────────────────┐ клиент ──────► │ Upload API │ ───────────────► │ объектное хранилище│ │ └─────┬──────┘ │ (исходники) │ │ части файла │ запись в БД └─────────┬─────────┘ └─────────────────┼───────────────────────────────────┘ ▼ │ событие «файл собран» ┌────────────┐ ▼ │ Metadata DB│ ◄── статусы ── ┌──────────────────────┐ └─────┬──────┘ │ очередь → транскодеры│ │ └──────────┬───────────┘ │ ▼ плеер ──► API (метаданные, URL плейлиста) ┌──────────────────────┐ │ │ хранилище сегментов │ └────────► CDN ── промах ──► shield ────► │ (HLS/DASH, origin) │ └──────────────────────┘
Два независимых пути:
- Путь записи — загрузка, обработка, публикация. Он асинхронный, и задержка в минуты здесь допустима.
- Путь чтения — плеер берёт метаданные у API, а все байты видео тянет с CDN. Сервисы компании видеопоток вообще не трогают.
Это разделение — главное, что интервьюер хочет увидеть на диаграмме.
Шаг 4. Загрузка
Почему не через свой сервер
Наивный вариант: клиент шлёт файл POST-запросом на API, API кладёт его в хранилище. Для файла на 20 ГБ это плохо:
- Каждый байт проходит через ваши серверы дважды: вход и выход к хранилищу.
- Соединение держится час, и его обрыв на 95% означает «начни сначала».
- Балансировщики и прокси обычно ограничивают размер и длительность запроса.
Presigned URL и загрузка частями
Правильный вариант:
- Клиент вызывает
POST /videosс названием и размером файла. API создаёт запись со статусомuploadingи начинает multipart-загрузку в объектном хранилище. - API возвращает
video_idи набор подписанных URL — по одному на часть файла. Подпись ограничена временем и конкретным объектом. - Клиент загружает части напрямую в хранилище, параллельно, по несколько штук.
- Оборвалась связь — клиент спрашивает, какие части уже приняты, и догружает остальные.
- Клиент вызывает
POST /videos/{id}/complete, хранилище собирает объект, API меняет статус наprocessingи публикует событие в очередь.
В S3 это называется multipart upload: часть не меньше 5 МБ (кроме последней), не больше 10 000 частей. Есть и открытый протокол докачки tus. На интервью название не важно, важна идея: байты идут мимо вашего API, загрузка возобновляемая, части идемпотентны. Повторная отправка той же части с тем же номером просто перезаписывает её — подробнее о таких операциях в статье про идемпотентность.
Дедупликация
Один и тот же ролик загружают тысячи раз. Можно считать хеш исходника и не обрабатывать файл повторно, если такой уже есть. Но побайтовое совпадение ловит только точные копии. Перекодированный или обрезанный ролик даст другой хеш, и для него нужен перцептивный отпечаток (fingerprint) — это уже отдельная система вроде Content ID.
Шаг 5. Транскодирование
Зачем перекодировать
Исходник может прийти в любом контейнере и кодеке, с переменной частотой кадров, на 50 Мбит/с. Отдавать его как есть нельзя:
- Телефон в метро не вытянет 50 Мбит/с.
- Не каждый браузер декодирует ProRes или HEVC.
- Перемотка по исходнику без регулярных ключевых кадров работает плохо.
Поэтому каждое видео превращают в лесенку битрейтов (bitrate ladder): несколько версий одного ролика в разных разрешениях и битрейтах.
| Качество | Разрешение | Битрейт H.264, ориентир |
|---|---|---|
| 240p | 426×240 | 0,4 Мбит/с |
| 360p | 640×360 | 0,8 Мбит/с |
| 480p | 854×480 | 1,5 Мбит/с |
| 720p | 1280×720 | 3 Мбит/с |
| 1080p | 1920×1080 | 4,5–7 Мбит/с |
Цифры ориентировочные. Netflix ещё в 2015 году рассказывал про per-title encoding: мультфильму с плоскими заливками хватает меньшего битрейта, чем боевику с дождём и взрывами, поэтому лесенку подбирают под каждый ролик. Про это стоит упомянуть как про оптимизацию, а не как про базовое решение.
Кодеки — отдельный компромисс. H.264 декодируется везде, VP9 и AV1 при том же качестве дают файл заметно меньше, но кодируются дольше и не везде есть аппаратный декодер. Крупные платформы держат несколько кодеков и отдают тот, который поддерживает устройство.
Как это выглядит на практике
Вот команда ffmpeg, которая делает три качества и HLS-плейлист. Я прогнал её на 20-секундном тестовом ролике:
ffmpeg -i input.mp4 \ -filter_complex "[0:v]split=3[v1][v2][v3];[v1]scale=-2:1080[v1080];[v2]scale=-2:720[v720];[v3]scale=-2:360[v360]" \ -map "[v1080]" -c:v:0 libx264 -b:v:0 4500k -maxrate:v:0 4800k -bufsize:v:0 9000k \ -map "[v720]" -c:v:1 libx264 -b:v:1 2500k -maxrate:v:1 2700k -bufsize:v:1 5000k \ -map "[v360]" -c:v:2 libx264 -b:v:2 800k -maxrate:v:2 860k -bufsize:v:2 1600k \ -map a:0 -map a:0 -map a:0 -c:a aac -b:a 128k \ -g 60 -keyint_min 60 -sc_threshold 0 \ -f hls -hls_time 6 -hls_playlist_type vod \ -hls_segment_filename "out/%v/seg_%03d.ts" \ -master_pl_name master.m3u8 \ -var_stream_map "v:0,a:0 v:1,a:1 v:2,a:2" \ "out/%v/index.m3u8"
Самое важное здесь — строка -g 60 -keyint_min 60 -sc_threshold 0. Она ставит ключевой кадр ровно каждые 60 кадров (2 секунды при 30 fps) и запрещает лишние ключевые кадры на сменах сцены. Во всех качествах ключевые кадры оказываются в одних и тех же моментах, а значит, и границы сегментов совпадают. Только так плеер может переключиться с 720p на 360p посреди ролика без рывка.
Параллельная обработка
Часовой фильм одним процессом ffmpeg кодируется часами. Требование «доступно через минуты» так не выполнить. Решение — разрезать исходник по ключевым кадрам на куски по 10 секунд и кодировать каждую пару «кусок × качество» как отдельную задачу:
import math RENDITIONS = {"240p": 0.3, "360p": 0.5, "480p": 0.8, "720p": 1.5, "1080p": 3.0} # сколько секунд CPU нужно на секунду видео (порядок, не бенчмарк) def plan(duration_sec, chunk_sec=10): chunks = math.ceil(duration_sec / chunk_sec) tasks = [(c, r) for c in range(chunks) for r in RENDITIONS] cpu_sec = sum(RENDITIONS[r] * chunk_sec for _, r in tasks) longest = max(RENDITIONS.values()) * chunk_sec return chunks, len(tasks), cpu_sec, longest for minutes in (5, 60): chunks, n, cpu, longest = plan(minutes * 60) print(f"{minutes} мин: {chunks} кусков, {n} задач, " f"одним воркером {cpu / 60:.0f} мин, " f"параллельно ~{longest:.0f} с + склейка")
5 мин: 30 кусков, 150 задач, одним воркером 30 мин, параллельно ~30 с + склейка 60 мин: 360 кусков, 1800 задач, одним воркером 366 мин, параллельно ~30 с + склейка
Коэффициенты CPU здесь условные, смысл в форме зависимости: время обработки перестаёт зависеть от длины ролика и упирается в размер пула воркеров.
Конвейер удобно описать как DAG:
исходник ─► проверка (ffprobe) ─► нарезка ─┬─► 240p × N кусков ─┐ ├─► 360p × N кусков ─┤ ├─► … ├─► сборка плейлистов ─► статус ready ├─► 1080p × N кусков ─┤ └─► превью, субтитры ─┘
Что сказать про надёжность:
- Задачи берутся из очереди сообщений с подтверждением. Воркер упал — задача вернётся в очередь по таймауту видимости.
- Каждая задача идемпотентна: результат пишется по детерминированному пути
videos/{id}/{quality}/chunk_{n}, повторный запуск просто перезапишет файл. - Оркестратор хранит состояние DAG в базе: какие задачи готовы, сколько попыток. После трёх неудач видео получает статус
failed, а не висит вечно вprocessing. - Можно публиковать видео, как только готовы 360p и 720p. Остальные качества доезжают позже, и плейлист пересобирается.
- Транскодеры — самые дорогие машины в системе. Их держат в автомасштабируемом пуле, часто на прерываемых инстансах: задачу всё равно можно перезапустить.
Шаг 6. HLS, DASH и сегменты
Почему сегменты, а не один файл
Можно отдавать один MP4 по HTTP с Range-запросами. Это работает, но качество в таком варианте выбирается один раз и навсегда. Адаптивный стриминг устроен иначе: каждое качество порезано на короткие сегменты, и плеер решает, из какой лесенки взять следующий сегмент.
Вот что ffmpeg создал в примере выше. Главный плейлист перечисляет качества:
#EXTM3U #EXT-X-VERSION:3 #EXT-X-STREAM-INF:BANDWIDTH=5090800,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2" 0/index.m3u8 #EXT-X-STREAM-INF:BANDWIDTH=2890800,RESOLUTION=1280x720,CODECS="avc1.64001f,mp4a.40.2" 1/index.m3u8 #EXT-X-STREAM-INF:BANDWIDTH=1020800,RESOLUTION=640x360,CODECS="avc1.64001e,mp4a.40.2" 2/index.m3u8
Плейлист одного качества перечисляет сегменты:
#EXTM3U #EXT-X-VERSION:3 #EXT-X-TARGETDURATION:6 #EXT-X-MEDIA-SEQUENCE:0 #EXT-X-PLAYLIST-TYPE:VOD #EXTINF:6.000000, seg_000.ts #EXTINF:6.000000, seg_001.ts #EXTINF:6.000000, seg_002.ts #EXTINF:2.000000, seg_003.ts #EXT-X-ENDLIST
Для CDN это идеальный контент: обычные неизменяемые файлы по HTTP. Каждый сегмент можно кэшировать на год, ключ кэша — просто URL.
Перемотка тоже становится простой. Плеер складывает длительности из #EXTINF и бинарным поиском находит сегмент, в который попадает нужная секунда:
from bisect import bisect_right from itertools import accumulate durations = [6.0, 6.0, 6.0, 2.0] # #EXTINF из плейлиста выше starts = [0.0, *accumulate(durations)][:-1] # [0, 6, 12, 18] def segment_at(t): return bisect_right(starts, t) - 1 print([segment_at(t) for t in (0, 5.9, 6, 13.5, 19.9)]) # [0, 0, 1, 2, 3]
Это тот же бинарный поиск, что и в задачах на собеседованиях, только применённый к реальному протоколу.
HLS или DASH
| Свойство | HLS | MPEG-DASH |
|---|---|---|
| Автор | Apple, RFC 8216 | MPEG, стандарт ISO/IEC 23009-1 |
| Манифест | текстовый .m3u8 | XML .mpd |
| Сегменты | MPEG-TS или fMP4 | fMP4 (и другие) |
| Поддержка | нативно в Safari и iOS, в остальных — hls.js | через JS-плееры (dash.js, Shaka), не в Safari на iOS |
| Кодеки | любые, которые поддерживает устройство | не привязан к кодеку |
Ответ для интервью: не выбирать. С форматом CMAF сегменты в fMP4 одни и те же, а разные только манифесты. Храним одну копию сегментов и два маленьких текстовых файла.
Длина сегмента
Apple в рекомендациях по HLS называет ориентиром 6 секунд. Компромисс такой:
- Короткие сегменты (2 с) — плеер быстрее реагирует на смену канала и быстрее стартует. Зато запросов больше, а у кодека меньше простора для сжатия, ведь каждый сегмент начинается с ключевого кадра.
- Длинные сегменты (10 с) — меньше запросов к CDN, лучше сжатие, но переключение качества запаздывает, а старт медленнее.
Для VOD обычно выбирают 4–6 секунд. Для прямых трансляций с малой задержкой есть Low-Latency HLS, где сегмент дробится на части по сотни миллисекунд. На этом этапе интервью достаточно сказать, что такая вещь существует.
Шаг 7. Adaptive bitrate: как плеер выбирает качество
ABR — та часть, где можно показать глубину. Важная мысль: решение принимает клиент, потому что только он знает свой канал и свой буфер. Сервер просто отдаёт файлы.
Два сигнала:
- Пропускная способность. Сегмент 4 секунды при 3 Мбит/с весит 1,5 МБ. Скачался за 1 секунду — канал около 12 Мбит/с. Оценку сглаживают экспоненциальным средним, чтобы один быстрый сегмент не уронил всё в 1080p.
- Буфер. Сколько секунд видео уже скачано вперёд. Буфер толстый — можно рискнуть и поднять качество. Буфер тает — срочно вниз, иначе пауза.
Упрощённый плеер, который учитывает оба сигнала:
LADDER = [ # (название, битрейт в кбит/с) ("240p", 400), ("360p", 800), ("480p", 1500), ("720p", 3000), ("1080p", 4500), ] SEGMENT_SEC = 4 SAFETY = 0.8 # берём не больше 80% от оценки канала LOW_BUFFER = 8 # секунд: ниже — играем осторожно HIGH_BUFFER = 12 # секунд: выше — можно повышать качество def ewma(prev, sample, alpha=0.3): return sample if prev is None else alpha * sample + (1 - alpha) * prev def choose(throughput_kbps, buffer_sec, current): budget = throughput_kbps * SAFETY if buffer_sec < LOW_BUFFER: budget *= 0.5 # буфер тает: спасаемся от паузы best = 0 for i, (_, kbps) in enumerate(LADDER): if kbps <= budget: best = i if best > current + 1: best = current + 1 # вверх — по одной ступени за раз if best > current and buffer_sec < HIGH_BUFFER: best = current # повышаем, только когда буфер толстый return best def simulate(bandwidth_kbps): buffer_sec, estimate, level, stalls = 0.0, None, 0, 0.0 for t, bw in enumerate(bandwidth_kbps): name, kbps = LADDER[level] download_sec = kbps * SEGMENT_SEC / bw if t > 0 and download_sec > buffer_sec: stalls += download_sec - buffer_sec # плеер стоит и крутит спиннер buffer_sec = max(buffer_sec - download_sec, 0) + SEGMENT_SEC estimate = ewma(estimate, bw) print(f"{t:2} канал={bw:5} оценка={estimate:6.0f} " f"{name:>5} буфер={buffer_sec:4.1f}с") level = choose(estimate, buffer_sec, level) print(f"паузы: {stalls:.1f} с") simulate([6000] * 8 + [1200] * 6 + [6000] * 4)
0 канал= 6000 оценка= 6000 240p буфер= 4.0с 1 канал= 6000 оценка= 6000 240p буфер= 7.7с 2 канал= 6000 оценка= 6000 240p буфер=11.5с 3 канал= 6000 оценка= 6000 240p буфер=15.2с 4 канал= 6000 оценка= 6000 360p буфер=18.7с 5 канал= 6000 оценка= 6000 480p буфер=21.7с 6 канал= 6000 оценка= 6000 720p буфер=23.7с 7 канал= 6000 оценка= 6000 1080p буфер=24.7с 8 канал= 1200 оценка= 4560 1080p буфер=13.7с 9 канал= 1200 оценка= 3552 720p буфер= 7.7с 10 канал= 1200 оценка= 2846 360p буфер= 9.0с 11 канал= 1200 оценка= 2352 360p буфер=10.3с 12 канал= 1200 оценка= 2007 360p буфер=11.7с 13 канал= 1200 оценка= 1765 360p буфер=13.0с 14 канал= 6000 оценка= 3035 360p буфер=16.5с 15 канал= 6000 оценка= 3925 480p буфер=19.5с 16 канал= 6000 оценка= 4547 720p буфер=21.5с 17 канал= 6000 оценка= 4983 720p буфер=23.5с паузы: 0.0 с
Что видно из трассы:
- Старт с низкого качества. Первый кадр появляется быстро, потом плеер поднимается по ступеням. Поэтому ролик на YouTube первые секунды бывает мыльным.
- Канал упал в 5 раз, а пауз нет. Буфер за 24 секунды принял удар, пока оценка медленно сползала вниз. Сегмент 1080p на канале 1,2 Мбит/с качается 15 секунд, и без запаса плеер бы встал.
- Экспоненциальное среднее запаздывает. Если канал проседает до 900 кбит/с, этот же код ловит секундную паузу. Поэтому реальные плееры опираются на буфер сильнее: в dash.js, например, есть буферный алгоритм BOLA, а hls.js держит две скользящие оценки, быструю и медленную, и берёт меньшую.
На интервью этого уровня хватает с запасом. Главное — назвать оба сигнала и объяснить, почему наверх идут осторожно, а вниз сразу.
Шаг 8. CDN и хранилище
Как устроена сама CDN — edge, origin shield, Cache-Control — разобрано в статье про CDN. Для видео важны особенности.
Популярность распределена по степенному закону. Небольшая доля роликов собирает большую часть просмотров. Эти сегменты живут на каждом edge, и доля попаданий для них близка к 100%. Длинный хвост — миллионы роликов с десятком просмотров — промахивается почти всегда.
Что с этим делают:
- Origin shield. Промахи всех edge одного региона сходятся в один промежуточный кэш, и до хранилища доходит один запрос вместо сотни.
- Прогрев. Видео канала с миллионами подписчиков можно заранее разложить по edge сразу после публикации — тут уместен push вместо pull.
- Свои узлы у провайдеров. Крупнейшие платформы ставят кэширующие серверы прямо в сети интернет-провайдеров: у Netflix это Open Connect, у Google — Google Global Cache. Трафик не выходит за пределы сети провайдера, и это дешевле для обеих сторон.
- Не всё нужно в каждом качестве. Если ролик никто не смотрит в 4K, его 4K-сегменты не попадут в кэш, и это нормально.
Хранилище по классам. Исходник нужен для перекодирования в новый кодек, но читают его редко — холодный класс. Сегменты популярных видео — горячий класс. Ролик, который не смотрели год, можно перенести в более дешёвый класс или удалить у него редкие качества, оставив исходник.
Защита контента. Ссылки на сегменты подписываются токеном с коротким сроком жизни, чтобы плейлист нельзя было вставить на чужой сайт. Для платного контента добавляется DRM: Widevine, FairPlay, PlayReady. Это отдельный большой мир, на интервью достаточно его назвать.
Шаг 9. Метаданные и API
CREATE TABLE videos ( video_id BIGINT PRIMARY KEY, owner_id BIGINT NOT NULL, title TEXT NOT NULL, status TEXT NOT NULL, -- uploading | processing | ready | failed duration_sec INT, manifest_url TEXT, -- путь к master.m3u8 / .mpd created_at TIMESTAMPTZ NOT NULL ); CREATE TABLE video_renditions ( video_id BIGINT NOT NULL REFERENCES videos (video_id), quality TEXT NOT NULL, -- 360p, 720p, ... codec TEXT NOT NULL, -- h264, vp9, av1 status TEXT NOT NULL, PRIMARY KEY (video_id, quality, codec) );
POST /api/v1/videos → video_id + подписанные URL частей POST /api/v1/videos/{id}/complete → статус processing GET /api/v1/videos/{id} → метаданные, статус, URL манифеста POST /api/v1/videos/{id}/views → событие просмотра
Метаданные шардируются по video_id и активно кэшируются: страницу популярного ролика открывают миллионы раз, а меняется она редко. Подробнее о шардировании — в статье про шардирование и репликацию.
Шаг 10. Счётчики просмотров
Наивный вариант — UPDATE videos SET views = views + 1 на каждый просмотр. Он ломается сразу по трём причинам:
- Горячая строка. Вирусный ролик получает десятки тысяч просмотров в секунду, и все они бьются в одну строку с блокировкой.
- Накрутка. Перезагрузка страницы не должна считаться новым просмотром, а пятисекундный клик — тем более.
- Лишняя нагрузка на основную базу, которая нужна для чтения метаданных.
Правильная схема:
- Плеер отправляет событие, когда человек посмотрел больше порога (условно 30 секунд).
- События летят в очередь или лог (Kafka и аналоги). Это надёжно и выдерживает любые пики.
- Потребители агрегируют события в памяти и раз в несколько секунд пишут сумму за окно.
- Сам счётчик горячего видео разбит на несколько шардов-строк, а чтение их суммирует.
import random from collections import Counter, defaultdict SHARDS = 16 MIN_WATCH_SEC = 30 # меньше — не считаем просмотром class ViewCounter: def __init__(self): self.buffer = Counter() # локальный буфер в памяти сервиса self.seen = set() # (video, viewer, час): дедупликация self.store = defaultdict(int) # «база»: (video, shard) -> счётчик def track(self, video_id, viewer_id, watched_sec, hour): if watched_sec < MIN_WATCH_SEC: return key = (video_id, viewer_id, hour) if key in self.seen: # перезагрузка страницы — не новый просмотр return self.seen.add(key) self.buffer[video_id] += 1 def flush(self): # раз в несколько секунд: одна запись на видео вместо одной на просмотр for video_id, n in self.buffer.items(): shard = random.randrange(SHARDS) # горячее видео не упирается в одну строку self.store[(video_id, shard)] += n writes = len(self.buffer) self.buffer.clear() return writes def total(self, video_id): return sum(self.store[(video_id, s)] for s in range(SHARDS)) random.seed(1) vc = ViewCounter() events = 0 for _ in range(100_000): video = "hit" if random.random() < 0.7 else f"v{random.randrange(500)}" vc.track(video, random.randrange(50_000), random.randrange(0, 600), hour=0) events += 1 print("событий:", events, "записей в базу:", vc.flush()) print("просмотров у хита:", vc.total("hit"))
событий: 100000 записей в базу: 501 просмотров у хита: 36702
Сто тысяч событий превратились в 501 запись. Хит получил 70% событий, но после отсечки коротких и повторных просмотров засчитано около 37 тысяч.
В продакшене set для дедупликации, конечно, не живёт в памяти одного процесса. Это ключи с TTL в Redis или дедупликация в потоковой обработке по окну. Если нужно не точное число, а количество уникальных зрителей, подходит HyperLogLog: около 12 КБ на счётчик при ошибке меньше процента.
Отсюда же растёт задача «топ трендовых видео за час»: потоковый агрегатор держит счётчики по окнам и выбирает k самых больших. Это top-k frequent на куче, только в масштабе потока.
Узкие места и вопросы вглубь
| Вопрос интервьюера | Что ответить |
|---|---|
| Транскодеры не успевают после всплеска | очередь сглаживает пик, автомасштабирование пула, приоритет популярным каналам |
| Видео вышло вирусным за минуту | CDN и shield держат нагрузку; счётчики шардированы; метаданные в кэше |
| Как перейти на новый кодек? | фоновая перекодировка из исходника, сначала самые просматриваемые ролики |
| Как снизить стоимость хранения? | per-title encoding, холодные классы, удаление редких качеств у старых видео |
| Пользователь загрузил запрещённый контент | проверка в DAG до публикации, отпечатки известных нарушений |
| Как сделать прямые трансляции? | ingest по RTMP/SRT, транскодирование на лету, LL-HLS, задержка в секундах |
Типичные ошибки
- Начинать с базы метаданных. Она здесь самая простая. Сначала байты: объём, трафик, CDN.
- Пропускать видео через свои серверы приложений. И на загрузке, и на отдаче байты идут мимо API.
- Транскодировать одним процессом. Часовой ролик будет обрабатываться часами. Режем на куски и запускаем параллельно.
- Забывать про выравнивание ключевых кадров. Без него переключение качества даёт рывки, и интервьюер, который работал с видео, это заметит.
- Выбирать качество на сервере. Сервер не знает канал клиента. ABR — логика плеера.
- Считать просмотры инкрементом в основной базе. Горячая строка и накрутка. Нужны события, агрегация и шардированные счётчики.
- Не считать стоимость. Видео — самая дорогая по трафику и хранению система из классических задач. Слова «а это дорого, поэтому…» звучат на интервью как опыт.
Итог
Видеохостинг на интервью — это история про два конвейера. Конвейер записи принимает файл частями мимо API, режет его на куски, параллельно кодирует в лесенку качеств и раскладывает сегменты HLS/DASH в объектное хранилище. Конвейер чтения отдаёт эти сегменты через CDN, а плеер сам выбирает качество по каналу и буферу. Всё остальное — метаданные, счётчики, тренды — привычные задачи, которые решаются кэшем, очередью и агрегацией. Покажите, что понимаете, где здесь терабиты, и разговор пойдёт в нужную сторону.