📈 Метрики, Prometheus и SLO
Метрика — число, которое сервис отдаёт каждые несколько секунд: сколько пришло запросов, сколько из них упало, сколько длился самый медленный процент. Лог рассказывает про один запрос, метрика показывает, как сервису живётся в целом, и именно по метрикам срабатывает алерт в три часа ночи. На собеседовании спрашивают про типы метрик, про то, как посчитать p99, чем RED отличается от USE и что такое SLI, SLO и SLA
🧠 Как работает Prometheus
Prometheus сам ходит за метриками. Сервис поднимает HTTP-ручку /metrics и отдаёт в ней текущие значения текстом, а Prometheus раз в scrape_interval забирает их и складывает в свою базу временных рядов. По умолчанию интервал минута, а в конфиге, который идёт в архиве Prometheus, стоит 15 секунд. Эта схема называется pull: если сервис упал, Prometheus сам это заметит, потому что для каждой цели он пишет метрику up, и она станет нулём
Ответ ручки выглядит так:
http_requests_total{method="GET",route="GET /orders/{id}",code="200"} 6311
http_requests_total{method="GET",route="GET /orders/{id}",code="502"} 163Временной ряд — это имя метрики плюс конкретный набор меток. Строка с code="200" и строка с code="502" — два разных ряда, и каждый Prometheus хранит отдельно. Отсюда главное ограничение, о котором ниже: каждое новое значение метки создаёт новый ряд
Для коротких задач, которые живут меньше интервала сбора, есть Pushgateway: задача сама отправляет результат, а Prometheus забирает его оттуда. Документация Prometheus советует его только для итогов пакетных задач. Pushgateway не забывает ряды, пока их не удалить, и для запушенных метрик нет сигнала up
Хранилище бывает и другим. VictoriaMetrics, Thanos и Mimir собирают тот же формат и понимают PromQL, поэтому всё, что ниже, к ним тоже относится
📏 Четыре типа метрик
| Тип | Что хранит | Пример | Как читают |
|---|---|---|---|
| Counter | Число, которое только растёт и обнуляется при рестарте | http_requests_total | Через скорость: rate(...[5m]) |
| Gauge | Текущее значение, ходит вверх и вниз | go_goroutines, размер очереди | Как есть, max_over_time, avg |
| Histogram | Счётчики по корзинам значений плюс сумма и количество | http_request_duration_seconds | histogram_quantile для перцентилей |
| Summary | Готовые перцентили, посчитанные в самом сервисе | Время ответа по quantile="0.99" | Как есть, но сложить между экземплярами нельзя |
Абсолютное значение счётчика почти бесполезно: «6311 запросов с момента старта» ничего не говорит. Поэтому счётчик всегда читают через rate, и rate сам переживает рестарт сервиса: падение значения он принимает за обнуление и продолжает считать с нуля. Правило из документации PromQL: сначала rate, потом агрегация. Если сложить счётчики двух экземпляров и потом взять rate, рестарт одного из них выглядит как обнуление суммы. В проверке после рестарта одного из двух экземпляров rate(sum(...)) показал пик в 304 запроса в секунду, а правильный sum(rate(...)) за то же время не поднимался выше 147
Имена по соглашению Prometheus: счётчик заканчивается на _total, единицы базовые и пишутся в имени. Время в секундах (_seconds), размер в байтах (_bytes), доля от 0 до 1 (_ratio). Метрика latency_ms рядом с duration_seconds из стандартных библиотек запутает всех, кто строит дашборд
📊 Гистограммы и перцентили
Среднее время ответа врёт. Если 99 запросов прошли за 10 мс, а один за 5 секунд, среднее будет 60 мс, и дашборд покажет, что всё хорошо, хотя каждый сотый пользователь ждал пять секунд. Поэтому latency смотрят перцентилями: p99 — время, быстрее которого прошли 99% запросов. Медиана показывает обычный опыт, p99 и p99.9 — тех, кому не повезло
Классическая гистограмма раскладывает наблюдения по корзинам с верхними границами le. Корзины накопительные: в le="0.1" лежат все запросы до 100 мс, включая те, что попали в le="0.05". Последняя корзина +Inf равна общему количеству:
http_request_duration_seconds_bucket{route="GET /orders/{id}",le="0.025"} 517
http_request_duration_seconds_bucket{route="GET /orders/{id}",le="0.05"} 3214
http_request_duration_seconds_bucket{route="GET /orders/{id}",le="0.1"} 6474
http_request_duration_seconds_bucket{route="GET /orders/{id}",le="+Inf"} 6474
http_request_duration_seconds_sum{route="GET /orders/{id}"} 324.79
http_request_duration_seconds_count{route="GET /orders/{id}"} 6474Перцентиль считает Prometheus:
histogram_quantile(0.99, sum by (le) (rate(http_request_duration_seconds_bucket[5m])))Он находит корзину, в которую попал 99-й процент, и внутри корзины интерполирует линейно, считая, что значения в ней распределены равномерно. Точность ограничена шириной корзины. В проверке сервис отвечал за 20–80 мс, то есть настоящий p99 около 80 мс. Prometheus посчитал 99 мс: 99-й процент попал в корзину от 50 до 100 мс, и интерполяция растянула его к верхней границе. Поэтому границы корзин ставят там, где принимают решения. SLO «95% запросов быстрее 300 мс» требует корзину le="0.3", иначе честно посчитать его нельзя
Summary считает перцентили прямо в сервисе и точнее, но такие перцентили нельзя сложить. Среднее из p99 десяти подов — не p99 сервиса, документация Prometheus прямо называет это статистической бессмыслицей. Гистограммы складываются по корзинам, поэтому в сервисах из нескольких экземпляров выбирают их
С Prometheus 3.8 стабильны нативные гистограммы: корзины в них подбираются автоматически и с высоким разрешением, ряд на гистограмму один вместо десятка. В Go их поддерживает client_golang, в Prometheus сбор включается настройкой scrape_native_histograms. В старых проектах ты почти всегда увидишь классические
🛠️ Метрики сервиса на Go
Стандартная библиотека — github.com/prometheus/client_golang. promhttp.Handler() отдаёт всё зарегистрированное, а заодно метрики рантайма Go и процесса: go_goroutines, паузы сборщика мусора, память, открытые файлы. По go_goroutines ищут утечки горутин, о них есть страница в модуле про конкурентность
Метрики HTTP-сервера пишут в middleware: один счётчик запросов с кодом ответа и одна гистограмма времени
Go · Middleware со счётчиком и гистограммой
var (
requests = promauto.NewCounterVec(prometheus.CounterOpts{
Name: "http_requests_total",
Help: "HTTP-запросы по маршруту и коду ответа",
}, []string{"method", "route", "code"})
duration = promauto.NewHistogramVec(prometheus.HistogramOpts{
Name: "http_request_duration_seconds",
Help: "Время обработки запроса",
Buckets: []float64{0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5},
}, []string{"method", "route"})
)
type statusWriter struct {
http.ResponseWriter
code int
}
func (w *statusWriter) WriteHeader(code int) {
w.code = code
w.ResponseWriter.WriteHeader(code)
}
// instrument считает запросы и время по шаблону маршрута, а не по URL
func instrument(mux *http.ServeMux) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
sw := &statusWriter{ResponseWriter: w, code: http.StatusOK}
mux.ServeHTTP(sw, r)
_, route := mux.Handler(r) // "GET /orders/{id}", а не "/orders/1042"
if route == "" {
route = "unmatched"
}
requests.WithLabelValues(r.Method, route, strconv.Itoa(sw.code)).Inc()
duration.WithLabelValues(r.Method, route).Observe(time.Since(start).Seconds())
})
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("GET /orders/{id}", getOrder)
go http.ListenAndServe(":9100", promhttp.Handler()) // метрики на отдельном порту
http.ListenAndServe(":8080", instrument(mux))
}Сервис с этим middleware отвечал за 20–80 мс и отдавал 502 в 2% случаев. Prometheus 3.16 собирал его каждые 5 секунд и под нагрузкой показал 84 запроса в секунду, долю ошибок 2,5% и p99 0,099 с. Метка route берётся из шаблона маршрута: тысячи запросов с разными id легли в один набор рядов. Запросы мимо маршрутов падают в unmatched, иначе сканер, перебирающий случайные адреса, наплодил бы ряды сам
Метрики отдают на отдельном порту, чтобы /metrics не торчал наружу через ingress: по ним видно маршруты и нагрузку
🚦 RED, USE и золотые сигналы
Что мерить, подсказывают три известные схемы. Их спрашивают по названию
- RED для сервисов, которые обрабатывают запросы: Rate (запросов в секунду), Errors (сколько из них упало), Duration (сколько длились). Схему предложил Том Уилки, и она показывает сервис глазами пользователя
- USE Брендана Грегга для ресурсов: CPU, памяти, диска, сети, пула соединений. Utilization показывает, сколько времени ресурс был занят, Saturation — сколько работы ждёт в очереди, Errors считает ошибки ресурса
- Четыре золотых сигнала из книги Google SRE: latency, traffic, errors, saturation. По сути это RED плюс насыщенность, то есть насколько сервис заполнен
На практике их сочетают. Дашборд сервиса начинается с RED по каждому маршруту, ниже USE по его ресурсам: троттлинг CPU, память против лимита, занятые соединения пула к базе, лаг консьюмера Kafka. RED говорит, что пользователям плохо, USE подсказывает, почему
🧾 SLI, SLO, SLA и бюджет ошибок
Три термина, которые на собеседовании просят различить:
- SLI — индикатор, конкретное измеримое число. «Доля запросов к
/ordersс кодом не 5xx», «доля запросов быстрее 300 мс» - SLO — цель для индикатора на окне. «99,9% запросов без 5xx за 30 дней»
- SLA — договор с клиентом, где за нарушение есть последствия, обычно деньги: скидка или штраф. Если за промах ничего не будет, это SLO. Внутренний SLO обычно ставят строже SLA, чтобы заметить проблему до штрафа
Из SLO следует бюджет ошибок — сколько можно сломать, не нарушив цель. 100% целью не ставят: в книге Google SRE это названо нереалистичным и нежелательным, потому что такая цель запрещает любые изменения
| SLO | Бюджет за 30 дней |
|---|---|
| 99% | 7 ч 12 мин |
| 99,9% | 43,2 мин |
| 99,95% | 21,6 мин |
| 99,99% | 4,3 мин |
Бюджет работает как договорённость между разработкой и эксплуатацией. Пока он есть, команда выкатывает фичи и рискует. Кончился — фичи ждут, команда чинит надёжность
🚨 Алерты
Prometheus проверяет правила раз в evaluation_interval и отправляет сработавшие в Alertmanager, а тот группирует, глушит дубли и шлёт в Telegram или PagerDuty. Поле for задаёт, сколько условие должно держаться, прежде чем алерт станет firing. До этого он висит в pending, и короткий всплеск не будит дежурного
Документация Prometheus советует алертить по симптомам. CPU 90% — причина, и пользователи могут её не замечать. Растущая доля 5xx или p99 выше SLO — симптом, пользователям уже плохо. Причины смотрят на дашборде, когда алерт уже пришёл
Лучший алерт для сервиса с SLO — по скорости сгорания бюджета (burn rate). Скорость 1 означает, что бюджет кончится ровно к концу 30 дней. Воркбук Google SRE рекомендует будить человека при скорости 14,4 на часовом окне: за этот час сгорает 2% месячного бюджета. Короткое окно в 5 минут добавляют, чтобы алерт погас быстро, когда проблему починили
YAML · Алерт по скорости сгорания для SLO 99,9%
groups:
- name: orders-slo
rules:
# доля ошибок за окно, считается заранее
- record: job:http_errors:ratio_rate5m
expr: |
sum by (job) (rate(http_requests_total{code=~"5.."}[5m]))
/ sum by (job) (rate(http_requests_total[5m]))
- record: job:http_errors:ratio_rate1h
expr: |
sum by (job) (rate(http_requests_total{code=~"5.."}[1h]))
/ sum by (job) (rate(http_requests_total[1h]))
# SLO 99.9%: бюджет 0.1%, горим в 14.4 раза быстрее нормы
- alert: OrdersErrorBudgetBurn
expr: |
job:http_errors:ratio_rate1h{job="orders"} > (14.4 * 0.001)
and job:http_errors:ratio_rate5m{job="orders"} > (14.4 * 0.001)
for: 2m
labels:
severity: page
annotations:
summary: "orders тратит бюджет ошибок: {{ $value | humanizePercentage }} за час"Правила прошли promtool check rules, а тест promtool test rules показал: при 2% ошибок алерт срабатывает, при 1% молчит. 1% ошибок — это скорость 10, бюджет сгорит за три дня, поэтому в воркбуке рядом стоит второе правило на скорость 6 и окно 6 часов и тикет на скорость 1 за 3 дня
Сохранённые выражения record называют recording rules. Prometheus считает их по расписанию и хранит как обычные ряды, поэтому тяжёлый запрос по часовому окну не пересчитывается на каждой проверке алерта и каждом открытии дашборда
⚠️ Где ошибаются
- id пользователя или URL в метке.
route="/orders/1042"илиuser_id="7"создают по ряду на каждое значение, а у гистограммы с восемью корзинами таких рядов 11 на значение. Миллион пользователей — 11 млн рядов, и Prometheus кончается по памяти. Документация прямо запрещает метки с неограниченным набором значений. Для поиска конкретного запроса есть логи и трейсы - Среднее вместо перцентиля.
_sum / _countдаёт среднее, и в проверке оно было 50 мс, близко к медиане. Хвост оно прячет: деградацию у 1% пользователей среднее почти не сдвинет rateпослеsum. Сложенные счётчики теряют информацию о рестартах, и график показывает пики, которых не было. Сначалаrate, потомsum by- Окно
rateменьше двух интервалов сбора. При сборе раз в 30 секундrate(x[30s])часто видит одну точку и возвращает пустоту. Окно берут с запасом: переменная Grafana$__rate_intervalгарантирует хотя бы четыре точки, при сборе раз в 15 секунд это[1m] - Алерт на каждую причину. Алерты на CPU, память, диск и каждую зависимость будят по десять раз за ночь, и дежурный перестаёт их читать. Будить стоит симптомом, причины разбирать на дашборде
🎯 Вопросы с собеседований
Какие типы метрик есть в Prometheus?
Четыре. Counter только растёт и обнуляется при рестарте, его читают через rate. Gauge ходит вверх и вниз, это текущее значение вроде числа горутин или размера очереди. Histogram раскладывает наблюдения по корзинам и хранит сумму и количество, из неё считают перцентили через histogram_quantile. Summary считает перцентили в самом сервисе, но их нельзя сложить между экземплярами
Как посчитать p99 времени ответа и почему не среднее?
Пишу время в histogram, а p99 считаю запросом histogram_quantile(0.99, sum by (le) (rate(..._bucket[5m]))). Сначала rate по корзинам, потом сумма по le через все экземпляры, потом квантиль. Среднее прячет хвост: если 1% запросов идёт 5 секунд, среднее почти не сдвинется, а p99 покажет проблему. Точность p99 ограничена шириной корзины, поэтому границы ставят рядом с целевыми порогами
Чем histogram отличается от summary и что выбрать?
Summary считает квантили в процессе, точно, но каждое наблюдение дороже, а квантили разных подов нельзя сложить. Histogram в сервисе дешёвая, это просто счётчики корзин, а квантиль считает Prometheus на запросе, и корзины складываются между подами. Для сервиса из нескольких реплик выбираю histogram. Если Prometheus 3.8 и новее, можно взять нативные гистограммы, у них корзины автоматические и точнее
Что такое RED и USE?
RED для сервисов: rate, errors, duration, то есть сколько запросов, сколько упало и сколько длились. Это взгляд пользователя. USE для ресурсов: utilization, saturation, errors, например загрузка CPU, очередь на пул соединений и ошибки диска. RED говорит, что что-то не так, USE помогает найти, в каком ресурсе причина
Чем отличаются SLI, SLO и SLA?
SLI — измеримый индикатор, например доля запросов без 5xx. SLO — цель для него на окне, например 99,9% за 30 дней. SLA — договор с клиентом с последствиями за нарушение, обычно деньгами, и он мягче внутреннего SLO. Из SLO следует бюджет ошибок: при 99,9% за 30 дней это 43 минуты полной недоступности или эквивалент в доле ошибок
Почему нельзя класть user_id в метку?
Каждая уникальная комбинация меток — отдельный временной ряд, который Prometheus держит в памяти и индексирует. С user_id рядов станет столько, сколько пользователей, а у гистограммы ещё умножится на число корзин. Это называется высокой кардинальностью, и она кладёт Prometheus по памяти. Метки должны иметь ограниченный набор значений: маршрут по шаблону, код ответа, метод
Как ты построишь алерты для нового сервиса?
Сначала договорюсь об SLO: доступность и latency на основных маршрутах. Алерт будет по симптомам: скорость сгорания бюджета ошибок на двух окнах, час и 5 минут, с порогом 14,4 для пейджа, и медленное сгорание за несколько дней в тикет. В правиле for на пару минут, чтобы не будить из-за всплеска. Причины вроде CPU и памяти вынесу на дашборд, который откроет дежурный
Prometheus сам ходит за метриками. Что делать с cron-задачей, которая живёт 10 секунд?
Prometheus может не успеть её собрать между интервалами. Для итогов пакетной задачи есть Pushgateway: задача пушит туда, например, время последнего успешного запуска, а Prometheus собирает его оттуда. Минусы: Pushgateway не забывает ряды, пока их не удалить, и для запушенных метрик нет up. Алерт ставлю на «давно не было успешного запуска»: одно упавшее выполнение ещё не повод будить человека
📚 Что почитать
- Metric types — четыре типа и как устроены классические и нативные гистограммы
- Histograms and summaries — таблица выбора и разбор ошибки квантиля на широких корзинах
- Service Level Objectives — глава книги Google SRE про SLI, SLO и SLA и почему не 100%
- Alerting on SLOs — как дойти до алертов по скорости сгорания бюджета, шаг за шагом