🛡️ Таймауты, ретраи и circuit breaker
В монолите медленная функция тормозит один запрос. В микросервисах медленный сосед за минуты кладёт всех, кто его вызывает: горутины ждут ответа, пул соединений кончается, и сервис заказов перестаёт отвечать, хотя сам он здоров. От этого защищают четыре приёма: таймауты, ретраи, circuit breaker и bulkhead. На собеседовании их спрашивают вместе, обычно через вопрос «сервис оплаты начал отвечать по 30 секунд, что будет с системой»
🧠 Как один медленный сервис роняет остальные
Допустим, сервис заказов принимает 500 запросов в секунду, и каждый ходит в оплату. Оплата отвечает за 50 мс, значит, одновременно в работе около 25 вызовов. Потом у оплаты зависла база, и ответ стал занимать 30 секунд. Запросы продолжают приходить с той же скоростью, а уходить перестают: через 10 секунд висят уже 5000 вызовов. Каждый держит горутину, соединение из пула и память под запрос и ответ. Пул соединений кончается, и запросы, которым оплата вообще не нужна, тоже встают в очередь за соединением
Так получается каскадный отказ: проблема одного сервиса поднимается по цепочке вызовов вверх, до шлюза и пользователя. Быстрый отказ лучше медленного: ошибка за 100 мс освобождает ресурсы, ожидание 30 секунд их копит. Все четыре приёма решают одну задачу — не дать ожиданию копиться
⏱️ Таймауты и бюджет запроса
Таймаут нужен у каждого вызова по сети, без исключений. Значения по умолчанию здесь против тебя. В Go у http.Client поле Timeout по умолчанию нулевое, а ноль означает «без таймаута». gRPC тоже не ставит дедлайн сам, клиент может ждать бесконечно
Таймаут выбирают по задержке зависимости, а не на глаз. В AWS советуют сначала решить, какую долю ложных таймаутов ты готов терпеть, например 0,1%, и взять задержку соседа на этом перцентиле, то есть p99.9. Если оплата в 99,9% случаев отвечает за 300 мс, таймаут 400–500 мс отрежет зависшие вызовы и почти не заденет нормальные. Таймаут в 30 секунд «на всякий случай» не защищает ни от чего
Дедлайн всего запроса
Таймауты по отдельности не складываются в осмысленное целое. Шлюз ждёт ответа 1 секунду, заказы ждут оплату 2 секунды, оплата ждёт банк 5 секунд. Через секунду шлюз уже вернул пользователю ошибку, а заказы и оплата ещё 6 секунд работают на ответ, который никто не прочитает
Правильно думать о бюджете запроса: у запроса один дедлайн на всю цепочку, и каждый следующий вызов получает остаток. Шлюз выдал 1 секунду, заказы потратили 150 мс на базу, значит, оплате осталось 850 мс минус запас на собственный ответ. В Go это ровно то, что делает context.WithTimeout от контекста запроса: дочерний дедлайн не бывает позже родительского, подробно на странице про context
Между сервисами дедлайн нужно передать. gRPC делает это сам: клиент отправляет в заголовке grpc-timeout оставшееся время, а не абсолютный момент, поэтому расхождение часов между машинами не мешает. В Go и Java сервер передаёт этот дедлайн дальше по умолчанию, когда сам вызывает следующий сервис с контекстом запроса. В HTTP стандартного заголовка нет: остаток бюджета передают своим заголовком или держат на каждом уровне таймаут меньше, чем у уровня выше
// таймаут на вызов оплаты не длиннее остатка бюджета запроса
ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)
defer cancel()
resp, err := payments.Charge(ctx, req) // gRPC передаст дедлайн дальше самБывает, что остатка бюджета не хватает даже на одну попытку. Если до дедлайна 20 мс, а вызов в среднем занимает 50, честнее сразу вернуть ошибку, чем занимать соседа работой, которая не успеет
🔁 Ретраи
Повтор лечит временные сбои: под перезапускался, соединение оборвалось, балансировщик отправил запрос в экземпляр, который как раз выключался. Такие сбои проходят за доли секунды, и второй попытки хватает. Повторять имеет смысл:
503 Service Unavailable, gRPCUNAVAILABLE, обрыв соединения429 Too Many Requests, но не раньше, чем черезRetry-After- таймаут, если операция идемпотентна
Не повторяют 400, 401, 403, 404, 409 и ошибки валидации: вторая попытка получит тот же ответ. И не повторяют вслепую запрос с побочным эффектом. Если таймаут случился после того, как оплата списала деньги, повтор спишет их второй раз. Безопасно повторять только идемпотентные операции, а для остальных нужен ключ идемпотентности, это следующая страница модуля
Паузу между попытками растят экспоненциально и добавляют случайный разброс, jitter, иначе клиенты, упавшие одновременно, одновременно и повторят. Механика пауз и код разобраны на странице про ретраи и DLQ. Здесь важнее то, что происходит с ретраями в системе из многих сервисов
Ретраи перемножаются
Пусть вызов идёт через пять уровней, и каждый делает до трёх попыток. Когда лежит база в самом низу, она получает 3^5 = 243 запроса на каждый запрос пользователя. Этот пример приводят в статье AWS о таймаутах и ретраях. Сервис, которому и так плохо, получает в сотни раз больше нагрузки, чем обычно, и уже не поднимется
Поэтому ретраи делают на одном уровне. В книге Google SRE совет такой: повторяет только уровень сразу над тем, который отказал. Нижний уровень отвечает ошибкой «перегружен, не повторяй», а верхние пробрасывают её как есть
Бюджет ретраев
Лимит попыток на запрос не спасает, когда зависимость лежит целиком. Три попытки на каждый запрос — это всё равно втрое больше нагрузки. Нужен лимит на клиента целиком. В Google SRE описаны два: не больше трёх попыток на запрос и не больше 10% повторов от всех запросов клиента. С таким бюджетом нагрузка при отказе растёт примерно в 1,1 раза вместо почти трёх
В gRPC похожий механизм встроен и называется retryThrottling. У клиента есть счётчик токенов, каждая ошибка списывает токен, каждый успех возвращает tokenRatio. Когда токенов меньше половины, повторы прекращаются, пока зависимость не начнёт отвечать
Go · Ретраи с jitter, дедлайном и бюджетом
var errUnavailable = errors.New("503 unavailable")
// budget — бюджет ретраев по схеме retryThrottling из gRPC:
// ошибка списывает токен, успех возвращает 0.1, ниже половины — не повторяем
type budget struct {
mu sync.Mutex
tokens, limit float64
}
func (b *budget) record(ok bool) {
b.mu.Lock()
defer b.mu.Unlock()
if ok {
b.tokens = min(b.limit, b.tokens+0.1)
} else {
b.tokens = max(0, b.tokens-1)
}
}
func (b *budget) allow() bool {
b.mu.Lock()
defer b.mu.Unlock()
return b.tokens > b.limit/2
}
func retry(ctx context.Context, b *budget, base time.Duration, call func(context.Context) error) error {
const maxAttempts = 3
for attempt := 1; ; attempt++ {
err := call(ctx)
b.record(err == nil)
if err == nil || !errors.Is(err, errUnavailable) || attempt == maxAttempts || !b.allow() {
return err
}
// full jitter: случайная пауза от нуля до base·2^(attempt-1)
pause := rand.N(base << (attempt - 1))
if dl, ok := ctx.Deadline(); ok && time.Until(dl) < pause {
return err // до дедлайна не успеем, не тратим попытку
}
select {
case <-time.After(pause):
case <-ctx.Done():
return ctx.Err()
}
}
}Проверка на Go 1.27 с бюджетом на 10 токенов. Зависимость, которая дважды ответила ошибкой и потом успехом, получает три попытки, и запрос проходит. Зависимость, которая лежит целиком, на 1000 запросов получает 1003 вызова: первые два запроса успели повторить, дальше бюджет кончился. Без бюджета вызовов было бы 3000
Для gRPC свой цикл не пишут, политику задают в service config:
{
"methodConfig": [{
"name": [{ "service": "payments.v1.Payments" }],
"retryPolicy": {
"maxAttempts": 3,
"initialBackoff": "0.1s",
"maxBackoff": "1s",
"backoffMultiplier": 2,
"retryableStatusCodes": ["UNAVAILABLE"]
}
}],
"retryThrottling": { "maxTokens": 10, "tokenRatio": 0.1 }
}В Go строку передают через grpc.WithDefaultServiceConfig. Значения maxAttempts больше 5 gRPC считает за 5, а jitter у него свой: ±20% от расчётной паузы
🔌 Circuit breaker
Ретраи помогают, когда сбой короткий. Если оплата лежит уже минуту, каждый запрос к ней всё равно ждёт таймаут, полсекунды впустую, и добавляет нагрузки соседу, которому и так плохо. Circuit breaker запоминает, что зависимость сломана, и какое-то время даже не пытается её вызвать. Название взято из электрики: автомат размыкает цепь при перегрузке. Паттерн популяризировал Майкл Найгард в книге «Release It!», у автомата три состояния:
| Состояние | Что происходит с вызовом | Когда переходит дальше |
|---|---|---|
| Closed, замкнут | Идёт в зависимость, ошибки считаются | Ошибок больше порога → Open |
| Open, разомкнут | Не идёт никуда, сразу возвращает ошибку | Прошло время ожидания → Half-open |
| Half-open, полуоткрыт | Пропускает несколько пробных вызовов | Пробные прошли → Closed, упали → снова Open |
Выгоды две. Вызывающий сервис получает отказ за микросекунды вместо таймаута и не копит горутины. Зависимость получает паузу без трафика и может подняться. Порог считают по-разному: подряд идущие ошибки, как в примере ниже, или доля ошибок за скользящее окно, например больше половины неудачных вызовов за последние 30 секунд
В Go чаще всего берут sony/gobreaker. С версии v2 он обобщённый: CircuitBreaker[T] и Execute(func() (T, error)). Без настроек он размыкается после больше чем пяти ошибок подряд и стоит открытым 60 секунд
cb := gobreaker.NewCircuitBreaker[string](gobreaker.Settings{
Name: "payments",
MaxRequests: 1, // пробных запросов в half-open
Timeout: 200 * time.Millisecond, // сколько стоять открытым
ReadyToTrip: func(c gobreaker.Counts) bool {
return c.ConsecutiveFailures >= 3
},
OnStateChange: func(name string, from, to gobreaker.State) {
log.Printf("%s: %s -> %s", name, from, to)
},
})
res, err := cb.Execute(charge)На gobreaker v2.4.0 с этими настройками три ошибки подряд перевели автомат из closed в open. Четвёртый и пятый вызовы вернули circuit breaker is open, не дойдя до зависимости. Через 250 мс зависимость починилась, пробный вызов прошёл, и автомат вернулся в closed
Три решения, которые придётся принять:
- Что считать ошибкой.
404и ошибка валидации не значат, что сосед сломан. В gobreaker для этого естьIsSuccessful, по умолчанию ошибкой считается любой ненулевойerror - Где ставить автомат. Один на зависимость, а если у неё несколько независимых частей, то на каждую: медленный отчёт не должен отключать быстрые платежи. Ретраи стоят снаружи автомата, а
ErrOpenStateв список повторяемых не входит - Что делать, когда автомат открыт. У Фаулера два примера: поставить платёж в очередь на потом или показать немного устаревшие данные. Если обходного пути нет, быстрая и понятная ошибка всё равно лучше таймаута
Смена состояния автомата — событие для логов и метрик. Открытый автомат значит, что зависимость лежит, и об этом должен узнать дежурный
🧱 Bulkhead и деградация
Bulkhead — переборки в корпусе корабля: пробоина затапливает один отсек, и судно остаётся на плаву. В сервисе это отдельный лимит ресурсов на каждую зависимость. Без него медленные рекомендации занимают все горутины и соединения, и платежи встают за компанию. С ним рекомендации исчерпают только свои 10 мест, а остальные запросы пойдут как обычно
Go · Bulkhead на буферизованном канале
var errBusy = errors.New("recommendations: busy")
// bulkhead — отдельный лимит одновременных вызовов на одну зависимость
type bulkhead chan struct{}
func (b bulkhead) Do(ctx context.Context, f func(context.Context) error) error {
select {
case b <- struct{}{}:
defer func() { <-b }()
return f(ctx)
default:
return errBusy // мест нет: отказываем сразу, не ждём в очереди
}
}
// recs := make(bulkhead, 10)В проверке 15 одновременных вызовов зависимости, которая отвечает за 300 мс, дали 10 выполненных и 5 мгновенных отказов. В Go то же делают через golang.org/x/sync/semaphore, а в Kubernetes переборкой служат отдельные поды со своими requests и limits. Пул соединений на каждого соседа свой, например отдельный http.Transport с ограниченным MaxConnsPerHost, работает так же
Отказ из переборки или автомата нужно чем-то заменить. Это деградация: сервис отдаёт меньше, но отдаёт. Нет рекомендаций — блок на странице скрыт. Нет свежей цены доставки — показывают цену из кэша с пометкой. Сломан поиск по отзывам — карточка товара открывается без отзывов. Решения принимает продукт, а не разработчик в момент аварии, поэтому список «что выключаем первым» составляют заранее
Последний рубеж — сброс нагрузки на стороне сервера, load shedding. Перегруженный сервис отвечает 503 части запросов сразу, не принимая их в работу. В Google запросы помечают уровнем критичности, и при перегрузке первыми отбрасывают фоновые
⚠️ Где ошибаются
- Нет таймаута у HTTP-клиента.
http.Getи&http.Client{}ждут ответа без ограничения. Зависший сосед держит горутину до рестарта сервиса. У каждого клиента должен бытьTimeoutили контекст с дедлайном на каждый запрос - Таймаут сверху меньше, чем сумма снизу. Шлюз ждёт 1 секунду, а внутренний вызов с тремя попытками по 500 мс может длиться полторы. Ответ, полученный после ухода клиента, никому не нужен. Дедлайн передают вниз через context, а не задают на каждом уровне независимо
- Повторяют неидемпотентный запрос. Клиент не дождался ответа на
POST /paymentsи повторил. Первый запрос дошёл, второй тоже, деньги списаны дважды. Повторяют только идемпотентные операции или с ключом идемпотентности - Circuit breaker считает ошибкой отмену клиента. Пользователи закрывают вкладки,
context.Canceledсыплются, и автомат размыкается на здоровой зависимости. Отмену и ошибки клиента исключают черезIsSuccessfulилиIsExcluded
🎯 Вопросы с собеседований
Сервис, в который ты ходишь, стал отвечать за 30 секунд. Что произойдёт и как защититься?
Если таймаута нет или он большой, вызовы копятся: каждый держит горутину, соединение из пула и память. Пул кончается, и встают даже запросы, которым этот сосед не нужен, а потом сбой поднимается выше по цепочке. Защита: таймаут по перцентилю задержки соседа, бюджет ретраев, circuit breaker, чтобы перестать ходить в сломанный сервис, и bulkhead, чтобы он не занял все ресурсы. На отказ отвечают деградацией, например скрывают блок
Как выбрать таймаут?
По реальной задержке зависимости. Решают, какую долю ложных таймаутов можно терпеть, например 0,1%, и берут задержку на этом перцентиле, p99.9, с небольшим запасом. Таймаут каждого вызова не должен выходить за остаток дедлайна всего запроса. Поэтому в Go его делают дочерним от контекста запроса, а gRPC передаёт оставшееся время следующему сервису сам
Какие запросы можно повторять, а какие нет?
Повторяют временные сбои: 503, UNAVAILABLE, обрыв соединения, 429 после Retry-After. Не повторяют ошибки клиента вроде 400, 404 и 409, потому что ответ будет тем же. Таймаут повторяют, только если операция идемпотентна: GET, PUT, DELETE или POST с ключом идемпотентности. Иначе первый запрос мог выполниться, и повтор сделает работу второй раз
Почему ретраи опасны в системе из многих сервисов?
Они перемножаются. Пять уровней по три попытки дают 3^5 = 243 запроса к нижнему сервису на один запрос пользователя, и именно тогда, когда он уже не справляется. Поэтому повторяют на одном уровне, а у клиента есть бюджет: например, не больше 10% повторов от всех запросов, как в Google SRE, или retryThrottling в gRPC. Между попытками растущая пауза с jitter
Как работает circuit breaker?
У него три состояния. В closed вызовы идут в зависимость и ошибки считаются. Когда ошибок больше порога, автомат переходит в open и сразу возвращает ошибку, не вызывая зависимость. Через время ожидания он становится half-open и пропускает несколько пробных вызовов. Если они прошли, автомат возвращается в closed, если упали, снова в open. Так вызывающий сервис не ждёт таймаутов, а зависимость получает паузу, чтобы подняться
Чем circuit breaker отличается от ретраев и как их совместить?
Ретраи рассчитаны на короткий сбой и повторяют один запрос. Circuit breaker рассчитан на долгий и запоминает состояние зависимости для всех запросов. Ретраи ставят снаружи автомата: каждая попытка проходит через автомат, а ошибку «автомат открыт» не повторяют. Так при долгом сбое повторы прекращаются сами
Что такое bulkhead?
Изоляция ресурсов по зависимостям, как отсеки в корпусе корабля. У каждого соседа свой лимит одновременных вызовов или свой пул соединений, и медленный сосед исчерпывает только свой лимит. В Go это семафор на буферизованном канале или x/sync/semaphore, на уровне инфраструктуры — отдельные поды с лимитами ресурсов. Цена в том, что ресурсы делятся статически, и часть мест простаивает
📚 Что почитать
- Timeouts, retries and backoff with jitter — как в AWS выбирают таймауты, почему ретраи перемножаются и зачем им бюджет
- Handling Overload — глава книги Google SRE: бюджет ретраев, критичность запросов, адаптивный троттлинг на клиенте
- CircuitBreaker — Мартин Фаулер о трёх состояниях автомата и о том, что делать, когда он открыт
- Retry — документация gRPC:
retryPolicy, jitter иretryThrottlingв service config