К содержимому
Войти

Go Road Map

🛡️ Таймауты, ретраи и 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, gRPC UNAVAILABLE, обрыв соединения
  • 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

Три решения, которые придётся принять:

  1. Что считать ошибкой. 404 и ошибка валидации не значат, что сосед сломан. В gobreaker для этого есть IsSuccessful, по умолчанию ошибкой считается любой ненулевой error
  2. Где ставить автомат. Один на зависимость, а если у неё несколько независимых частей, то на каждую: медленный отчёт не должен отключать быстрые платежи. Ретраи стоят снаружи автомата, а ErrOpenState в список повторяемых не входит
  3. Что делать, когда автомат открыт. У Фаулера два примера: поставить платёж в очередь на потом или показать немного устаревшие данные. Если обходного пути нет, быстрая и понятная ошибка всё равно лучше таймаута

Смена состояния автомата — событие для логов и метрик. Открытый автомат значит, что зависимость лежит, и об этом должен узнать дежурный

🧱 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