✻ Урок 8.5 · Тема 8: Наблюдаемость
Алерты и Alertmanager: правила, маршрутизация, runbook
Содержание урока
Как работать с кодом и когда идти дальше
Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:
- Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
- Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
- Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.
Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.
Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.
Зачем это нужно
Дашборд (страница с графиками в Grafana, её разберём в уроке 8.6) никто не смотрит в три часа ночи. Если сервис лежит, об этом должна узнать система, а не клиент, написавший в поддержку. Плохой алертинг (alerting, оповещение о проблемах) ломается в обе стороны: молчит при аварии или будит дежурного сотней одинаковых сообщений, после чего его начинают игнорировать. Это называют alert fatigue (усталость от алертов): человек, которого десять раз разбудили зря, на одиннадцатый раз не встанет.
Вот как выглядит плохой алертинг в телефоне дежурного, когда сервис «Заметки» упал в 03:10, а проверка срабатывает каждые 15 секунд:
03:12:45 Заметки недоступны
03:13:00 Заметки недоступны
03:13:15 Заметки недоступны
...
04:12:30 Заметки недоступны
за час: 240 одинаковых сообщений
Дежурный выключит звук на пятом сообщении и пропустит настоящее. Нужно, чтобы о сбое приходило одно сообщение, а как этого добиться, разберём в уроке.
Хороший алерт сообщает о боли пользователя, приходит один раз и содержит ссылку на runbook (раннбук, инструкцию «что делать, когда это сработало»). На работе ты будешь писать правила, настраивать маршрутизацию по срочности и разбирать два вечных вопроса: «почему меня не разбудило» и «почему разбудило зря».
Шаг проекта: в «Заметки» добавляются шесть алертов (alert, сообщение «условие нарушено»), Alertmanager (программа, которая принимает сработавшие алерты и решает, кому и как срочно написать), проверка правил юнит-тестом и runbook на каждый алерт. Подробно всё разберём ниже.
Что нужно знать
- Урок 8.1: наблюдаемость, SLI и SLO: алерт строится от SLO (цели по качеству сервиса) и симптомов (то, что видит пользователь: ошибки и медленные ответы), а не от загрузки процессора (CPU).
- Урок 8.2: Prometheus и /metrics: job
notes(группа целей опроса), метрикаup, файлprometheus.yml, томprom-data. - Урок 8.3: PromQL:
rate, доля ошибок,histogram_quantile, recording rules (сохранённые заранее выражения)notes:http_errors:ratio5mиnotes:http_latency:p95_5m. - Урок 8.4: blackbox и exporters: проба снаружи (
probe_success,probe_ssl_earliest_cert_expiry, jobblackbox-https),node_exporterи метрики диска. - Урок 4.6: Compose, nginx и TLS: файл
compose.yml, сервисы и сетьnotes-net, в которой контейнеры видят друг друга по имени. - Урок 1.4: процессы и сигналы: перечитывание конфигурации по сигналу SIGHUP.
- Если хочешь разобрать основы на другом стенде, см. Алерты в курсе «Мониторинг и SRE».
Картина целиком
Представь пожарную сигнализацию в офисе. Датчик дыма в каждой комнате сам ничего не решает: он только проверяет «дымно или нет». Отдельный пульт охраны собирает сигналы от всех датчиков. Если задымились сразу пять комнат из-за одного пожара, пульт не звонит пять раз, а говорит один раз: «горит второй этаж». Ночью пульт звонит охраннику, а днём про мелкую неисправность (сел аккумулятор датчика) пишет в общий чат. У охранника на стене висит инструкция: что делать при пожаре.
В нашей системе роли такие:
- датчик это правило оповещения в Prometheus: раз в 15 секунд оно проверяет условие;
- пульт это Alertmanager: принимает сработавшие сигналы, склеивает, решает, кому и как срочно сообщить;
- инструкция это runbook.
flowchart TD
APP["«Заметки»<br>/metrics"] -->|"каждые 15 с"| PR["Prometheus<br>собирает метрики"]
PR --> RU{"Правила alerts.yml:<br>условие держится дольше for?"}
RU -->|да| AM["Alertmanager принимает алерт<br>1. дедупликация<br>2. маршрут по severity<br>3. группировка<br>4. подавление и silence"]
AM -->|critical| PG["Получатель page<br>будит человека"]
AM -->|warning| TK["Получатель ticket<br>заводит задачу"]
PG --> RB["В сообщении ссылка на runbook"]
Сверху вниз читается весь путь: метрика, правило, Alertmanager, получатель и инструкция. Шаги внутри Alertmanager идут в том же порядке, что и в реальной работе: сначала маршрут, потом группировка, потом подавление и silence (заглушка: уведомления по выбранным меткам временно выключает человек), потом отправка. severity (серьёзность) это метка на алерте со значением critical или warning: по ней Alertmanager выбирает получателя. Сам Prometheus только решает, что условие нарушено, а кому и как об этом сказать, решает Alertmanager.
За урок ты разберёшь каждую стрелку: из чего состоит правило, почему у алерта три состояния, как Alertmanager решает, кому и сколько раз сообщить, как проверить всё это без настоящей аварии и что написать в инструкции, чтобы её мог выполнить сонный человек.
Теория
Зачем алерт и почему их легко сделать вредными
Метрики и дашборды отвечают на вопрос «что происходит», если ты на них смотришь. Но смотреть круглосуточно невозможно. Алерт (alert, оповещение) это автоматический вопрос к метрикам, который система задаёт сама, без человека: «сейчас плохо?». Если ответ «да», человеку отправляется сообщение.
Алерт проходит ловушки в обе стороны:
- Слишком чувствительный: срабатывает на любой скачок, будит по пустякам. Результат: усталость от алертов, люди отключают звук и пропускают настоящее.
- Слишком тугой: срабатывает поздно или никогда. Результат: о проблеме узнаёт клиент.
- Без инструкции: дежурный проснулся, но не знает, что смотреть.
- Без внимания к самому алертингу: сломалась система оповещения, и она молча ничего не отправляет.
Разберём на примере. Сервис падает в 03:10. Плохой сценарий: в 03:10 никаких алертов, в 08:00 приходит письмо из поддержки «клиенты жалуются». Другой плохой сценарий: в 03:10 приходит 40 сообщений «упал под 1», «упал под 2»… и «CPU 0%», дежурный читает первые три и выключает телефон. Хороший сценарий: в 03:12 одно сообщение «Заметки недоступны, вот инструкция».
Прикинь сам: почему отключить надоевший алерт иногда правильнее, чем оставить?
Алерт, на который все давно не реагируют, вредит: приучает игнорировать сообщения вообще, в том числе настоящие. Если он не требует действия, его место на дашборде. Если требует, надо исправить причину или порог, а не привыкать к шуму.
Частая ошибка: считать, что чем больше алертов, тем безопаснее. Наоборот: каждый лишний алерт снижает доверие ко всем остальным. Правило, которое выручает: у каждого алерта есть человек, который обязан что-то сделать. Если делать нечего, это не алерт, а строка на дашборде.
Главное: алерт ломается в обе стороны: слишком чувствительный будит зря, слишком тугой молчит, а без runbook и контроля самой системы толку мало.
Из чего же состоит правило?
Из чего состоит правило оповещения
Чтобы Prometheus сам проверял условие «плохо», условие нужно записать на языке, который он понимает: на PromQL (язык запросов Prometheus, урок 8.3), плюс объяснить, как долго ждать и что написать человеку. Это и есть правило оповещения (alerting rule).
Правила лежат в YAML-файле. YAML это формат настроек, где вложенность задаётся отступами пробелами (не табами), а список начинается со знака -. Внутри файла есть группы (groups), в группе список правил (rules). Prometheus вычисляет все правила группы по очереди раз в evaluation_interval (интервал вычисления; по умолчанию 1 минута, мы ставим 15 секунд в prometheus.yml в задании 2). Одно правило состоит из полей:
| Поле | Что значит |
|---|---|
alert |
имя алерта, по нему его ищут и на него ссылаются runbook и маршруты |
expr |
условие в PromQL. Алерт есть, пока выражение возвращает хотя бы один ряд (одну временную серию) |
for |
сколько времени условие обязано держаться подряд, прежде чем алерт «загорится» |
labels |
метки: пары «ключ: значение», добавляемые к алерту. По ним работает маршрутизация (severity, service) |
annotations |
текст для человека: summary (одна строка сути), description (подробности), runbook_url (ссылка на инструкцию) |
Разберём на примере. Возьмём правило, которое ловит остановку сбора метрик:
- alert: NotesMetricsDown
expr: up{job="notes"} == 0
for: 1m
Разберём expr по кускам. Метрика up (из урока 8.2) равна 1, если Prometheus смог опросить цель, и 0, если не смог. {job="notes"} оставляет только цели из группы notes. == 0 это оператор сравнения-фильтра: он не отвечает «да/нет», а оставляет только те ряды, для которых сравнение верно. Пока «Заметки» работают, у единственного ряда up{job="notes"} значение 1, сравнение с 0 ложно, ряд отбрасывается, запрос возвращает пустой результат, алерта нет. Когда «Заметки» упали, значение стало 0, ряд остался, запрос вернул один ряд, условие выполнено.
Из этого получается важное правило: чтобы алерт сработал, выражение должно вернуть ряд, а не «истину». Поэтому во всех правилах есть сравнение (== 0, > 0.05, < 0): оно и отфильтровывает здоровые ряды.
Одного up для «сервис недоступен» мало. Он говорит лишь, что Prometheus достучался до приложения напрямую, в обход nginx и TLS. Если упадёт прокси или истечёт сертификат, up{job="notes"} останется равным 1, а пользователи ничего не откроют. Поэтому недоступность ловят пробой снаружи из урока 8.4: probe_success{job="blackbox-https"} == 0 (1 если проба прошла, 0 если нет). Алерт NotesDown строится на ней, а up == 0 остаётся предупреждением «приложение не отдаёт метрики».
Метки берутся из двух мест: те, что были у ряда в выражении (job, instance), плюс те, что ты дописал в labels. Итоговый алерт NotesMetricsDown получит job="notes", instance="notes:8080", severity="warning", service="notes" и служебную метку alertname="NotesMetricsDown".
В annotations можно подставлять значения. Шаблоны Prometheus пишутся в двойных фигурных скобках: {{ $labels.instance }} превратится в адрес упавшей цели, например notes:8080, а {{ $value }} в текущее значение выражения. Так одно правило даёт понятный текст для любой цели.
Частая ошибка: принять evaluation_interval за частоту уведомлений. Это частота проверки условия. Как часто человек получит сообщение, определяет Alertmanager (ниже). Вторая ошибка: ждать от expr значения true. В Prometheus у фильтра нет булевого результата, есть «ряд есть» и «ряда нет».
Главное: правило это условие
expr, непрерывностьfor, метки для маршрута и аннотации с описанием и ссылкой на runbook.
Проверь понимание: правило
expr: up{job="notes"} == 1иfor: 1m. Когда оно сработает?
Ответ
Когда «Заметки» живы: у здоровой цели up равен 1, фильтр пропускает ряд, условие держится, через минуту алерт загорится. Это ошибка в условии: правило будет кричать, когда всё хорошо, и молчать при аварии. Для падения нужно == 0.
Как алерт живёт во времени?
Состояния алерта и поле for
Метрики шумят. Один опрос мог не пройти из-за секундной задержки сети, и up на 15 секунд стал 0. Будить человека из-за этого глупо. Поле for заставляет условие продержаться заданное время без перерыва.
У алерта три состояния:
inactive: условие ложно, алерта нет;pending(ожидание): условие только что стало истинным, но с этого момента прошло меньшеfor;firing(горит): условие держится дольшеfor, алерт отправляется в Alertmanager.
Стоит условию хоть на один цикл стать ложным, состояние падает в inactive, а счёт for начнётся заново.
stateDiagram-v2
[*] --> inactive
inactive --> pending: условие стало истинным
pending --> inactive: условие пропало, отсчёт for сброшен
pending --> firing: условие держится дольше for
firing --> inactive: условие стало ложным
На временной шкале то же самое: условие ложно в 0:00, истинно с 0:15 и дальше, и при for: 1m алерт станет firing в 1:15. Если условие пропадёт на 0:45, счёт начнётся заново.
Разберём на примере. NotesMetricsDown с for: 1m. В 12:00:00 Prometheus опросил цель, опрос не прошёл, up = 0. Правило вычисляется, ряд есть, состояние pending, счётчик начался в 12:00:00. 12:00:15, 12:00:30, 12:00:45: ряд есть, всё ещё pending. В 12:01:00 условие держится ровно минуту, состояние firing, алерт уходит в Alertmanager. Если в 12:00:40 цель ответила (up = 1), то на ближайшей проверке правило вернёт пусто, состояние inactive, никто ничего не узнал. Компромисс такой: чем больше for, тем меньше ложных срабатываний, но тем позже ты узнаёшь о настоящей беде. При for: 10m о падении ты узнаешь минимум через десять минут. Поэтому для падения сервиса ставят минуту, для «стало медленнее» десять минут.
Двигай нагрузку и смотри, как алерт проходит через pending: короткий скачок гаснет, не став firing.
Прикинь сам: алерт с
for: 5m, условие было истинным 4 минуты 50 секунд, а потом стало ложным. Сколько уведомлений придёт?
Ни одного. Алерт всё это время был в pending и вернулся в inactive, не став firing. Именно так for гасит шум от коротких скачков.
Частая ошибка: считать, что for это задержка перед отправкой. Точнее, это требование непрерывности: прерывание сбрасывает отсчёт. И ещё: пока алерт pending, Alertmanager о нём ничего не знает, в интерфейсе Alertmanager его не будет, он виден только в Prometheus.
Главное: алерт идёт
inactive,pending,firing, аforтребует непрерывности, и любой разрыв сбрасывает отсчёт.
О чём вообще стоит сообщать?
Что мониторить: симптомы, а не причины
Ночью человека надо будить только тогда, когда пользователю плохо. Иначе он либо не выспится ради ерунды, либо перестанет верить телефону.
Всё, что можно измерить, делится на два типа:
- Симптомы: то, что видит пользователь. Сервис недоступен, доля ошибок 5xx (ответов с кодом 500-599, ошибка на стороне сервера) выше нормы, ответы стали медленными. Это тема урока 8.1: SLI (показатели качества) и SLO.
- Причины: внутреннее состояние, которое может, но не обязано вредить. Загрузка CPU, память, число соединений.
Будить нужно по симптомам. Причины полезны на дашборде и в расследовании, но CPU 90% при нормальных ответах не авария (сервис просто занят), а у упавшего сервиса CPU вообще 0%.
Исключение: то, что через время неизбежно станет симптомом. Диск, который заполнится через сутки, ещё ничему не вредит, но вредить будет. Это предупреждение, которое разбирают днём. Отсюда две срочности, которые ты будешь записывать в метку severity:
critical(page, «пейдж»: вызов человека немедленно): пользователи страдают прямо сейчас;warning(ticket): нужно разобраться в рабочие часы, достаточно завести задачу.
Разберём на примере. Наши шесть алертов:
| Алерт | Тип | Срочность | Почему |
|---|---|---|---|
NotesDown |
симптом | critical |
проба снаружи красная: пользователь сервис не откроет |
NotesMetricsDown |
причина | warning |
приложение не отдаёт метрики: остальные алерты слепнут |
NotesHighErrorRate |
симптом | critical |
часть пользователей получает ошибки |
NotesHighLatency |
симптом | warning |
медленно, но работает: завести задачу |
NotesDiskFillingUp |
причина заранее | warning |
пока работает, а через сутки нет |
NotesCertExpiringSoon |
причина заранее | warning |
сертификат истечёт меньше чем через 14 дней, потом сервис для клиентов «упадёт» |
Частая ошибка: считать, что «критично» значит «важно». Критичность измеряется не важностью сервиса, а тем, нужен ли человек прямо сейчас. Алерты на бюджет ошибок SLO (burn rate, скорость сгорания бюджета) разбираются в уроке 8.11, здесь мы работаем с простыми порогами.
Главное: будят по симптомам, которые видит пользователь, а причины остаются для дашборда и расследования.
Проверь понимание: почему «CPU выше 80%» плохой критичный алерт, а «доля 5xx выше 5% в течение 5 минут» хороший?
Ответ
CPU это причина и часто рабочая норма (сервис просто занят). Доля 5xx это прямой симптом: часть пользователей получает ошибки, и на него всегда есть что делать. Первый даёт ложные тревоги и приучает игнорировать алерты, второй нет.
Что делать с тем, что станет проблемой позже?
Предсказание: как алерт видит будущее (predict_linear)
Диск не «ломается», он заканчивается постепенно. Если ждать, когда свободного места станет 0, то узнаешь об этом одновременно с аварией. Хочется получить предупреждение заранее.
Функция predict_linear(метрика[окно], секунд) берёт значения метрики за окно, проводит через них прямую линию (линейная регрессия) и продолжает её вперёд на указанное число секунд. Результат это предсказанное значение метрики через это время.
Разберём на примере. Правило NotesDiskFillingUp:
predict_linear(node_filesystem_avail_bytes{mountpoint="/",fstype!~"tmpfs|overlay"}[6h], 24 * 3600) < 0
По частям: node_filesystem_avail_bytes (из node_exporter, урок 8.4) это свободные байты на файловой системе. {mountpoint="/", fstype!~"tmpfs|overlay"} выбирает корневой раздел и исключает виртуальные файловые системы в памяти (tmpfs) и слои контейнеров (overlay). !~ значит «не подходит под регулярное выражение». [6h] это окно: смотрим последние 6 часов. 24 * 3600 это 86 400 секунд, то есть сутки вперёд. < 0 фильтр: оставить, если предсказанное свободное место отрицательное, то есть закончится. Пример чисел: сейчас свободно 20 ГБ, за 6 часов убыло 6 ГБ, скорость 1 ГБ в час. Через 24 часа получится 20 минус 24 равно минус 4 ГБ, условие верно. С for: 30m алерт станет firing, только если прогноз держится полчаса: разовый скачок (скачали большой файл и удалили) не разбудит.
Прикинь сам: свободно 100 ГБ, за 6 часов убыло 3 ГБ. Сработает ли
predict_linear(..., 24 * 3600) < 0?
Нет. Скорость 0,5 ГБ в час, за сутки уйдёт 12 ГБ, предсказание 100 минус 12 равно 88 ГБ, это больше нуля. Диск не закончится ближайшие сутки, алерта нет.
Частая ошибка: ждать от прогноза точности. Прогноз линейный, а рост бывает ступенчатым (лог вырос за минуту). Поэтому это предупреждение заранее, а не гарантия. Про то, что диск уже почти полон, сообщает отдельный порог.
Главное:
predict_linearпозволяет предупредить о проблеме заранее и превращает «срочно» в «разобрать днём».
Теперь посмотрим, что делает Alertmanager.
Alertmanager: что он делает и чего не делает
Prometheus умеет проверять условия, но не умеет обращаться с людьми. Если бы он сам слал сообщения, то при каждом вычислении правил (каждые 15 секунд) отправлял бы одно и то же, а при падении узла с десятью подами слал бы десять сообщений. Нужна отдельная программа, которая думает о получателях. Это Alertmanager.
Alertmanager ничего не измеряет и не проверяет. Он получает от Prometheus уже сработавшие (firing) алерты по HTTP и применяет к ним шаги: дедупликация (один набор меток это один алерт), маршрутизация (выбор получателя), группировка, ожидание таймеров, затем подавление (inhibit) и silence, отправка получателю, повторная отправка по расписанию. Ниже каждый из шагов по отдельности.
flowchart TD
P["Prometheus<br>повторно шлёт firing-алерты<br>раз в минуту"] --> D["Дедупликация<br>тот же набор labels = один алерт"]
D --> R["Маршрут<br>по labels выбираем получателя"]
R --> G["Группировка<br>одинаковые group_by = одно сообщение"]
G --> T["Тайминги<br>group_wait, group_interval, repeat_interval"]
T --> I["Подавление inhibit и silence<br>зависимый или заглушённый молчит"]
I --> PG["receiver page<br>webhook, Telegram"]
I --> TK["receiver ticket<br>webhook, почта"]
Частая ошибка: думать, что Alertmanager решает, что сломалось. Нет, это решает Prometheus. Alertmanager решает только, как и кому об этом сказать. Поэтому, если алерта нет в Alertmanager, ищи причину в Prometheus (правило, for, связь), а не в настройках маршрутов.
Главное: Alertmanager ничего не измеряет: он только принимает сработавшие алерты и решает, как и кому о них сообщить.
Проверь понимание: алерт в состоянии
pendingвиден в Prometheus, но его нет в Alertmanager. Это сбой?
Ответ
Нет, так и задумано. Prometheus отправляет в Alertmanager только firing-алерты. Пока for не прошёл, алерт есть только у Prometheus.
Поэтому, если алерта не видно в Alertmanager, начни с Prometheus: открой http://localhost:9090/alerts. Состояние pending значит, что условие истинно, но for ещё не вышел, и просто подожди. Состояние firing при пустом Alertmanager уже сбой связи: смотри блок alerting в конфиге Prometheus и страницу Status > Runtime & Build Information.
Как он склеивает повторы?
Дедупликация и группировка
Два повторяющихся явления портят жизнь дежурному: один и тот же алерт приходит снова и снова, и один сбой порождает лавину похожих алертов.
Дедупликация убирает повторы одного и того же алерта, а группировка склеивает разные алерты в одно сообщение. Склеиваются только алерты с одинаковыми значениями перечисленных меток.
Алерт в Alertmanager определяется набором его меток (labels). Prometheus повторно шлёт один и тот же firing-алерт примерно раз в минуту (при смене состояния сразу), но набор меток тот же, поэтому Alertmanager считает его одним и тем же алертом (дедупликация): второе сообщение получателю не уходит.
Группировка управляется параметром group_by: список меток, по которым алерты склеиваются. У алертов с одинаковыми значениями этих меток образуется одна группа и одно уведомление. Остальные метки внутри уведомления перечисляются списком.
Помнишь дежурного, которому ночью пришло 240 одинаковых сообщений? Вот та же авария, когда между Prometheus и телефоном стоит Alertmanager:
03:12:45 [FIRING:1] NotesDown https://notes.lab/healthz Заметки недоступны
runbook: .../runbooks/NotesDown.md
07:12:45 [FIRING:1] NotesDown https://notes.lab/healthz напоминание, всё ещё горит
за четыре часа: 2 сообщения
[FIRING:1] значит «горит один алерт». Сообщение одно, в нём сразу ссылка на инструкцию (runbook), а напоминание придёт только через четыре часа.
Разберём на примере. Ночью упал узел, на нём работали десять экземпляров сервиса. За минуту сработали десять алертов NotesHighErrorRate, у каждого своя метка instance (pod-1 … pod-10), но alertname="NotesHighErrorRate" и service="notes" одинаковы.
group_by: ["alertname", "service"] -> одна группа, одно сообщение «10 алертов»
group_by: ["alertname", "instance"] -> десять групп, десять сообщений
Во втором случае в group_by попала метка, различающаяся у каждого экземпляра, и склейка не работает. Это классическая ошибка: instance в group_by даёт то, от чего группировка должна спасать.
Прикинь сам:
group_by: ["alertname"]. СработалиNotesDown(сервисnotes) иNotesDown(сервисbilling). Сколько уведомлений?
Одно: значение единственной метки из group_by (alertname="NotesDown") у алертов одинаково, они попадают в одну группу. Если нужны раздельные сообщения по сервисам, добавь service в group_by.
Частая ошибка: думать, что группировка удаляет алерты. Все алерты остаются, просто сообщение о них одно.
Главное: одинаковый набор меток это один алерт, а
group_byсклеивает похожие алерты в одно сообщение.
Как выбрать получателя?
Маршрутизация: дерево route
Разным алертам нужны разные получатели: критичные будят людей, предупреждения заводят задачи, алерты базы данных идут DBA, а не разработчикам.
В файле alertmanager.yml есть один корневой route с получателем по умолчанию (receiver). Внутри него список вложенных routes с условиями matchers (сопоставители: проверка меток, например severity = "critical"). Алерт проходит вложенные маршруты сверху вниз. Первый подошедший забирает его, если у него не стоит continue: true (тогда проверка продолжается дальше). Если не подошёл никто, алерт достаётся корневому получателю.
Разберём на примере. Из нашей конфигурации:
flowchart TD
ROOT["route<br>корень, receiver: webhook"] -->|"severity = critical"| PG["receiver: page"]
ROOT -->|"severity = warning"| TK["receiver: ticket"]
ROOT -->|"иначе"| WH["receiver: webhook<br>по умолчанию"]
Алерт проходит ветки сверху вниз и уходит в первую подошедшую. Если не подошла ни одна, он попадает к получателю по умолчанию.
Три алерта:
NotesDownсseverity: critical: первая ветка подошла, получательpage.NotesHighLatencyсseverity: warning: первая ветка не подошла, вторая да, получательticket.- Алерт без метки
severityили сseverity: info: ни одна ветка не подошла, получательwebhook. Он не пропадёт, но и не пойдёт куда надо. Поэтому корневого получателя по умолчанию делают таким, чтобы его сообщения было видно.
Частая ошибка: считать, что порядок веток не важен. Если поставить широкую ветку выше узкой, узкая никогда не сработает, потому что широкая заберёт алерт раньше. Проверять это удобно командой amtool config routes test, она покажет получателя для набора меток без настоящего алерта.
Главное: алерт идёт по веткам route сверху вниз и уходит в первую подошедшую, поэтому порядок веток это часть логики.
Проверь понимание: алерт с
severity: warning,service: notes. Что будет, если поставить веткуservice = "notes"с получателемpageвыше веткиseverity = "warning"?
Ответ
Алерт попадёт в page: первая ветка подошла и забрала его, до warning-ветки дело не дойдёт (без continue). Предупреждения по сервису начнут будить людей. Порядок веток это часть логики.
Когда именно слать сообщения?
Тайминги: group_wait, group_interval, repeat_interval
Даже после склейки нужно решить, когда слать: сразу в первую секунду или подождать остальных участников; как часто добавлять новые алерты в уже отправленное сообщение; как часто напоминать о том, что беда не решена.
Таймеры понятнее всего на конкретной линии времени ниже.
Три таймера:
group_wait(обычно 30 секунд): сколько ждать после появления первого алерта новой группы, прежде чем отправить первое уведомление. За это время в группу попадают остальные.group_interval(обычно 5 минут): как часто отправлять уведомление, если в уже отправленную группу пришли новые алерты или что-то снялось.repeat_interval(у нас 4 часа): как часто повторять напоминание о том же самом, неизменившемся составе группы, если алерт всё ещё горит.
Разберём на примере одного алерта NotesDown с for: 2m. Сервис упал в 12:00:00, пробы идут раз в 15 секунд.
| Время | Что происходит |
|---|---|
| 12:00:00 | сервис упал |
| 12:00:15 | проба красная, правило видит probe_success == 0: алерт pending |
| 12:02:15 | условие держится 2 минуты (for): алерт firing, Prometheus отправляет его в Alertmanager |
| 12:02:45 | прошёл group_wait (30 секунд): первое сообщение уходит получателю page |
| 12:03:00 | в ту же группу добавился второй алерт NotesDown с другим instance |
| 12:07:45 | group_interval (5 минут после прошлой отправки): уходит обновлённое сообщение уже с двумя алертами |
| 16:07:45 | repeat_interval (4 часа после последней отправки): напоминание, если состав группы не менялся |
Время ориентировочное, плюс-минус цикл опроса и вычисления правил (15 секунд).
Прикинь сам: зачем нужен
group_wait, если алерт уже точно горит? Почему не слать сразу?
Чтобы собрать однотипные алерты, которые сработают в течение ближайших секунд, в одно сообщение. Если слать сразу, то первое сообщение уйдёт про один алерт, а следующие про остальные: получится тот самый шквал, от которого группировка защищает. Компромисс: чем больше group_wait, тем дольше ты не знаешь о беде.
Частая ошибка: думать, что repeat_interval это «раз в столько присылать новые алерты». Нет, новые алерты в группе идут по group_interval, а repeat_interval только для напоминания о неизменной группе. Слишком короткий repeat_interval превращает Alertmanager в спамера: дежурный получает «ещё горит» каждую минуту.
Главное:
group_waitждёт остальных участников группы,group_intervalограничивает частоту обновлений,repeat_intervalнапоминает о неизменившемся.
Как не слать лишнего?
Подавление (inhibit) и заглушка (silence)
Бывают алерты, которые сами по себе верны, но в данный момент бесполезны. Сервис упал: алерт «медленные ответы» этого же сервиса лишний. Или идут плановые работы, и алерты про них ожидаемы.
- Подавление (
inhibit_rules): правило «пока горит алерт-источник (source_matchers), не отправлять алерты-цели (target_matchers), если у них совпадают метки изequal». Совпадение поequalнужно, чтобы алерт про один сервис не глушил алерты про другой. - Silence (заглушка): временное правило, заданное вручную по меткам и на срок. Пока оно действует, подходящие алерты остаются
firing, но уведомления не идут. По истечении срока заглушка исчезает сама.
Разберём на примере. Наше правило:
inhibit_rules:
- source_matchers: ['alertname = "NotesDown"']
target_matchers: ['severity = "warning"']
equal: ["service"]
По-русски: «пока горит NotesDown, не отправляй предупреждения (severity = "warning") с тем же значением service». Если NotesDown горит для service=notes, то NotesHighLatency с service=notes заглушится. А предупреждение про service=billing пройдёт: у него service другой. Silence, для сравнения, ставят командой amtool silence add alertname=NotesDown --duration=10m: пока идут работы, NotesDown не будит никого, через десять минут заглушка сама исчезает и, если сервис всё ещё лежит, уведомление придёт.
Частая ошибка: путать silence и inhibit. Silence ставит человек на время, inhibit срабатывает по правилу из-за другого алерта. И silence не удаляет алерт и не чинит ничего: он только выключает звук. Забыл заглушку на неделю, пропустил настоящую аварию: заглушки ставят на короткий срок и с комментарием.
Главное: inhibit срабатывает автоматически по правилу, а silence ставят вручную на срок, и оба оставляют алерты
firing, только без уведомлений.
Проверь понимание: ты поставил silence на
alertname=NotesDownна 10 минут, а через 15 минут сервис всё ещё лежит. Что будет?
Ответ
Через 10 минут заглушка истечёт. Алерт всё это время оставался firing, поэтому уведомление уйдёт при ближайшей отправке: пропустить аварию заглушкой нельзя, она только откладывает звук.
Кому реально отправлять?
Получатели (receivers) и webhook
Сообщение нужно доставить туда, где человек его увидит: в Telegram, Slack, почту, систему дежурств (PagerDuty).
В alertmanager.yml секция receivers описывает получателей: у каждого имя и один или несколько способов доставки (telegram_configs, slack_configs, email_configs, webhook_configs). Маршрут ссылается на получателя по имени. Webhook (веб-хук, «обратный вызов по HTTP») это универсальный способ: Alertmanager отправляет POST-запрос (HTTP-запрос с телом) с JSON-документом на адрес, а на той стороне что угодно принимает и обрабатывает. Telegram подключается так же блоком telegram_configs с токеном бота. Токен это секрет, в git его не хранят (урок 9.1).
Разберём на примере. В уроке нет настоящего Telegram, поэтому приёмником служит контейнер go-httpbin: он отвечает на любой запрос и пишет его в лог. Получатель page отправляет POST на http://webhook:8080/anything/page. Здесь webhook это имя контейнера в сети notes-net (по имени контейнеры находят друг друга, урок 4.6), 8080 его порт внутри сети, /anything/page путь, который мы придумали: по нему в логе видно, какой получатель сработал. Тело запроса это JSON примерно такого вида (сокращён):
{
"status": "firing",
"receiver": "page",
"groupLabels": {"alertname": "NotesDown", "service": "notes"},
"alerts": [{"status": "firing", "labels": {"alertname": "NotesDown", "severity": "critical"}}]
}
status это firing или resolved (алерт снялся), receiver кто получил, groupLabels по каким меткам сгруппировано, alerts список алертов группы.
Прикинь сам: в логе
webhookесть строкаPOST /anything/ticket. Что это говорит?
Сработал получатель ticket: пришёл алерт с severity: warning, и Alertmanager отправил уведомление на путь /anything/ticket. По пути в логе можно понять, по какой ветке пошёл алерт.
Частая ошибка: думать, что Alertmanager проверяет, дошло ли сообщение до человека. Он знает только, что доставка получателю (например, ответ 200 от webhook) прошла. Прочитал ли его человек, он не знает.
Главное: получатель это куда уходит сообщение, а webhook позволяет подключить любую систему обычным HTTP-запросом.
Как понять, что сам алертинг жив?
Как узнать, что алертинг сам не сломался: Watchdog и promtool
Самая неприятная авария: молчит не сервис, а система оповещения. Тишина выглядит как «всё хорошо».
Это называют dead man’s switch («рычаг мёртвой руки»): тишина здесь тревожный сигнал, а не нормальное состояние. Идея в том, что проверять надо не только сбой, но и пропажу сигнала о том, что всё хорошо.
Заводят «сторожевой» алерт Watchdog с условием vector(1) (константа-ряд, условие вечно истинно). Он горит всегда, и Alertmanager постоянно шлёт его на внешний сервис. Пока сообщения идут, всё работает. Пропали они на несколько минут: сломался Prometheus, Alertmanager или канал. Внешний сервис поднимает тревогу. В проект Watchdog не добавляем (внешнего приёмника нет), но на проде он обязателен.
Вторая защита: правила проверяют до выкатки. У promtool (программа из комплекта Prometheus) две команды:
promtool check rulesпроверяет синтаксис: файл читается, выражения корректны;promtool test rulesзапускает юнит-тест: ты подаёшь синтетические (придуманные) значения метрик и говоришь, какие алерты должны гореть в какой момент. Выражения при этом проверяются на придуманных данных, поэтомуtestловит неверную логику (не тот порог, не то сравнение), но не ловит неверное имя метрики: его сверяют с живым/metrics.
Юнит-тест это файл с блоками: input_series (какие ряды подаём, значения записываются через x: '0x40' значит «0, потом ещё 40 раз повтор», всего 41 значение, а '0.10x8 0x60' значит «0.10 и ещё 8 раз, затем 0 и ещё 60 раз»), interval (шаг между значениями) и alert_rule_test (в момент eval_time ожидаем такие-то алерты exp_alerts).
Частая ошибка: считать, что если check зелёный, правило рабочее. check смотрит только форму. test проверяет логику на придуманных данных, поэтому опечатку в имени метрики он тоже не поймает: и в правиле, и в тесте стоит одно и то же неверное имя, и они сойдутся. Имя метрики сверяй с живым /metrics, а выражение алерта запускай на настоящих данных в Prometheus (шаг 4 задания 1).
Главное: Watchdog всегда горит и молчит только при сбое системы, а
promtoolпроверяет форму и поведение правил до выкатки.
Проверь понимание: что даёт
promtool test rules, чего не даётpromtool check rules?
Ответ
check проверяет только синтаксис и корректность выражений. test проверяет поведение: на заданных входных рядах алерт становится firing в нужную минуту с нужными метками. Но данные в тесте придуманы, поэтому опечатка в имени метрики пройдёт оба и всплывёт только на живых данных.
Как выбрать пороги?
Как выбрать порог и for: разбор на цифрах
Новичок видит в правиле > 0.05 и for: 5m и спрашивает: «откуда такие числа?». Если брать их с потолка, алерт будет или будить зря, или молчать. Нужно уметь обосновать число.
Порог берут из цели по качеству (урок 8.1). Если цель «не более 1% ошибок за месяц», то алерт должен сработать, когда ошибок заметно больше обычного, а не при единичном сбое. for выбирают по трём вопросам. Как быстро нужно узнать (падение сервиса: минуты, медленный рост диска: часы)? Насколько метрика «шумит» (скачет ли она сама по себе)? Сколько стоит ложная тревога (разбудить человека дороже, чем завести задачу)? Чем быстрее нужно узнать, тем меньше for, чем больше шума и дороже ложная тревога, тем больше. Нижняя граница простая: for должен покрывать хотя бы два-три цикла опроса. Правила вычисляются каждые 15 секунд, поэтому for: 15s сработает уже от двух проверок подряд (слишком мало), а for: 1m потребует пяти подряд.
Разберём на примере. Правило NotesHighErrorRate: notes:http_errors:ratio5m > 0.05 and notes:http_requests:rate5m > 0.1 (больше 5% ошибок за 5 минут при трафике выше 0,1 запроса в секунду) и for: 5m. Почему так? Сервис получает 20 запросов в секунду. Два случайных 500 за минуту это 2 из 1200 запросов, то есть около 0,17%, намного ниже 5%, алерт молчит. Если же 5% запросов падает стабильно (60 из 1200 за минуту), значит, что-то сломалось. for: 5m нужен, чтобы пятиминутное окно не поймало короткий всплеск после деплоя. Общее время до уведомления: до 5 минут окна, плюс 5 минут for, плюс group_wait (обычно 30 секунд): в худшем случае около 10 минут. Если для твоего сервиса десять минут это слишком долго, уменьши for до 2 минут и смирись с тем, что изредка будешь получать лишнее.
Условие по трафику нужно ради ночи, когда запросов почти нет. Если за пять минут пришёл один запрос и он упал, доля ошибок равна 100%, и алерт разбудил бы дежурного ради одного запроса. Оператор and оставляет ряд слева, только если справа тоже есть ряд, поэтому правило требует ещё и notes:http_requests:rate5m > 0.1 (больше 6 запросов в минуту). Число 0,1 взято для учебного стенда, на проде его подбирают по обычному трафику. Минус у связки один: если сервис упал совсем и запросов нет, этот алерт молчит, но для такого случая есть NotesDown.
Прикинь сам: алерт на ошибки срабатывает несколько раз в неделю на 30 секунд и сам проходит. Что поменяешь?
Увеличу for (например, с 1 до 5 минут): короткие всплески перестанут доходить до состояния firing. Если настоящие аварии при этом не задерживаются слишком сильно, этого достаточно. Порог трогать не нужно, он описывает «насколько плохо», а проблема в том, что всплески короткие.
Частая ошибка: искать «правильный» порог на все случаи. Порог всегда компромисс между скоростью и шумом, и его корректируют по опыту: если алерт срабатывал трижды зря, порог или for увеличивают, если пропустил настоящую проблему, уменьшают.
Главное: порог берут из цели по качеству, а
forиз баланса между скоростью реакции и шумом, и оба подстраивают по опыту.
Что должно быть в инструкции?
Runbook: инструкция, которую можно выполнить в три часа ночи
Разбуженный дежурный не помнит архитектуру. Автор правила может быть в отпуске. Если решение живёт в голове одного человека, то команда зависит от него.
Runbook (раннбук) это документ на один алерт, ссылка на него лежит в аннотации runbook_url, значит попадает прямо в сообщение. В нём пять разделов: симптом (что сработало и что видит пользователь), влияние (насколько всё плохо, будить ли ещё кого-то), проверки (команды по порядку), действия (как починить и как откатить), эскалация (кому звать, если не помогло за N минут).
Разберём на примере. Раздел «Проверки» плохого runbook: «Проверь состояние сервиса». Хорошего: «1. docker compose ps в ~/notes: жив ли notes, нет ли Restarting. 2. docker compose logs notes --tail 50: причина падения». Второй можно выполнить, не думая.
Частая ошибка: писать runbook как описание архитектуры или wiki-страницу. Это последовательность действий. Проверять его надо на живом человеке: если новичок споткнулся, документ надо дописывать.
Главное: runbook это пять разделов и конкретные шаги, которые выполнит сонный человек, а проверяют его на новичке.
Когда звать: эскалация идёт по таймеру, а не по самооценке. Если в runbook написано «не поднялся за 15 минут», через 15 минут зови, даже когда кажется, что осталось чуть-чуть. Лучше разбудить человека зря, чем молчать лишний час. В поле «Эскалация» пиши роль и канал связи (например, «владелец сервиса, чат дежурных»), а не просто «звать владельца».
Проверь понимание: какие пять разделов должен содержать runbook?
Ответ
Симптом, влияние, проверки (команды по порядку), действия (починить и откатить), эскалация (кому звать, если не помогло).
Практика
Перед началом основной стек «Заметок» запущен (docker compose up -d в ~/notes), мониторинг из уроков 8.2-8.4 работает (docker compose -f ~/notes/monitoring/compose.yml ps). Все файлы ниже лежат в ~/notes/monitoring/ и ~/notes/docs/. Адреса runbook_url в правилах это пример: так выглядит адрес runbook в твоём репозитории на GitHub, подставь свой.
Задание 1. Шесть алертов и проверка правил
Цель: написать правила оповещения и проверить их без запуска Alertmanager.
Предскажи: в файле правил NotesMetricsDown использует up{job="notes"} == 0. Что вернёт этот запрос, пока «Заметки» работают: пустой результат или ряд со значением 1?
Ответ
Пустой результат. Оператор сравнения == 0 фильтрует ряды: у живого target up равен 1, он отбрасывается. Алерт есть, только пока запрос возвращает хотя бы один ряд.
Шаги:
- Создай каталоги и файл правил. Что делает команда:
mkdir -pсоздаёт каталоги (флаг-pсоздаёт и промежуточные, и не ругается, если каталог уже есть). Конструкцияcat > файл <<'YAML' ... YAMLзаписывает всё, что написано до словаYAML, в файл; кавычки вокруг'YAML'запрещают оболочке подставлять в текст переменные и$. Шаблоны аннотаций содержат двойные фигурные скобки: для Prometheus это подстановки, копируй их как есть. Комментарии#в YAML это пояснения для людей, программа их пропускает. Записьlabels: {severity: critical, service: notes}это сокращённая форма словаря в одну строку.
mkdir -p ~/notes/monitoring/prometheus/rules ~/notes/monitoring/prometheus/tests
cat > ~/notes/monitoring/prometheus/rules/alerts.yml <<'YAML'
groups:
- name: notes-alerts
rules:
# Симптом: проба снаружи (nginx, TLS, приложение) красная, job blackbox-https из урока 8.4
- alert: NotesDown
expr: probe_success{job="blackbox-https"} == 0
for: 2m
labels: {severity: critical, service: notes}
annotations:
summary: "Заметки недоступны снаружи"
description: "Проба {{ $labels.instance }} красная больше 2 минут."
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesDown.md"
# Причина: Prometheus не может снять метрики с приложения (проба снаружи при этом может быть зелёной)
- alert: NotesMetricsDown
expr: up{job="notes"} == 0
for: 1m
labels: {severity: warning, service: notes}
annotations:
summary: "Приложение не отдаёт метрики"
description: "Target {{ $labels.instance }} не отвечает больше минуты."
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesMetricsDown.md"
# Симптом: доля ответов 5xx выше 5% при заметном трафике (recording rules из урока 8.3)
- alert: NotesHighErrorRate
expr: notes:http_errors:ratio5m > 0.05 and notes:http_requests:rate5m > 0.1
for: 5m
labels: {severity: critical, service: notes}
annotations:
summary: "Доля ошибок 5xx выше 5%"
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesHighErrorRate.md"
# Симптом: 95-й перцентиль задержки выше 500 мс
- alert: NotesHighLatency
expr: notes:http_latency:p95_5m > 0.5
for: 10m
labels: {severity: warning, service: notes}
annotations:
summary: "p95 задержки выше 500 мс"
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesHighLatency.md"
# Предупреждение заранее: диск закончится в ближайшие сутки
- alert: NotesDiskFillingUp
expr: predict_linear(node_filesystem_avail_bytes{mountpoint="/",fstype!~"tmpfs|overlay"}[6h], 24 * 3600) < 0
for: 30m
labels: {severity: warning, service: notes}
annotations:
summary: "Диск заполнится меньше чем за 24 часа"
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesDiskFillingUp.md"
# Предупреждение заранее: сертификат истекает меньше чем через 14 дней
- alert: NotesCertExpiringSoon
expr: probe_ssl_earliest_cert_expiry{job="blackbox-https"} - time() < 14 * 86400
for: 1h
labels: {severity: warning, service: notes}
annotations:
summary: "Сертификат истекает меньше чем через 14 дней"
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesCertExpiringSoon.md"
YAML
- Проверь синтаксис командой
promtoolиз образа Prometheus (ставить ничего не нужно). Разбор:docker run --rmзапускает контейнер и удаляет его после завершения;--entrypoint promtoolговорит запустить вместо сервера Prometheus программуpromtool;-v "$PWD/prometheus:/p:ro"подключает каталогprometheusиз текущей папки внутрь контейнера как/p,:roзначит «только чтение»;check rules /p/rules/alerts.ymlэто аргументыpromtool.
cd ~/notes/monitoring
docker run --rm --entrypoint promtool \
-v "$PWD/prometheus:/p:ro" prom/prometheus:v3.15.0 \
check rules /p/rules/alerts.yml
Должно получиться (вывод ориентировочный, на живом стенде после правок не снимался):
Checking /p/rules/alerts.yml
SUCCESS: 6 rules found
- Напиши юнит-тест: подаём придуманные метрики и проверяем, что сработало (и что не сработало). Обозначения в
valuesобъяснены в теории:0x40это «0 и ещё 40 раз», приinterval: 15sэто 10 минут данных.exp_alerts: []значит «алертов быть не должно». Вexp_labelsперечислены все метки алерта, кромеalertname: егоpromtoolподставляет сам.
cat > ~/notes/monitoring/prometheus/tests/alerts_test.yml <<'YAML'
rule_files:
- ../rules/alerts.yml
evaluation_interval: 15s
tests:
# Проба красная 10 минут: после for (2 минуты) NotesDown должен гореть
- interval: 15s
input_series:
- series: 'probe_success{job="blackbox-https", instance="https://notes.lab/healthz"}'
values: '0x40'
alert_rule_test:
- eval_time: 1m
alertname: NotesDown
exp_alerts: [] # for ещё не прошёл: алерт в pending
- eval_time: 3m
alertname: NotesDown
exp_alerts:
- exp_labels:
severity: critical
service: notes
job: blackbox-https
instance: "https://notes.lab/healthz"
exp_annotations:
summary: "Заметки недоступны снаружи"
description: "Проба https://notes.lab/healthz красная больше 2 минут."
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesDown.md"
# Всплеск ошибок на 2 минуты: за счёт for уведомления быть не должно
- interval: 15s
input_series:
- series: 'notes:http_errors:ratio5m'
values: '0.10x8 0x60'
- series: 'notes:http_requests:rate5m'
values: '5x70'
alert_rule_test:
- eval_time: 2m
alertname: NotesHighErrorRate
exp_alerts: [] # условие уже 2 минуты истинно, но for: 5m не вышел
# Контроль: те же 10% держатся постоянно, после for алерт обязан загореться
- interval: 15s
input_series:
- series: 'notes:http_errors:ratio5m'
values: '0.10x40'
- series: 'notes:http_requests:rate5m'
values: '5x40'
alert_rule_test:
- eval_time: 6m
alertname: NotesHighErrorRate
exp_alerts:
- exp_labels:
severity: critical
service: notes
exp_annotations:
summary: "Доля ошибок 5xx выше 5%"
runbook_url: "https://github.com/distinguished-sre/learning/blob/main/devops/project/notes/docs/runbooks/NotesHighErrorRate.md"
# Ночь: доля ошибок 100%, но трафика почти нет (0,02 запроса в секунду): будить не нужно
- interval: 15s
input_series:
- series: 'notes:http_errors:ratio5m'
values: '1x40'
- series: 'notes:http_requests:rate5m'
values: '0.02x40'
alert_rule_test:
- eval_time: 6m
alertname: NotesHighErrorRate
exp_alerts: []
YAML
docker run --rm --entrypoint promtool \
-v "$PWD/prometheus:/p:ro" prom/prometheus:v3.15.0 \
test rules /p/tests/alerts_test.yml
- Сверь имена метрик с живыми данными: юнит-тест их не проверяет, он работает на придуманных рядах. Запрос без
== 0должен вернуть ряды со значением 1. Пустой ответ значит, что имя метрики или метки неверное. Второй запрос показывает, сколько секунд осталось до конца сертификата.
curl -s localhost:9090/api/v1/query --data-urlencode 'query=probe_success{job="blackbox-https"}' \
| jq -r '.data.result[] | [.metric.instance, .value[1]] | @tsv'
curl -s localhost:9090/api/v1/query --data-urlencode 'query=probe_ssl_earliest_cert_expiry{job="blackbox-https"} - time()' \
| jq -r '.data.result[] | [.metric.instance, .value[1]] | @tsv'
Что должно получиться (вывод ориентировочный, на живом стенде после правок не снимался). Шаг 3:
Unit Testing: /p/tests/alerts_test.yml
SUCCESS
Шаг 4:
https://notes.lab/healthz 1
https://notes.lab/readyz 1
https://notes.lab/healthz 31449600
https://notes.lab/readyz 31449600
Как читать вывод: Checking ... SUCCESS: 6 rules found значит, что файл прочитан и в нём нашлось шесть правил. Строка Unit Testing: и SUCCESS под ней это результат юнит-теста: все проверки (exp_alerts) сошлись. Если тест не сходится, вместо неё будет блок FAILED: с двумя частями: exp: (что ты ожидал) и got: (что получилось на самом деле). Сравни их метки и аннотации глазами: расхождение почти всегда видно сразу. Результат шага 4: единицы в первых строках значат, что проба прошла, а число секунд делится на 86 400, и получаются дни до конца сертификата (31 449 600 секунд это около 364 дней, у тебя число другое).
Объясни себе:
- Почему в тесте
eval_time: 1mждёт пустой списокexp_alerts, хотя проба уже красная? - Что второй тест (всплеск на 2 минуты) доказывает про поле
for, и зачем третий тест с постоянными 10%? - Что доказывает четвёртый тест с ночным трафиком 0,02 запроса в секунду?
- Юнит-тест прошёл, а в шаге 4 пришёл пустой ответ. Что это значит и какой из двух результатов верить?
Типичные ошибки:
FAILED:и в блокеgot: []пусто, а вexp:есть алерт: правило не сработало на данных теста. Проверь имя метрики и метки вinput_series, и чтоeval_timeбольшеfor.- Шаг 4 вернул пустой ответ: нет job
blackbox-httpsиз урока 8.4 или метрика названа иначе. Сначала открой Status > Targets и убедись, что цель в состоянии UP. - В
FAILED:вexp:иgot:метки отличаются одной строкой (например,service="notesx"противservice="notes"): в ожидаемых метках опечатка или не хватает унаследованных от метрики (job,instance).alertnameдобавлять не надо.
Задание 2. Alertmanager: конфиг и маршрутизация
Приёмник вебхуков используй как готовый инструмент. Достаточно понимать, где он принимает сообщение и как увидеть его в логе. Правила алертов и дерево маршрутов разбери: по меткам алерта предскажи получателя, затем проверь его через amtool и живой эксперимент. Программировать собственный приёмник на Python здесь не требуется.
Цель: запустить Alertmanager и приёмник вебхуков, описать дерево маршрутов и проверить его без реальных алертов.
Предскажи: что попадёт в получателя ticket: алерт NotesHighLatency с severity: warning, или он уйдёт получателю по умолчанию? Как убедиться, не ломая ничего?
Ответ
Он уйдёт в ticket: ветка с severity = "warning" подходит. Проверить можно без аварии командой amtool config routes test --config.file=alertmanager.yml severity=warning service=notes: метки идут последними аргументами ключ=значение, а команда показывает, какому получателю они достанутся. Ниже мы её запустим.
Шаги:
- Создай конфигурацию Alertmanager. Ключи разобраны в теории:
routeэто корень дерева,routesветки,matchersусловия по меткам,receiversполучатели,inhibit_rulesподавление.
mkdir -p ~/notes/monitoring/alertmanager
cat > ~/notes/monitoring/alertmanager/alertmanager.yml <<'YAML'
route:
receiver: webhook # по умолчанию, если ни одна ветка не подошла
group_by: ["alertname", "service"]
group_wait: 30s # ждём остальных участников группы
group_interval: 5m # новые алерты в уже отправленную группу
repeat_interval: 4h # напоминание о неснятом алерте
routes:
- matchers: ['severity = "critical"']
receiver: page
- matchers: ['severity = "warning"']
receiver: ticket
receivers:
- name: webhook
webhook_configs:
- url: http://webhook:8080/anything/default
- name: page # будит человека
webhook_configs:
- url: http://webhook:8080/anything/page
- name: ticket # заводит задачу
webhook_configs:
- url: http://webhook:8080/anything/ticket
inhibit_rules:
# Пока сервис лежит, предупреждения про него же не нужны
- source_matchers: ['alertname = "NotesDown"']
target_matchers: ['severity = "warning"']
equal: ["service"]
YAML
- Добавь в
monitoring/compose.ymlдва сервиса в секциюservices:(сетьnotes-netуже описана в конце файла с урока 8.2).imageэто образ (готовый пакет с программой),ports: "127.0.0.1:9093:9093"открывает порт 9093 контейнера на порту 9093 только для самой машины (у Alertmanager нет аутентификации, на всех интерфейсах любой в сети смог бы ставить silence),volumesподключает каталог с конфигом только для чтения и томalertmanager-dataдля данных (там хранятся silence и журнал отправленных уведомлений: без тома после пересоздания контейнера заглушки пропадут),commandпередаёт программе путь к конфигу,restart: unless-stoppedперезапускает контейнер после сбоя.
alertmanager:
image: prom/alertmanager:v0.34.1
ports:
- "127.0.0.1:9093:9093"
volumes:
- ./alertmanager:/etc/alertmanager:ro
- alertmanager-data:/alertmanager
command:
- --config.file=/etc/alertmanager/alertmanager.yml
restart: unless-stopped
# Приёмник вебхуков: логирует каждый POST от Alertmanager
webhook:
image: mccutchen/go-httpbin:v2.18.3
restart: unless-stopped
Том объяви в конце файла, в уже существующей секции volumes: рядом с prom-data (вторую секцию volumes: не создавай):
volumes:
prom-data:
alertmanager-data:
На проде Alertmanager запускают парой в кластере: Prometheus шлёт алерты обоим (оба адреса в targets, а не через балансировщик), а сами экземпляры обмениваются данными о отправленных уведомлениях и silence, чтобы не слать дубли. В уроке экземпляр один.
- Подключи Alertmanager в
monitoring/prometheus/prometheus.yml. Ключrule_filesуже добавлен в уроке 8.3, его glob/etc/prometheus/rules/*.ymlподхватит иalerts.yml(проверь:grep -n rule_files ~/notes/monitoring/prometheus/prometheus.yml;grep -nищет строку и печатает её с номером). Второйrule_filesдобавлять нельзя: Prometheus не принимает два одноимённых ключа верхнего уровня. Осталось сказать, куда отправлять сработавшие алерты:alerting(alertmanager:9093это имя сервиса и порт в сетиnotes-net). Добавь на верхний уровень, рядом сscrape_configs, без отступа:
alerting:
alertmanagers:
- static_configs:
- targets: ["alertmanager:9093"]
Заодно впиши в уже существующий блок global: (второй global: не создавай) строку evaluation_interval: по умолчанию правила вычисляются раз в минуту, а мы хотим раз в 15 секунд.
global:
scrape_interval: 15s
evaluation_interval: 15s # как часто вычислять правила
Отдельный том для правил не нужен: каталог ./prometheus уже смонтирован в контейнер целиком (урок 8.2), поэтому rules/alerts.yml виден внутри как /etc/prometheus/rules/alerts.yml.
- Проверь конфиг и запусти.
amtool check-configпроверяет файл так же, какpromtoolдля правил.docker compose up -dзапускает всё, что описано вcompose.yml, в фоне (-d).docker compose kill -s HUP prometheusпосылает контейнеру сигнал SIGHUP: по нему Prometheus перечитывает конфиг без перезапуска (урок 1.4).
cd ~/notes/monitoring
docker run --rm --entrypoint amtool \
-v "$PWD/alertmanager:/a:ro" prom/alertmanager:v0.34.1 \
check-config /a/alertmanager.yml
docker compose up -d
docker compose kill -s HUP prometheus # перечитать конфиг без перезапуска (сигнал SIGHUP)
- Спроси у дерева маршрутов, кому достанется набор меток. Цикл
for sev in warning critical; do ...; doneвыполняет команду дважды, подставляя$sev, аseverity=$sev service=notesэто набор меток, про который мы спрашиваем.
for sev in warning critical; do
docker run --rm --entrypoint amtool -v "$PWD/alertmanager:/a:ro" \
prom/alertmanager:v0.34.1 config routes test \
--config.file=/a/alertmanager.yml severity=$sev service=notes
done
Что должно получиться:
Checking '/a/alertmanager.yml' SUCCESS
Found:
- global config
- route
- 1 inhibit rules
- 3 receivers
- 0 templates
ticket
page
(строки ticket и page печатает цикл из шага 5, по одной на каждый запуск). В браузере http://localhost:9093 открывается интерфейс Alertmanager, на http://localhost:9090/rules видны 6 правил в состоянии OK, а http://localhost:9090/config содержит секцию alerting.
Как читать amtool config routes test: команда ничего не отправляет, а только проходит по дереву route с заданными метками и печатает имя получателя. Если добавить --verify.receivers=ticket, она завершится с ошибкой, когда получатель другой: так удобно проверять маршруты в CI. Вывод проверки конфига читай так: SUCCESS и список Found значит, что Alertmanager принял конфигурацию: нашёл маршрут, одно правило подавления и три получателя. Строка ticket это имя получателя, которому достанется алерт с метками severity=warning, page для critical. Это ровно то, что мы задумали в маршрутах.
Объясни себе:
- Что произойдёт с алертом
severity=info, для которого нет ветки?
Типичные ошибки:
err="yaml: unmarshal errors: line 3: field group_by_ not found"илиunknown fields in route: опечатка в имени ключа. Alertmanager строго проверяет схему и не стартует.level=ERROR msg="Error on notify" ... dial tcp: lookup webhook on 127.0.0.11:53: no such host: приёмник в другой сети или не запущен. Оба сервиса должны быть в одномcompose.ymlи сетиnotes-net.- В Prometheus на странице Status > Alertmanager Discovery (или в
curl localhost:9090/api/v1/alertmanagers) нет Alertmanager: не выполнена перезагрузка.docker compose kill -s HUP prometheusперечитывает конфиг, перезапуск не нужен.
Задание 3. Уроним сервис и проследим алерт до webhook
Цель: пройти весь путь: inactive, pending, firing, уведомление; попробовать silence.
Предскажи: алерт NotesDown имеет for: 2m, group_wait: 30s, пробы идут каждые 15 секунд. Через сколько примерно после остановки сервиса в приёмник придёт первый POST?
Ответ
Около трёх минут: до 15 секунд на обнаружение (проба стала красной), две минуты for в состоянии pending, плюс до 15 секунд на цикл вычисления правил и 30 секунд group_wait в Alertmanager. Итого от 2,5 до 3 минут.
Шаги:
- Останови приложение и следи за состоянием правила.
docker compose stop notesостанавливает сервисnotes.watch -n 5 "команда"повторяет команду каждые 5 секунд и перерисовывает экран. Внутри:curl -sтихо запрашивает страницу,localhost:9090/api/v1/alertsэто API Prometheus со списком активных алертов,|передаёт ответ вjq(разбор JSON),-rпечатает без кавычек,.data.alerts[]перебирает алерты,[.labels.alertname, .state]собирает пару «имя, состояние»,@tsvпечатает её через табуляцию.
cd ~/notes
docker compose stop notes
watch -n 5 "curl -s localhost:9090/api/v1/alerts | jq -r '.data.alerts[] | [.labels.alertname, .state] | @tsv'"
Сначала оба алерта в pending, через минуту NotesMetricsDown станет firing, а NotesDown только через две минуты (выход из watch: Ctrl+C).
- Когда
NotesDownстанетfiring, подожди ещё 30 секунд и проверь, что Alertmanager получил алерт и куда его отправил, и что дошёл вебхук. Первая команда спрашивает у API Alertmanager список его алертов, вторая печатает последние 5 строк лога приёмника (logs ... --tail 5).
curl -s localhost:9093/api/v2/alerts | jq -r '.[] | [.labels.alertname, .labels.severity, .status.state] | @tsv'
docker compose -f monitoring/compose.yml logs webhook --tail 5
-
Верни сервис командой
docker compose start notes. Алерт снимется после ближайшего вычисления правил (до 15 секунд), а уведомлениеresolvedпридёт не позжеgroup_interval(у нас 5 минут).go-httpbinтело запроса в лог не пишет, поэтомуresolvedвидно косвенно: в логе приёмника появится ещё одинPOST /anything/page, и счётчикdocker compose -f monitoring/compose.yml logs webhook | grep -c 'POST /anything/page'вырастет на единицу, аcurl -s localhost:9090/api/v1/alertsперестанет показыватьNotesDown. Само тело с полемstatusувидишь, если подключить приёмник, который печатает тело запроса; для урока хватает пути. -
Заглуши алерт на 10 минут (silence) и убедись, что он виден как заглушенный.
--network hostдаёт контейнеру сеть твоей машины, чтобыamtoolдостучался доlocalhost:9093;silence add alertname=NotesDownсоздаёт заглушку на алерты с такой меткой;--duration=10mсрок;sleep 180ждёт, пока пройдутforиgroup_waitи алерт реально загорится (сервис нельзя поднимать раньше, иначе заглушать будет нечего);--authorи--commentкто и зачем поставил (всегда пиши комментарий, через неделю никто не вспомнит).
docker compose stop notes
docker run --rm --network host --entrypoint amtool prom/alertmanager:v0.34.1 \
--alertmanager.url=http://localhost:9093 silence add alertname=NotesDown \
--duration=10m --author=me --comment="плановые работы"
sleep 180
curl -s localhost:9093/api/v2/alerts | jq -r '.[] | select(.labels.alertname == "NotesDown") | [.labels.alertname, .status.state] | @tsv'
docker compose start notes
- Теперь останови не приложение, а прокси, и сравни, какой алерт сработает. Prometheus ходит за метриками к
notes:8080напрямую, поэтомуupостанется 1, а проба снаружи пойдёт через nginx и покраснеет.
docker compose stop proxy
sleep 180
curl -s localhost:9090/api/v1/alerts | jq -r '.data.alerts[] | [.labels.alertname, .state] | @tsv'
docker compose start proxy
Что должно получиться:
NotesDown pending
NotesMetricsDown pending
NotesMetricsDown firing
NotesDown firing
Затем в Alertmanager NotesDown critical active и NotesMetricsDown warning suppressed (предупреждение погасило правило inhibit), а в логах приёмника строка с POST /anything/page. silence add печатает id заглушки (длинная строка из букв и цифр), а после паузы последняя команда печатает NotesDown suppressed: при остановленном сервисе алерт помечен suppressed и в приёмник не идёт. После остановки прокси в Prometheus горит только NotesDown (firing), а NotesMetricsDown нет. Вывод ориентировочный: стенд после правок не поднимался.
Как читать вывод: pending значит, что условие уже истинно, но минута for не вышла; firing значит, что алерт ушёл в Alertmanager. active во втором запросе это состояние алерта в Alertmanager: он принят и не заглушен. После silence add статус меняется на suppressed: алерт жив, но уведомления не идут.
Объясни себе:
- Почему после
docker compose start notesалерт не снимается мгновенно? - Чем silence отличается от удаления правила или от
inhibit? Что будет, когда его срок истечёт, а сервис ещё лежит? - Почему при остановленном прокси горит
NotesDown, аNotesMetricsDownмолчит? Какой из двух алертов ближе к тому, что видит пользователь?
Типичные ошибки:
- В логах приёмника пусто: Alertmanager не видит Prometheus. Смотри секцию
alerting:(см. сценарий 4 ниже). curl: (7) Failed to connect to localhost port 9093: Alertmanager не запущен,docker compose -f ~/notes/monitoring/compose.yml ps alertmanager.
Задание 4. Шаг проекта: runbook на каждый алерт
Цель: к каждому алерту приложить инструкцию, по которой его сможет разобрать любой дежурный, а не только автор.
Предскажи: какие 5 разделов должен содержать runbook, чтобы человек, разбуженный в 3:00, не думал, а действовал?
Ответ
Симптом (что видит пользователь и что сработало), влияние (насколько всё плохо), проверки (команды по порядку), действия (как починить и как откатить), эскалация (кому звать, если не помогло). Каждая ссылка runbook_url из алерта ведёт именно на такой документ.
Шаги:
- Создай шесть файлов в
~/notes/docs/runbooks/(Markdown-файлы с заголовками#и##; команды в них основаны на том, что уже пройдено в темах 1, 4 и 8). Команды сsudoв runbook выполняются на хосте, а не внутри контейнера, и требуют прав администратора: у дежурного они должны быть заранее.
mkdir -p ~/notes/docs/runbooks
cat > ~/notes/docs/runbooks/NotesDown.md <<'MD'
# NotesDown: «Заметки» не отвечают
## Симптом
`probe_success{job="blackbox-https"} == 0` больше 2 минут, пользователи видят 502 или таймаут.
## Влияние
Сервис недоступен полностью. Критично, будит дежурного.
## Проверки
0. Прямая проба `probe_success{job="blackbox-direct"}` из урока 8.4: если она зелёная, а внешняя красная, ищи в `proxy` и сертификате.
1. `docker compose ps` в `~/notes`: жив ли `notes` и `proxy`, нет ли `Restarting`.
2. `docker compose logs notes --tail 50`: причина падения.
3. `curl -i --cacert ~/notes/deploy/tls/notes.crt https://notes.lab/healthz`: отвечает ли приложение через прокси (порт 8080 после урока 4.6 наружу не опубликован).
4. `docker compose ps db`: жива ли и `healthy` ли PostgreSQL.
## Действия
- Контейнер остановлен: `docker compose up -d notes`.
- Падает после смены конфига или образа: вернуть прошлый `.env` или тег, `docker compose up -d`.
- Причина в БД: разобрать `docker compose logs db`, потом перезапустить `notes`.
## Эскалация
Не поднялся за 15 минут: звать владельца сервиса (роль «владелец сервиса», канал «чат дежурных»), записать время начала для постмортема.
MD
cat > ~/notes/docs/runbooks/NotesMetricsDown.md <<'MD'
# NotesMetricsDown: Prometheus не снимает метрики «Заметок»
## Симптом
`up{job="notes"} == 0` больше минуты. Пользователи при этом могут работать нормально.
## Влияние
Остальные алерты слепнут: ошибки и задержки мы не увидим. Предупреждение. Если горит и NotesDown, работай по его runbook.
## Проверки
1. Prometheus, Status > Targets, цель `notes`: текст ошибки в колонке Error.
2. `docker compose ps notes` в `~/notes`: жив ли контейнер.
3. `docker compose logs notes --tail 50`: нет ли падений.
## Действия
- Контейнер остановлен: `docker compose up -d notes`.
- Контейнер жив, а сбор не идёт: проверь адрес `notes:8080` в `prometheus.yml` и что `/metrics` внутри сети отвечает.
## Эскалация
Не разобрался за 30 минут: завести задачу владельцу мониторинга (роль «владелец мониторинга», канал «чат команды»).
MD
cat > ~/notes/docs/runbooks/NotesHighErrorRate.md <<'MD'
# NotesHighErrorRate: доля 5xx выше 5%
## Симптом
`notes:http_errors:ratio5m > 0.05` дольше 5 минут.
## Влияние
Часть пользователей получает 500/502/503, расходуется бюджет ошибок.
## Проверки
1. Какие пути: `sum by (path, status) (rate(notes_http_requests_total{status=~"5.."}[5m]))`.
2. Была ли выкатка или правка `.env` перед началом ошибок.
3. `docker compose logs notes --since 15m | grep -i error`.
4. `curl -s --cacert ~/notes/deploy/tls/notes.crt https://notes.lab/readyz`: отвечает ли БД.
## Действия
- Ошибки после выкатки: откатить на прошлый тег образа, `docker compose up -d notes`.
- Причина в БД: проверить `db`, место на диске, число соединений.
- Причина неясна, а ошибки идут: сначала снизить ущерб (откат, перезапуск), потом разбираться.
## Эскалация
Ошибки не падают 30 минут после отката: звать разработчика приложения (роль «разработчик сервиса», канал «чат дежурных»).
MD
cat > ~/notes/docs/runbooks/NotesHighLatency.md <<'MD'
# NotesHighLatency: p95 выше 500 мс
## Симптом
`notes:http_latency:p95_5m > 0.5` дольше 10 минут.
## Влияние
Сервис отвечает медленно, возможны таймауты клиентов. Предупреждение: завести задачу.
## Проверки
1. Где медленно: `histogram_quantile(0.95, sum by (le, path) (rate(notes_http_request_duration_seconds_bucket[5m])))`.
2. `docker stats --no-stream`: CPU и память контейнера `notes`.
3. Долгие запросы БД: `docker compose exec db psql -U notes -d notes -c "select pid, now() - query_start as age, query from pg_stat_activity where state = 'active' order by age desc"`.
## Действия
- Медленный SQL: индекс или ограничение выборки.
- Не хватает ресурсов: поднять лимиты или число экземпляров.
- Ожидаемый всплеск нагрузки: убедиться, что он ожидаем.
## Эскалация
Растут и задержки, и ошибки: работать по NotesHighErrorRate.
MD
cat > ~/notes/docs/runbooks/NotesDiskFillingUp.md <<'MD'
# NotesDiskFillingUp: диск заполнится меньше чем за сутки
## Симптом
`predict_linear` по `node_filesystem_avail_bytes` даёт отрицательное свободное место через 24 часа.
## Влияние
Сейчас сервис работает, через часы возможны отказы БД и логов. Предупреждение: разобрать в рабочее время.
## Проверки
1. `df -h /`: сколько занято.
2. `sudo du -xh / --max-depth=2 2>/dev/null | sort -h | tail -15`: что занимает место.
3. `docker system df`: образы, тома, кэш сборки.
4. `df` и `du` расходятся: `sudo lsof +L1` покажет удалённые, но открытые файлы.
## Действия
- Старые образы и кэш: `docker image prune`, сначала прочитай, что удалится.
- Разросшиеся логи: настроить ротацию `json-file` с `max-size`.
- Данные растут по делу: расширить диск и завести задачу на ёмкость.
## Эскалация
Свободно меньше 10%: поднять приоритет, звать владельца платформы (роль «владелец платформы», канал «чат дежурных»).
MD
cat > ~/notes/docs/runbooks/NotesCertExpiringSoon.md <<'MD'
# NotesCertExpiringSoon: сертификат истекает меньше чем через 14 дней
## Симптом
`probe_ssl_earliest_cert_expiry - time()` меньше 14 суток.
## Влияние
Сейчас всё работает. После истечения клиенты увидят ошибку сертификата, а NotesDown покраснеет. Предупреждение: сделать в рабочее время.
## Проверки
1. `openssl x509 -in ~/notes/deploy/tls/notes.crt -noout -enddate`: дата окончания.
2. Сколько дней осталось по метрике: `curl -s localhost:9090/api/v1/query --data-urlencode 'query=(probe_ssl_earliest_cert_expiry{job="blackbox-https"} - time()) / 86400' | jq -r '.data.result[].value[1]'`.
## Действия
- Выпусти новый сертификат тем же способом, что в уроке 4.6, и положи в `~/notes/deploy/tls/`.
- Перезапусти `proxy` в каталоге `~/notes`: `docker compose up -d --force-recreate proxy`.
- Blackbox должен получить тот же файл (`ca_file` из урока 8.4), а он живёт в отдельном проекте: `docker compose -f monitoring/compose.yml up -d --force-recreate blackbox`.
## Эскалация
Осталось меньше 3 суток: поднять срочность, звать владельца платформы (роль и канал как в NotesDiskFillingUp).
MD
- Закоммить результат: правила, конфигурация, тест и документация живут в git, как и код.
cd ~/notes
git add monitoring docs/runbooks
git commit -m "Алерты, Alertmanager и runbook (урок 8.5)"
Что должно получиться:
[main 3f1c2ab] Алерты, Alertmanager и runbook (урок 8.5)
9 files changed, 291 insertions(+)
Хеш и число строк будут другими. Проверка: ls ~/notes/docs/runbooks показывает ровно 6 файлов, имена совпадают со значениями alertname (по ним построены runbook_url), а promtool check rules из задания 1 по-прежнему проходит.
Как читать вывод: в квадратных скобках ветка и короткий хеш коммита, дальше твоё сообщение; вторая строка сколько файлов изменено и сколько строк добавлено.
Объясни себе:
- Почему имя файла runbook совпадает с
alertname? - Чем плохо «Проверь состояние сервиса» в разделе проверок?
Типичные ошибки:
fatal: pathspec 'monitoring' did not match any files: команда запущена не из~/notes. Перейди в корень репозитория.runbook_urlведёт на 404: файл ещё не запушен на GitHub, или имя файла отличается отalertnameрегистром.
Сломай и почини
В этом разделе ты тренируешь главный навык дежурного: по симптому найти причину. Скрипт сам ломает мониторинг, и читать его целиком не нужно: диагностика и есть упражнение. Перед запуском посмотри только, какие команды он выполняет. Скрипт правит только файлы в ~/notes/monitoring/, поэтому запускай его от своего пользователя (не через sudo) и только на учебной ВМ.
Скачай скрипт. У curl флаг -f означает «при ошибке сервера не сохраняй страницу с ошибкой», -s тихий режим, -S всё же показывать ошибки, -L разрешает переходы по перенаправлениям, -o задаёт имя файла:
curl -fsSL -o /tmp/break-8.5.sh https://raw.githubusercontent.com/distinguished-sre/learning/main/devops/project/notes/break/8.5/break.sh
grep -nE 'sed|awk|rm|docker|sudo|curl' /tmp/break-8.5.sh
bash /tmp/break-8.5.sh 1
Сценарии: 1, 2, 3 и 4. Проходи по одному: запусти, найди причину, почини сам или командой bash /tmp/break-8.5.sh fix, потом бери следующий. В конце выполни fix и удали скрипт: rm /tmp/break-8.5.sh.
Симптом
- Сценарий 1. Ты остановил
notes(docker compose stop notes) и ждёшь минимум три минуты.NotesDownпришёл, но в Prometheus (curl -s localhost:9090/api/v1/alerts) нет алертаNotesMetricsDown, хотяupдляnotesравен 0. - Сценарий 2. Ты создаёшь ошибки в цикле и получаешь уведомления пачками «сработал, снялся, сработал» каждые несколько минут:
for i in $(seq 200); do curl -s --cacert ~/notes/deploy/tls/notes.crt https://notes.lab/error -o /dev/null; sleep 0.3; done
- Сценарий 3. Один и тот же алерт приходит в приёмник заново каждую минуту, хотя ничего не изменилось.
- Сценарий 4. В Alertmanager пусто (
curl -s localhost:9093/api/v2/alertsвозвращает[]) при том, что в Prometheus алертfiring.
Гипотезы
Выпиши свои по каждому симптому. Типичные причины и что о них скажет теория:
- Алерта нет вообще (например,
NotesMetricsDown): вexprлишний фильтр (условие не выполняется) или слишком длинныйfor(условие выполняется, но ждать долго). - Флаппинг (алерт мигает): нет
forи порог на границе нормы, значение прыгает вокруг него. - Дубли: слишком короткие
repeat_intervalилиgroup_interval, либо вgroup_byпопала метка, различающаяся у каждого алерта. - Пустой Alertmanager при
firingв Prometheus: нет секцииalerting:или Prometheus не перечитал конфиг.
Проверки
Каждая команда отвечает на свой вопрос. jq вырезает нужные поля из JSON, @tsv печатает их через табуляцию:
curl -s localhost:9090/api/v1/rules | jq -r '.data.groups[].rules[] | [.name, .health, .state] | @tsv' # загружены ли правила
curl -s localhost:9090/api/v1/alerts | jq -r '.data.alerts[] | [.labels.alertname, .state] | @tsv' # состояние алертов
curl -s localhost:9090/api/v1/alertmanagers | jq '.data.activeAlertmanagers' # видит ли Prometheus Alertmanager
Пустой список [] в activeAlertmanagers означает сценарий 4. Метрики prometheus_notifications_dropped_total (отброшенные уведомления) и prometheus_notifications_errors_total (ошибки отправки) показывают недоставку.
Исправление
Разбор всех сценариев
- Алерт не срабатывает. В выражении
NotesMetricsDownстоит условие, которомуupне соответствует (лишний фильтр по меткеinstance), илиforвыставлен в 30 минут. Вставь выражение в интерфейс Prometheus (Graph) и посмотри, возвращает ли оно ряды. Верниexpr: up{job="notes"} == 0иfor: 1m, проверьpromtool test rules, перечитай конфиг (docker compose kill -s HUP prometheus). Тест из задания 1 должен был поймать это заранее. - Флаппинг. Убери порог с границы или добавь/увеличь
for. Дополнительно можно сравнивать с окном (avg_over_time, среднее за период), чтобы сгладить шум. Флаппинг лечится в правиле, а не в Alertmanager:group_intervalлишь прячет его. - Дубли. Верни
repeat_interval: 4hиgroup_interval: 5m, аgroup_byоставь только поalertnameиservice. Уведомление «ещё горит» приходит редко, а не раз в минуту. Перечитай Alertmanager:docker compose kill -s HUP alertmanager. - Нет
alerting:. Добавь блок с цельюalertmanager:9093(имя сервиса в сетиnotes-net), перечитай конфиг. Проверьapi/v1/alertmanagers: должен быть один активный.
После исправления запусти bash /tmp/break-8.5.sh fix, если хочешь вернуть эталонное состояние, и удали временный файл: rm /tmp/break-8.5.sh.
ИИ в помощь
Общие правила работы с ИИ-помощником собраны на странице «ИИ-помощник», здесь только сценарии этой темы.
Задача: составить правило оповещения по симптому.
Метрика notes:http_errors:ratio5m хранит долю ответов 5xx за 5 минут. Напиши правило Prometheus alert на «доля ошибок больше 5% пять минут», с метками severity и аннотациями summary и runbook_url. Объясни, почему тут for, а не просто условие.
Проверь ответ: есть expr, for: 5m, метка severity, аннотация runbook_url. Типичная ошибка: алерт на загрузку CPU вместо симптома или отсутствие for. Ещё одна: нет условия по трафику, и правило будит ночью из-за одного упавшего запроса.
Задача: разобрать маршрутизацию.
Вот route из alertmanager.yml: <вставь route без секретов>. Для алертов с severity critical, warning и без метки severity скажи, какому получателю уйдёт каждый, и найди ветки, которые перекрывают друг друга.
Проверь ответ: алерт идёт по веткам сверху вниз и берёт первую подошедшую. Проверь результат командой amtool config routes test, не верь только тексту нейросети.
Задача: найти причину «меня не разбудило».
Алерт NotesDown был в Prometheus в состоянии firing, но уведомление не пришло. Назови причины по порядку проверки: Alertmanager, route, inhibit, silence, receiver.
Проверь ответ: в списке есть активный silence, inhibit_rules и неверный route. Типичная ошибка: рекомендовать перезапустить Prometheus, не проверяя сначала, дошёл ли алерт до Alertmanager.
Словарик урока
| Термин | Простыми словами |
|---|---|
| Alerting (алертинг) | автоматическая проверка условия «плохо?» и отправка сообщения человеку |
| Alerting rule (правило оповещения) | запись в YAML: имя, условие expr, время for, метки, аннотации |
expr |
условие на PromQL: алерт есть, пока запрос возвращает хотя бы один ряд |
for |
сколько условие должно держаться непрерывно, прежде чем алерт загорится |
pending / firing / inactive |
состояния алерта: ожидает срока for / горит и отправлен / условие ложно |
| Label (метка) | пара «ключ: значение» у алерта или метрики, по ним ищут и маршрутизируют |
| Annotation (аннотация) | текст для человека в алерте: summary, description, runbook_url |
| Alertmanager | программа, которая принимает алерты и решает, кому, когда и сколько раз о них сказать |
| Дедупликация | повторная отправка того же алерта не считается новым |
group_by |
по каким меткам склеивать алерты в одно сообщение |
group_wait / group_interval / repeat_interval |
ждать перед первой отправкой / как часто добавлять новое в группу / как часто напоминать о неснятом |
| Route (маршрут) | дерево условий по меткам, которое выбирает получателя |
| Receiver (получатель) | способ доставки: Telegram, почта, webhook |
| Webhook | отправка HTTP POST с JSON на указанный адрес |
| Inhibit (подавление) | пока горит главный алерт, зависимые не отправляются |
| Silence (заглушка) | ручное временное отключение уведомлений по меткам |
| Runbook | инструкция для дежурного: симптом, влияние, проверки, действия, эскалация |
| Эскалация | передача проблемы другому человеку по таймеру, а не по самооценке |
severity |
срочность: critical (будить сейчас) или warning (разобрать в рабочее время) |
| Alert fatigue | усталость от алертов: люди игнорируют сообщения из-за шума |
| Watchdog (dead man’s switch) | алерт, который горит всегда: его пропажа означает поломку самого алертинга |
promtool, amtool |
программы проверки правил Prometheus и конфигурации Alertmanager |
predict_linear |
функция прогноза значения метрики через заданное время |
| Порог (threshold) | значение метрики, за которым алерт считается сработавшим; выбирается вместе с for как компромисс между скоростью и шумом |
Вопросы с собеседований
Раздел для повторения: ответь вслух, потом открой ответ. Вопросы с пометкой «часто» задают почти на каждом собеседовании по теме урока: начни с них.
1. [junior] [часто] Ночью пришёл алерт «CPU 92%», сервис отвечает нормально. Что делаешь и что предложишь после?
Ответ
Сначала смотрю, есть ли боль у пользователей: ошибки, задержки, доступность. Если их нет, реагировать нечем, сервис просто занят. После: убираю ночной алерт по CPU, оставляю метрику на дашборде, а будить людей предлагаю по симптомам (ошибки, задержки).
Что хотят услышать: симптом против причины, алерт должен требовать действия, борьба с alert fatigue (усталостью от алертов).
Красный флаг: «просто перезагрузил сервер» или «ничего страшного, игнорируем такие алерты».
2. [junior] [часто] Зачем в правиле поле for?
Ответ
Оно требует, чтобы условие держалось всё указанное время. Один неудачный scrape (опрос цели) или короткий скачок не дают уведомления: алерт остаётся в pending. Слишком большой for задерживает реакцию, поэтому я подбираю его под цену ошибки: для падения сервиса минута, для медленных ответов десять.
Что хотят услышать: состояния pending и firing, защита от флаппинга (мигания), компромисс между шумом и задержкой.
Красный флаг: «for это как часто проверять правило».
3. [junior] [часто] Чем группировка отличается от подавления (inhibit)?
Ответ
Группировка склеивает похожие алерты в одно уведомление, но все они остаются актуальными. Подавление молчит про зависимый алерт, пока горит главный: если сервис лежит, алерт про медленные ответы этого же сервиса не нужен.
Что хотят услышать: group_by, inhibit_rules с equal, пример с зависимостью.
Красный флаг: путает inhibit и silence или считает, что группировка «удаляет» алерты.
4. [middle] [на скорость] Упал узел, дежурному пришло 40 сообщений в Telegram. Как исправить конфигурацию?
Ответ
Проверю group_by: если группировка по instance или pod, то для каждого пода отдельное уведомление. Оставлю alertname и service, подберу group_wait (30 секунд, чтобы собрать всех). Добавлю inhibit: алерт «узел недоступен» глушит алерты подов на нём. Отдельно проверю repeat_interval.
Что хотят услышать: group_by, group_wait, inhibit_rules с source_matchers/target_matchers, equal.
Красный флаг: «уберу часть алертов, чтобы их было меньше».
5. [middle] Алерт «горит» уже неделю, все привыкли и не реагируют. Что с этим делать?
Ответ
Это признак плохого алерта: если он неделю горит и никто не действует, он либо не нужен, либо порог неверен. Либо чиню причину, либо меняю порог, либо перевожу в предупреждения и удаляю из пейджера (канала срочных вызовов). Регулярно пересматриваю самые частые алерты и удаляю те, на которые не было действий.
Что хотят услышать: alert fatigue, каждый алерт требует действия, ревью шума раз в неделю или спринт.
Красный флаг: «пусть висит, это информационный алерт».
6. [middle] Как убедиться, что алертинг вообще жив, а не молчит из-за поломки?
Ответ
Держу сторожевой алерт (Watchdog, vector(1)), который горит всегда. Внешний сервис ждёт его регулярных повторов и сам поднимает тревогу, если они пропали. Так ловится падение Prometheus, Alertmanager и канала доставки. Плюс тестирую правила promtool test rules и периодически проверяю доставку реальным тестовым алертом.
Что хотят услышать: dead man’s switch, внешняя проверка, тесты правил, проверка канала.
Красный флаг: «алертов давно не было, значит всё хорошо».
7. [middle] [на скорость] Что должно быть в хорошем runbook и как ты поймёшь, что он плохой?
Ответ
Симптом, влияние, пошаговые проверки командами, действия и откат, эскалация. Плохой runbook состоит из общих слов, не содержит команд и устарел. Проверяю его на учениях: дежурный, который систему не знает, разбирает по нему инцидент. Если споткнулся, дополняю. Если команды в нём устарели, чиню после инцидента и привязываю проверку к изменениям сервиса; алерт без runbook считаю недоделанным.
Что хотят услышать: конкретные команды, эскалация, актуальность через учения, ссылка в runbook_url.
Красный флаг: «runbook это wiki-страница про архитектуру».
8. [middle] Ты добавил новое правило, оно валидно по promtool check, но никогда не срабатывает. Как проверить?
Ответ
check смотрит только синтаксис. Пишу promtool test rules с синтетическим рядом и ожидаемыми метками, тогда видно, где расходятся имена метрик и меток. В самом Prometheus запускаю выражение в Graph и проверяю, возвращает ли оно ряды на реальных данных, а на странице правил смотрю health.
Что хотят услышать: unit-тесты правил, запуск выражения на реальных данных, типичные причины (неверный label, неподходящий job).
Красный флаг: «подожду, вдруг сработает» или «поменяю пороги наугад».
9. [junior] Что такое silence в Alertmanager и когда его ставить?
Ответ
Silence - временное заглушение уведомлений по набору лейблов. Правило алерта продолжает срабатывать, но Alertmanager не отправляет сообщения, пока silence активен. Я ставлю его на время плановых работ или когда проблема известна и уже кем-то разбирается. Обязательно указываю срок и комментарий с причиной и задачей, чтобы он не остался навсегда. Удалять правило алерта вместо silence нельзя: потом его забудут вернуть.
Что хотят услышать: заглушение уведомлений по лейблам на время, правило продолжает работать, срок и комментарий, не удалять правила.
Красный флаг: бессрочные silence «чтобы не шумело».
10. [middle] Что делают group_wait, group_interval и repeat_interval?
Ответ
group_wait - сколько Alertmanager ждёт после появления первого алерта группы, чтобы собрать похожие и отправить одним сообщением. group_interval - через сколько присылать обновление, если в уже отправленную группу добавились новые алерты. repeat_interval - как часто напоминать о группе, если ничего не изменилось. Слишком маленькие значения дают лавину сообщений, слишком большие задерживают важное. Для критичных маршрутов я ставлю короткий group_wait, для шумных - подлиннее.
Что хотят услышать: назначение каждого параметра, последствия слишком маленьких и больших значений, разные значения для разных маршрутов.
Красный флаг: «repeat_interval нужен, чтобы алерт перепроверялся».
11. [junior] Ты дежурный и 20 минут не понимаешь, что происходит. Кому и как пишешь?
Ответ
Не жду, пока разберусь сам: после 20 минут без понимания зову по эскалации из runbook, а если её нет, пишу владельцу сервиса и старшему дежурному в канал дежурных. Сообщение короткое и самодостаточное: что сработало, с какого времени, что уже проверил, что видят пользователи, что нужно от человека. Параллельно продолжаю работать и фиксирую время и действия для постмортема. Лучше разбудить человека зря, чем молчать лишний час. Начинаю с оценки влияния на пользователей и, если есть простой откат, делаю его раньше поиска причины.
Что хотят услышать: эскалация по таймеру, а не по самооценке; чёткое сообщение со статусом; не прятать проблему.
Красный флаг: «сначала разберусь сам, потом позову» без срока.
12. [middle] Alertmanager запущен в двух экземплярах. Что произойдёт с уведомлениями и заглушками?
Ответ
Два экземпляра объединяют в кластер флагом --cluster.peer: они обмениваются состоянием уведомлений и заглушек (silences) и не дублируют отправку. Prometheus при этом шлёт алерты на оба экземпляра, а не через балансировщик. Заглушка, созданная на одном, через gossip (обмен сообщениями между узлами) попадает на другой. Если кластер не настроен, оба будут слать одно и то же, а заглушка на одном узле второй не остановит. Данные заглушек хранятся в каталоге данных, поэтому ему нужен постоянный том.
Что хотят услышать: кластер, gossip, оба адреса в alerting Prometheus, постоянный том, дубли без кластера.
Красный флаг: «поставлю балансировщик перед Alertmanager и всё».
Проверено на версиях
Проверено командами (Docker на Mac, 2026-09-30) на прежней версии урока из четырёх правил: promtool check rules и promtool test rules на образе prom/prometheus:v3.15.0 для файлов alerts.yml и alerts_test.yml из задания 1 (тест проходил, формат FAILED: получен намеренно испорченным тестом); amtool check-config и amtool config routes test на образе prom/alertmanager:v0.34.1 для alertmanager.yml из задания 2 (ticket для warning, page для critical).
Не прогонялось после правок (шесть правил вместо четырёх, проба blackbox-https в NotesDown, условие по трафику, том alertmanager-data; Docker и promtool при правке были недоступны): promtool check rules, promtool test rules и запросы шага 4; ранее и сейчас не прогонялось: docker compose up, вывод watch/curl к API, доставка вебхуков в go-httpbin, amtool silence add, git commit. Вывод этих команд написан по документации, значения времени приблизительные. Синтаксис compose.yml не проверялся.
- Prometheus: v3.15.0 (
promtoolиз того же образа) - Alertmanager: v0.34.1 (
amtoolиз образа) - go-httpbin: v2.18.3 (тег зафиксирован в
monitoring/compose.yml, актуальность не проверялась) - node_exporter: v1.12.1
- Docker Compose: v2 (плагин
docker compose)
Итог урока: ты умеешь
- умею написать alerting rule с
for,labelsиannotationsи объяснить состоянияinactive,pending,firing - умею отличить алерт по симптому от алерта по причине и выбрать для него срочность
criticalилиwarning - умею настроить Alertmanager:
route,group_by,repeat_interval, receivers,inhibit_rules - умею проверить маршрутизацию командой
amtool config routes testи создать silence - умею проверить правила через
promtool check rulesи написать юнит-тестpromtool test rules - умею проследить алерт от остановленного сервиса до webhook и найти, где цепочка оборвалась
- умею написать runbook с симптомом, проверками, действиями и эскалацией и привязать его через
runbook_url
Дальше: Урок 8.6: Grafana, дашборды как код
Проверь себя
Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.
Тест работает с включённым JavaScript.