Системный дизайн системы метрик и алертинга: pull и push, TSDB, downsampling, кардинальность

Как спроектировать систему мониторинга вроде Prometheus и Grafana на system design интервью: pull против push, устройство TSDB, сжатие, downsampling, кардинальность меток и алерты.

12 мин чтениясистемный дизайн · распределённые системы · python · собеседования

Коротко

ВопросРешение в этом разборе
Нагрузка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 с → 107/15≈67010^7 / 15 \approx 670 тыс. точек в секунду;
  • точка после сжатия около 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...

Если наивно вычесть первое значение из последнего, получится (70−100)/60<0(70 - 100) / 60 < 0. Обработка сброса — частый вопрос на интервью.

Сбор: pull против push

Это центральная развилка, и тут нет правильного ответа, есть компромиссы.

Pull (Prometheus): сервис отдаёт текущие значения по HTTP на /metrics, сборщик сам ходит по списку целей. Список берётся из service discovery: Kubernetes, Consul, облачный API.

Push (Graphite, StatsD, InfluxDB, OpenTelemetry по OTLP): сервис сам отправляет точки на коллектор.

КритерийPullPush
Сервис упалсразу видно: сбор не удался, метрика up = 0тишина неотличима от «нечего сообщить»
Кто управляет нагрузкойсборщик: интервал и число целей в его рукахклиенты: тысяча сервисов может завалить коллектор
Короткие задачи (cron)задача может умереть раньше, чем до неё дойдёт сборотправила результат и завершилась
Сеть, NAT, мобильныесборщику нужен доступ к каждой целиклиенту нужен доступ к одному адресу
Отладкаоткрыл /metrics в браузере и видишь то же, что сборнужно смотреть уже в хранилище

На интервью хороший ответ — гибрид. Основной путь pull, потому что он даёт контроль нагрузки и бесплатный health check. Для коротких задач — шлюз (как Pushgateway): задача пушит в него, а сборщик забирает у шлюза. Для устройств за NAT и других регионов — агенты, которые собирают локально и пушат в центр (так работает remote write в Prometheus и агенты вроде Grafana Agent / Alloy).

Масштабируется pull шардированием целей: каждый сборщик забирает свою долю по хешу адреса, распределение — через консистентное хеширование. Для надёжности ставят два одинаковых сборщика на одни и те же цели: данные дублируются, а дедупликация делается при чтении.

Хранилище: почему не обычная БД

Профиль нагрузки у метрик особенный:

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

Строка в PostgreSQL на точку — это десятки байт плюс индекс, на 670 тыс. вставок в секунду реляционная база задохнётся. Поэтому строят специализированную TSDB. Схема похожа на LSM-дерево:

  1. Head block. Свежие точки копятся в памяти, сгруппированные по рядам. Каждая запись сначала идёт в журнал предзаписи, чтобы пережить падение.
  2. Блоки. Раз в 2 часа head сбрасывается на диск в неизменяемый блок: сжатые чанки точек и инвертированный индекс.
  3. Компакция. Мелкие блоки сливаются в крупные (до дней), заодно удаляются ряды и данные за пределами срока хранения.

Инвертированный индекс

Запрос 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)), и внешний сервис, который поднимает тревогу, если этот алерт перестал приходить. Плюс мониторинг размещают отдельно от прода: другой кластер, по возможности другой регион.

Итоговая архитектура

  1. Сервисы отдают /metrics; короткие задачи пушат в шлюз; удалённые площадки пушат через агентов.
  2. Сборщики — шардированы по целям, по два на шард; service discovery даёт список целей.
  3. Локальная TSDB в каждом сборщике: head в памяти + WAL, блоки по 2 часа, последние часы на диске.
  4. Объектное хранилище для блоков; компактор сливает блоки и делает downsampling.
  5. Слой запросов читает свежее и старое, дедуплицирует реплики, кеширует и режет запросы по времени.
  6. Вычислитель правил — recording и alerting rules; менеджер алертов в кластере.
  7. Grafana или аналог для дашбордов поверх слоя запросов.

Масштабирование по каждому слою независимое: больше целей — больше шардов сборщиков; больше истории — дешёвое объектное хранилище; больше пользователей дашбордов — реплики слоя запросов и кеш. Про общие приёмы читайте в статье о шардировании и репликации.

Типичные ошибки на интервью

  • Взять обычную БД и не объяснить, почему поток мелких вставок с упорядоченным временем требует другой структуры.
  • Хранить «запросы в секунду» вместо счётчика и терять события между сборами.
  • Усреднять перцентили при downsampling или хранить только среднее.
  • Не заметить кардинальность и разрешить произвольные метки.
  • Слать уведомление на каждый алерт без группировки и подавления.
  • Мониторить мониторинг тем же мониторингом без внешнего dead man's switch.
  • Выбрать pull или push догматически, не назвав сценарии, где второй вариант лучше.

Вопросы для самопроверки

  1. Почему при pull-модели падение сервиса видно сразу, а при push нет?
  2. Зачем хранить при downsampling min и max, если есть среднее?
  3. Как посчитать p99 за час, если в хранилище остались только пятиминутные агрегаты?
  4. Во сколько раз вырастет число рядов, если добавить метку region с 5 значениями?
  5. Почему алерт с for: 5m может сработать позже чем через 5 минут после начала проблемы?

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

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

Все задачи