Системный дизайн системы метрик и алертинга: pull и push, TSDB, downsampling, кардинальность
Как спроектировать систему мониторинга вроде Prometheus и Grafana на system design интервью: pull против push, устройство TSDB, сжатие, downsampling, кардинальность меток и алерты.
Коротко
| Вопрос | Решение в этом разборе |
|---|---|
| Нагрузка | 10 млн активных рядов, сбор раз в 15 с, около 670 тыс. точек в секунду на запись |
| Модель данных | ряд = имя метрики + набор меток; точка = (время, float64) |
| Сбор | pull для сервисов с известными адресами, push через шлюз для коротких задач и edge-клиентов |
| Хранение | TSDB: запись в память + WAL, блоки по 2 часа, сжатие delta-of-delta и XOR ≈ 1–2 байта/точка |
| Долгое хранение | downsampling до 5 мин и 1 ч с min/max/sum/count, объектное хранилище |
| Главный враг | кардинальность: user_id в метке превращает тысячи рядов в миллиарды |
| Алерты | правила с for, отдельный менеджер: дедупликация, группировка, подавление, тишина |
«Спроектируйте мониторинг» звучит как задача про графики, но графики тут самая простая часть. Интервьюер ждёт, что вы увидите три вещи: огромный поток мелких записей, данные, которые почти никто не читает, но которые срочно нужны во время аварии, и систему, которая должна работать, когда всё остальное лежит. Ниже разбор по шагам, как его стоит вести на интервью.
Требования
Функциональные:
- сервисы отдают метрики: счётчики запросов, задержки, загрузку CPU, размер очередей;
- можно строить графики за произвольный период и агрегировать по меткам («p99 задержки по сервисам за сутки»);
- правила алертов проверяются постоянно, уведомления уходят в мессенджер, почту, систему дежурств.
Нефункциональные:
- запись не теряется при всплесках и не тормозит сами сервисы;
- запросы по свежим данным (последний час) отвечают за сотни миллисекунд, по старым — за секунды;
- мониторинг доступнее, чем то, что он мониторит. Если он падает вместе с продом, он бесполезен;
- хранение: сырые данные 2 недели, агрегаты — год и больше.
Чего мы не делаем: логи и трейсы. Это соседние системы со своими хранилищами, на интервью стоит явно сказать, что они вне рамок.
Оценка нагрузки
Прикинем по методике из статьи про оценки на салфетке:
- 10 тыс. машин и контейнеров, у каждого около 1000 рядов → 10 млн активных рядов;
- сбор раз в 15 с → тыс. точек в секунду;
- точка после сжатия около 1,5 байта → около 1 МБ/с, ≈ 86 ГБ в сутки;
- две недели сырых данных ≈ 1,2 ТБ. Немного для диска, но много для памяти.
Главный вывод: нагрузка — это не байты, а количество рядов и точек. Индексы, память и скорость запросов растут с числом рядов, поэтому дальше всё крутится вокруг него.
Модель данных
Ряд (time series) однозначно задаётся именем и метками:
http_requests_total{service="api", method="GET", status="200", instance="10.0.0.7:8080"}
Каждая уникальная комбинация меток — отдельный ряд со своей последовательностью точек (timestamp, value). Типы метрик:
| Тип | Что хранит | Пример |
|---|---|---|
| counter | только растёт, сбрасывается при рестарте | число запросов, байт отправлено |
| gauge | текущее значение, ходит вверх и вниз | память, длина очереди |
| histogram | счётчики по корзинам + сумма + количество | задержки запросов |
Важная деталь: сервис отдаёт не «запросов в секунду», а сырой счётчик. Скорость считается при запросе. Так не теряются события между сборами, а пропущенный сбор не портит график: следующая точка всё равно содержит полный итог.
Скорость по счётчику с учётом рестартов:
def rate(samples): """samples: [(ts, value)] счётчика; возвращает среднюю скорость в секунду.""" increase = 0.0 for (_, prev), (_, cur) in zip(samples, samples[1:]): # счётчик только растёт; падение значит рестарт процесса increase += cur - prev if cur >= prev else cur return increase / (samples[-1][0] - samples[0][0]) points = [(0, 100), (15, 160), (30, 220), (45, 10), (60, 70)] print(rate(points)) # 60 + 60 + 10 + 60 = 190 за 60 с -> 3.1666...
Если наивно вычесть первое значение из последнего, получится . Обработка сброса — частый вопрос на интервью.
Сбор: pull против push
Это центральная развилка, и тут нет правильного ответа, есть компромиссы.
Pull (Prometheus): сервис отдаёт текущие значения по HTTP на /metrics, сборщик сам ходит по списку целей. Список берётся из service discovery: Kubernetes, Consul, облачный API.
Push (Graphite, StatsD, InfluxDB, OpenTelemetry по OTLP): сервис сам отправляет точки на коллектор.
| Критерий | Pull | Push |
|---|---|---|
| Сервис упал | сразу видно: сбор не удался, метрика up = 0 | тишина неотличима от «нечего сообщить» |
| Кто управляет нагрузкой | сборщик: интервал и число целей в его руках | клиенты: тысяча сервисов может завалить коллектор |
| Короткие задачи (cron) | задача может умереть раньше, чем до неё дойдёт сбор | отправила результат и завершилась |
| Сеть, NAT, мобильные | сборщику нужен доступ к каждой цели | клиенту нужен доступ к одному адресу |
| Отладка | открыл /metrics в браузере и видишь то же, что сбор | нужно смотреть уже в хранилище |
На интервью хороший ответ — гибрид. Основной путь pull, потому что он даёт контроль нагрузки и бесплатный health check. Для коротких задач — шлюз (как Pushgateway): задача пушит в него, а сборщик забирает у шлюза. Для устройств за NAT и других регионов — агенты, которые собирают локально и пушат в центр (так работает remote write в Prometheus и агенты вроде Grafana Agent / Alloy).
Масштабируется pull шардированием целей: каждый сборщик забирает свою долю по хешу адреса, распределение — через консистентное хеширование. Для надёжности ставят два одинаковых сборщика на одни и те же цели: данные дублируются, а дедупликация делается при чтении.
Хранилище: почему не обычная БД
Профиль нагрузки у метрик особенный:
- записи почти только вставки в конец, и почти всегда «сейчас»;
- обновлений и удалений точек нет, удаляют целиком старые блоки;
- чтение — диапазоны по времени для множества рядов, отобранных по меткам;
- свежие данные читают в сотни раз чаще старых.
Строка в PostgreSQL на точку — это десятки байт плюс индекс, на 670 тыс. вставок в секунду реляционная база задохнётся. Поэтому строят специализированную TSDB. Схема похожа на LSM-дерево:
- Head block. Свежие точки копятся в памяти, сгруппированные по рядам. Каждая запись сначала идёт в журнал предзаписи, чтобы пережить падение.
- Блоки. Раз в 2 часа head сбрасывается на диск в неизменяемый блок: сжатые чанки точек и инвертированный индекс.
- Компакция. Мелкие блоки сливаются в крупные (до дней), заодно удаляются ряды и данные за пределами срока хранения.
Инвертированный индекс
Запрос http_requests_total{service="api", status="500"} должен быстро найти нужные ряды среди миллионов. Для каждой пары метка=значение хранится отсортированный список id рядов (posting list), как в поисковике. Запрос — пересечение списков, а пересечение отсортированных списков делается двумя указателями за линейное время. Найти начало нужного диапазона времени внутри ряда — бинарный поиск по отсортированным чанкам.
Сжатие: 16 байт в 1,5
Наивно точка — это 8 байт времени и 8 байт float64. Facebook в статье про Gorilla (2015) показал, как сжать её в среднем до 1,37 байта, Prometheus использует тот же подход.
Время: delta-of-delta. Сбор идёт с постоянным интервалом, поэтому разность разностей почти всегда ноль:
def delta_of_delta(ts): out = [ts[0], ts[1] - ts[0]] for i in range(2, len(ts)): out.append((ts[i] - ts[i - 1]) - (ts[i - 1] - ts[i - 2])) return out ts = [1700000000, 1700000015, 1700000030, 1700000045, 1700000061, 1700000075] print(delta_of_delta(ts)) # [1700000000, 15, 0, 0, 1, -2]
Ноль кодируется одним битом, небольшой джиттер — несколькими.
Значения: XOR с предыдущим. Соседние значения gauge близки, поэтому их битовые представления совпадают в старших битах (знак, экспонента, начало мантиссы). XOR даёт число с длинными нулями слева и справа, и хранить нужно только середину:
import struct def float_bits(v): return struct.unpack('>Q', struct.pack('>d', v))[0] def xor_widths(values): """Сколько «значимых» бит остаётся после XOR с предыдущим значением.""" widths = [] for prev, cur in zip(values, values[1:]): x = float_bits(prev) ^ float_bits(cur) if x == 0: widths.append(0) # значение не изменилось: пишем один бит continue leading = 64 - x.bit_length() trailing = (x & -x).bit_length() - 1 widths.append(64 - leading - trailing) return widths print(xor_widths([42.0, 42.0, 42.5, 42.5, 43.0, 43.0])) # [0, 1, 0, 2, 0]
Вместо 64 бит на значение — один бит, если оно не изменилось, и несколько бит плюс короткий заголовок, если изменилось. Шумные значения со случайной мантиссой сжимаются хуже, поэтому среднее и выходит «1–2 байта на точку», а не доли бита.
Downsampling и долгое хранение
Год сырых данных при 15-секундном сборе — это 2 млн точек на ряд. График за год шириной 1000 пикселей всё равно покажет одну точку на 2000 исходных. Поэтому старые данные прореживают: например, после 2 суток делают агрегаты по 5 минут, после 10 суток — по часу (такие пороги по умолчанию в Thanos).
Главная ошибка — хранить только среднее. Среднее прячет пики: пятисекундный всплеск задержки до 95 мс растворится в окне.
from collections import defaultdict def downsample(points, step): buckets = defaultdict( lambda: {'min': float('inf'), 'max': float('-inf'), 'sum': 0.0, 'count': 0} ) for ts, v in points: b = buckets[ts - ts % step] b['min'] = min(b['min'], v) b['max'] = max(b['max'], v) b['sum'] += v b['count'] += 1 return dict(sorted(buckets.items())) raw = [(0, 10), (15, 12), (30, 95), (45, 11), (60, 9), (75, 13), (90, 12), (105, 10)] for start, agg in downsample(raw, 60).items(): print(start, agg, 'avg =', agg['sum'] / agg['count']) # 0 {'min': 10, 'max': 95, 'sum': 128.0, 'count': 4} avg = 32.0 # 60 {'min': 9, 'max': 13, 'sum': 44.0, 'count': 4} avg = 11.0
Храним min, max, sum, count: из них восстанавливается среднее, а пик в 95 не теряется. Агрегаты пяти минут сливаются в часовые без доступа к сырым данным: минимум минимумов, сумма сумм.
Чего не восстановить: перцентили. p99 пяти пятиминуток — это не p99 часа, и усреднять перцентили нельзя. Поэтому задержки хранят гистограммой: счётчики корзин суммируются при любой агрегации, а перцентиль считается из суммарной гистограммы при запросе. Если интервьюер спросит про точность — упомяните скетчи (DDSketch, t-digest), это родственники Count-Min Sketch и HyperLogLog по духу: приблизительный ответ с гарантированной ошибкой за малую память.
Архитектура долгого хранения: сборщики держат последние часы локально, готовые блоки уходят в объектное хранилище (S3 и аналоги), отдельный компактор делает слияние и downsampling, слой запросов читает одновременно свежее из сборщиков и старое из хранилища. Так устроены Thanos, Cortex и Grafana Mimir; VictoriaMetrics решает ту же задачу своим кластерным режимом.
Кардинальность: главный враг
Число рядов одной метрики — произведение числа значений её меток:
from math import prod labels = {'service': 50, 'instance': 20, 'method': 8, 'status': 6, 'endpoint': 40} print(prod(labels.values())) # 1920000 рядов print(prod(labels.values()) * 12) # гистограмма: 10 корзин + _sum + _count = 23040000 labels['user_id'] = 100_000 print(f"{prod(labels.values()) * 12:,}") # 2,304,000,000,000
Это верхняя граница: реальные комбинации встречаются не все. Но порядок понятен — одна неудачная метка, и индекс перестаёт помещаться в память, сборщик падает по OOM, а вместе с ним пропадают все алерты.
Что делать:
- Правило на уровне команды: в метках только ограниченные множества.
user_id,request_id, email, полный URL с параметрами — в логи и трейсы, не в метрики. Вместо/users/12345— шаблон маршрута/users/:id. - Лимиты на приёме: максимум рядов на цель и на арендатора, при превышении сбор отклоняется целиком, а не по частям.
- Наблюдение за самим собой: метрики «топ метрик по числу рядов» и «новые ряды в минуту». Найти виновника — по сути задача Top K частых элементов.
- Churn: каждый деплой в Kubernetes меняет
podи создаёт новые ряды, старые висят до конца блока. Частые раскатки умножают кардинальность так же, как плохая метка.
На интервью этот раздел часто отличает уровень senior: мало сказать «будет много данных», нужно показать, откуда именно возьмётся взрыв.
Запросы
Язык запросов (PromQL, MetricsQL) делает три вещи: выбрать ряды по меткам, применить функцию по времени (rate за 5 минут), агрегировать по меткам (sum by (service)). Тяжёлые запросы дашбордов, которые обновляются каждые 30 секунд у сотни людей, заранее считают recording rules: результат записывается как новый ряд, а дашборд читает уже его.
Запросы по большим диапазонам распараллеливаются по времени: месяц режется на сутки, сутки считаются независимо, результаты кешируются (так делает фронтенд запросов в Mimir и Thanos). Суточный кусок за прошлую неделю уже не изменится — это идеальный кандидат для кеша.
Алертинг
Алерт — это запрос, который проверяется по расписанию, например раз в 30 секунд:
sum(rate(http_requests_total{status=~"5.."}[5m]))
/ sum(rate(http_requests_total[5m])) > 0.05
for: 2m
for защищает от дребезга: условие должно держаться 2 минуты подряд. Пока оно выполнено меньше этого срока, алерт в состоянии pending, потом переходит в firing:
class AlertRule: def __init__(self, threshold, for_seconds): self.threshold = threshold self.for_seconds = for_seconds self.active_since = None self.state = 'inactive' def evaluate(self, now, value): if value <= self.threshold: if self.state == 'firing': print(f'{now:>4}: resolved') self.active_since, self.state = None, 'inactive' elif self.active_since is None: self.active_since, self.state = now, 'pending' elif now - self.active_since >= self.for_seconds and self.state != 'firing': self.state = 'firing' print(f'{now:>4}: FIRING (порог превышен с {self.active_since})') return self.state rule = AlertRule(threshold=0.05, for_seconds=120) error_ratio = [0.01, 0.09, 0.02, 0.07, 0.08, 0.09, 0.08, 0.06, 0.01] for i, v in enumerate(error_ratio): print(f'{i * 30:>4}: {v:.2f} -> {rule.evaluate(i * 30, v)}')
Одиночный всплеск на 30-й секунде не дал алерта, а устойчивое превышение с 90-й секунды дошло до firing на 210-й. Цена — задержка: for плюс интервал проверки плюс окно rate. Это компромисс между ложными срабатываниями и скоростью реакции, его стоит проговорить вслух.
Менеджер уведомлений
Правила вычисляет одна часть системы, а рассылает другая (в Prometheus это Alertmanager). Причина — когда ломается база, срабатывают сотни алертов у сотни сервисов, и дежурному нужно одно сообщение, а не сотня. Задачи менеджера:
- дедупликация — два одинаковых сборщика прислали один и тот же алерт;
- группировка — алерты с одинаковыми
clusterиalertnameсобираются в одно уведомление с задержкой в десятки секунд; - подавление (inhibition) — если горит «дата-центр недоступен», алерты всех сервисов в нём не шлём;
- тишина (silence) — на время плановых работ алерты по меткам выключаются руками;
- маршрутизация и повторы — критичное в систему дежурств, остальное в чат; доставка с ретраями, как в системе уведомлений.
Менеджеры запускают в кластере из нескольких экземпляров, состояние (кто что уже отправил, какие тишины) они синхронизируют через gossip. Лучше отправить дубль, чем потерять алерт.
Кто сторожит сторожа
Мониторинг не может сообщить о собственной смерти. Стандартный приём — dead man's switch: правило, которое горит всегда (vector(1)), и внешний сервис, который поднимает тревогу, если этот алерт перестал приходить. Плюс мониторинг размещают отдельно от прода: другой кластер, по возможности другой регион.
Итоговая архитектура
- Сервисы отдают
/metrics; короткие задачи пушат в шлюз; удалённые площадки пушат через агентов. - Сборщики — шардированы по целям, по два на шард; service discovery даёт список целей.
- Локальная TSDB в каждом сборщике: head в памяти + WAL, блоки по 2 часа, последние часы на диске.
- Объектное хранилище для блоков; компактор сливает блоки и делает downsampling.
- Слой запросов читает свежее и старое, дедуплицирует реплики, кеширует и режет запросы по времени.
- Вычислитель правил — recording и alerting rules; менеджер алертов в кластере.
- Grafana или аналог для дашбордов поверх слоя запросов.
Масштабирование по каждому слою независимое: больше целей — больше шардов сборщиков; больше истории — дешёвое объектное хранилище; больше пользователей дашбордов — реплики слоя запросов и кеш. Про общие приёмы читайте в статье о шардировании и репликации.
Типичные ошибки на интервью
- Взять обычную БД и не объяснить, почему поток мелких вставок с упорядоченным временем требует другой структуры.
- Хранить «запросы в секунду» вместо счётчика и терять события между сборами.
- Усреднять перцентили при downsampling или хранить только среднее.
- Не заметить кардинальность и разрешить произвольные метки.
- Слать уведомление на каждый алерт без группировки и подавления.
- Мониторить мониторинг тем же мониторингом без внешнего dead man's switch.
- Выбрать pull или push догматически, не назвав сценарии, где второй вариант лучше.
Вопросы для самопроверки
- Почему при pull-модели падение сервиса видно сразу, а при push нет?
- Зачем хранить при downsampling
minиmax, если есть среднее? - Как посчитать p99 за час, если в хранилище остались только пятиминутные агрегаты?
- Во сколько раз вырастет число рядов, если добавить метку
regionс 5 значениями? - Почему алерт с
for: 5mможет сработать позже чем через 5 минут после начала проблемы?
Если на все пять отвечаете уверенно, к задаче про мониторинг вы готовы. Общий план, как разложить время на подобной задаче, есть в разборе подходов к system design интервью.