PunchVIDEO: Putin’s nuclear briefcase caught on camera in ChinaThe Jerusalem PostKahana must bring unity to Knesset through careful, patient action, not charging ahead - editorialInquirer Entertainment‘PBB’ housemate Calix Esguerra enjoys support of fellow pageant kingsInquirerCHR probes alleged rights violations in mass arrest of Asean protesters한겨레부전∼마산 복선전철 터널 붕괴 원인은 “허용치 20배 넘는 주입 압력”ZDF heuteEntdecken Sie das ZDF-NachrichtenstudioComplete SportsFIFA Unveils NFF Normalisation CommitteeHet Laatste Nieuws“Het wachten meer dan waard”: ook BV’s vieren de release van langverwachte game ‘GTA VI’RapplerAs Meta bets big on Muse AI agent, early safety mishaps surfaceThe Sydney Morning HeraldAustralian cricket’s reputation on the brink of being reduced to ashesNDTVStock Market Today: Green Energy Stock In Focus After Rs 12.98 Crore Windfall. Should You Buy?TagesschauLiveblog zum APEC-Gipfel: ++ Trump und Putin beenden ihr Gespräch ++
The Daily Newsstand · Free, Always
Thursday, November 19, 2026

Ретраи, которые вы добавили ради надёжности, не дают сервису подняться после сбоя

Translate

Платёжный сервис лёг на десять секунд. Перезапустился под, пересобрался пул соединений к базе. Через десять секунд он здоров, health‑check зелёный, CPU в норме. А ошибки идут ещё полчаса, на платежи приходит втрое больше запросов, чем обычно, и дежурный перебирает всё подряд, от базы до соседей по ноде. В итоге кто‑то от отчаяния режет трафик на шлюзе до нуля, ждёт минуту и включает обратно, после чего ошибки пропадают.

Последний шаг и есть подсказка. Сервис был в порядке. Застряла система, в состоянии, из которого она сама не выходит, пока её кормят нагрузкой. Держали её там ретраи, таймауты и очередь. Каждую из этих настроек когда‑то поставили ради надёжности, и по отдельности каждая её добавляет.

Четыре секунды простоя, после которых сервис уже не встаёт

Спорить на словах про ретраи бесполезно, поэтому я написал небольшую модель на Python. Сервис обрабатывает 100 запросов в секунду, клиенты присылают 80, загрузка 80%. Клиент ждёт 2 секунды, потом сдаётся и, если разрешено, повторяет. Сервис лежит с 30-й секунды, дальше меняется только длительность простоя и число повторов:

простой   без ретраев          3 ретрая          1 ретрай
  2 с     сразу                сразу             сразу
  3 с     через 3 с            через 3 с         через 3 с
  4 с     через 7 с            не восстановился  не восстановился
  5 с     через 11 с           не восстановился  не восстановился
 10 с     через 31 с           не восстановился  не восстановился

«Не восстановился» значит, что за 140 секунд наблюдения система ни разу не вышла на нормальную пропускную способность, хотя сервис давно работает. Я ожидал увидеть порог где‑то на десятках секунд, а он оказался на четырёх. Одного ретрая хватает, чтобы пятисекундный сбой стал бесконечным. Даже при загрузке 60% три ретрая не дают выбраться из пятисекундного простоя.

Такое состояние называют метастабильным отказом. Причина сбоя давно устранена, а система держит себя в аварии сама. Запросы истекают в очереди, клиенты их повторяют, повторы удлиняют очередь, и новые запросы истекают тоже. Модель упрощённая, в ней нет пулов соединений и автоскейлинга. Но форма графика та же, что в разборах настоящих инцидентов. И на ней видно, какая настройка за какую часть петли отвечает.

Таймаута нет, пока вы его не поставили

Начинается всё с клиента, который ждёт вечно. Во многих популярных HTTP‑клиентах таймаута по умолчанию нет. requests в Python будет ждать ответа бесконечно, если не передать timeout. http.Client{} в Go с нулевым Timeout тоже. У java.net.http.HttpClient таймаута запроса нет, пока его не задали в HttpRequest. В.NET HttpClient по умолчанию ждёт 100 секунд, встроенный fetch в Node.js ждёт заголовков до 300 секунд.

Пока сосед отвечает, этого никто не видит. Когда он начинает висеть, у вызывающего кончаются горутины, потоки или соединения в пуле, и он перестаёт отвечать своим клиентам. Сбой ползёт вверх по цепочке, хотя никто выше не упал.

var client = &http.Client{Timeout: 2 * time.Second}
requests.get(url, timeout=(1, 2))   # 1 с на соединение, 2 с на ответ
HttpRequest req = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(2)).build();

Значение берётся из реального p99 ответа соседа, с запасом в три‑пять раз. Таймаут в 30 секунд на всякий случай в штатном режиме ничем не мешает. При сбое он держит ресурсы полминуты на каждый висящий запрос.

Ретраи, которые перемножаются

Цепочка обычная: шлюз, потом заказы, заказы, и только потом платежи. Каждая команда добавила три попытки независимо, потому что так написано в гайде по отказоустойчивости.

Платежи не отвечают. Шлюз делает 3 попытки к заказам, на каждую заказы делают 3 попытки к платежам. На один клик пользователя платежи получают 9 запросов, на четырёх уровнях это 27, а на пяти уже 81.

В модели с одним уровнем и тремя повторами клиенты за 180 секунд отправили 48 480 запросов вместо 14 400. Нагрузка выросла в 3,4 раза в тот момент, когда сервис меньше всего способен её принять, и это ещё без перемножения по уровням.

Повторять должен один уровень, ближайший к пользователю или ближайший к причине, но не все сразу. Остальные при ошибке снизу быстро отдают ошибку наверх. В Envoy, кстати, ретраев по умолчанию нет вообще, а без настроенного бюджета он разрешает всего 3 одновременных повтора на весь кластер.

Если у вас в сайдкаре стоит num_retries: 3 и в коде сервиса ещё три попытки, вы уже перемножаете. В gRPC политика повторов задаётся в service config, и maxAttempts больше 5 клиент молча режет до 5:

{
  "methodConfig": [{
    "name": [{"service": "payments.Payments"}],
    "timeout": "1s",
    "retryPolicy": {
      "maxAttempts": 2,
      "initialBackoff": "0.1s",
      "maxBackoff": "1s",
      "backoffMultiplier": 2,
      "retryableStatusCodes": ["UNAVAILABLE"]
    }
  }]
}

maxAttempts: 2 означает исходный вызов плюс один повтор. В списке кодов нет DEADLINE_EXCEEDED: если время вышло, повтор уже никому не нужен.

Дедлайн, который не доезжает до соседа

Шлюз ждёт заказы одну секунду. Заказы ждут платежи 800 миллисекунд и при ошибке повторяют ещё дважды с паузой, так что над одним запросом они могут сидеть почти три секунды. Шлюз сдался через секунду и уже показал пользователю ошибку. Две оставшиеся секунды заказы и платежи жгут CPU и соединения к базе ради ответа, который выбросят.

Фиксится это передачей дедлайна вниз. В gRPC он едет между сервисами сам, в заголовке grpc-timeout. В HTTP его придётся передавать руками:

func callPayments(ctx context.Context, url string) (*http.Response, error) {
	ctx, cancel := context.WithTimeout(ctx, 800*time.Millisecond)
	defer cancel()
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, nil)
	if err != nil {
		return nil, err
	}
	if dl, ok := ctx.Deadline(); ok {
		req.Header.Set("X-Request-Deadline-Ms", strconv.FormatInt(dl.UnixMilli(), 10))
	}
	return client.Do(req)
}

context.WithTimeout берёт меньшее из своего значения и дедлайна родителя. Если заказы на входе восстановили дедлайн шлюза через context.WithDeadline и осталось 300 миллисекунд, платежам достанется 300, а не 800. Абсолютное время в заголовке требует синхронизированных часов. Если NTP на нодах вам не внушает доверия, передавайте остаток в миллисекундах, как делает gRPC.

Очередь из запросов, которых уже никто не ждёт

Самое неприятное в модели случилось без единого ретрая. Сервис поднялся на 40-й секунде, а нормальная работа вернулась только на 71-й. За десять секунд простоя в очередь легло 800 запросов. Клиенты бросили их через две секунды, но сервис об этом не знает и после подъёма честно обрабатывает их по порядку. Пока он разгребает мёртвых, свежие запросы стоят в конце очереди, тоже протухают, и цикл крутится.

Проверка дедлайна до начала работы стоит несколько микросекунд:

func handler(w http.ResponseWriter, r *http.Request) {
	ms, err := strconv.ParseInt(r.Header.Get("X-Request-Deadline-Ms"), 10, 64)
	if err == nil && time.Now().UnixMilli() > ms {
		http.Error(w, "deadline exceeded", http.StatusGatewayTimeout)
		return
	}
	// дальше обычная обработка
}

С ней модель восстанавливается в ту же секунду, когда сервис поднялся, и с ретраями, и без. Одна проверка на входе. Та же логика работает для Kafka и RabbitMQ: задачу, которая лежит дольше, чем её кто‑то ждёт, пропускают, а не выполняют.

Есть и второй способ, если дедлайна в запросе нет. Под перегрузкой очередь разбирают с конца, LIFO вместо FIFO: свежий запрос ещё кому‑то нужен, старый почти наверняка нет. В Facebook так и делают, переключая очередь в LIFO, когда она перестаёт успевать опустошаться.

В моей модели LIFO тоже вернул систему мгновенно, даже с тремя ретраями. Цена в том, что старые запросы не обрабатываются никогда, и их надо выкидывать по таймауту, иначе очередь растёт без конца.

Джиттер размазывает повторы, но не убирает их

Следующий совет из любой статьи про ретраи: экспоненциальная пауза со случайным разбросом. Вот обычный full jitter:

func backoff(attempt int) time.Duration {
	const base, maxDelay = 100 * time.Millisecond, 2 * time.Second
	d := base << attempt
	if d > maxDelay || d <= 0 {
		d = maxDelay
	}
	return time.Duration(rand.Int63n(int64(d)))
}

Я ждал, что он хотя бы сократит аварию. Три ретрая с джиттером в модели не восстановились так же, как без него, а запросов ушло почти столько же, 47 594 против 48 480. Джиттер раскладывает повторы по времени, но их число не меняет.

Когда суммарная нагрузка в 3–4 раза выше пропускной способности, раскладывать её бесполезно, её надо срезать. Убирать его всё равно не надо. Без него сотни клиентов после разрыва переподключаются в одну миллисекунду.

Бюджет на повторы

Срезает нагрузку бюджет ретраев: повторов не больше заданной доли от обычных запросов. Пока ошибок мало, ретраев хватает на всех. Когда ошибок много, клиент перестаёт повторять и сразу возвращает ошибку. В модели бюджет в 10% вернул систему через 51 секунду после подъёма сервиса там, где без бюджета она не вернулась вовсе.

В gRPC бюджет включается в том же service config, рядом с methodConfig:

"retryThrottling": { "maxTokens": 10, "tokenRatio": 0.1 }

Неудачный вызов отнимает токен, удачный добавляет tokenRatio, и пока токенов не больше половины maxTokens, повторов нет. В Envoy то же самое задаётся на кластере, и бюджет заменяет фиксированный лимит в 3 повтора:

circuit_breakers:
  thresholds:
  - priority: DEFAULT
    retry_budget:
      budget_percent: { value: 10.0 }
      min_retry_concurrency: 3

По умолчанию budget_percent равен 20% от активных и ожидающих запросов. Для HTTP‑клиента без сетки бюджет пишется в двадцать строк, только держать его надо один на процесс для каждого соседа. Бюджет, созданный на каждый запрос заново, ничего не ограничивает. Без мьютекса горутины его порвут:

type budget struct {
	mu                sync.Mutex
	tokens, max, ratio float64
}

func (b *budget) done(ok bool) (canRetry bool) {
	b.mu.Lock()
	defer b.mu.Unlock()
	if ok {
		b.tokens = min(b.max, b.tokens+b.ratio)
	} else {
		b.tokens = max(0, b.tokens-1)
	}
	return b.tokens > b.max/2
}

Цикл повторов с бюджетом, паузой и дедлайном:

func withRetry(ctx context.Context, b *budget, call func(context.Context) error) error {
	var err error
	for attempt := 0; attempt < 3; attempt++ {
		err = call(ctx)
		if !b.done(err == nil) || err == nil || errors.Is(err, context.DeadlineExceeded) {
			return err
		}
		select {
		case <-time.After(backoff(attempt)):
		case <-ctx.Done():
			return ctx.Err()
		}
	}
	return err
}

Повтор, который списывает деньги дважды

Последняя ошибка короче остальных, но дороже всех. Ретрай POST /payments после таймаута повторяет запрос, который мог выполниться: платёж прошёл, ответ потерялся по дороге. Без ключа идемпотентности такой повтор списывает деньги второй раз. Ключ генерирует клиент один раз на операцию и шлёт его во всех попытках, а сервис проверяет его до списания:

res, err := tx.ExecContext(ctx,
	`INSERT INTO payment_keys(key) VALUES ($1) ON CONFLICT DO NOTHING`,
	r.Header.Get("Idempotency-Key"))
if err != nil {
	return err
}
if n, _ := res.RowsAffected(); n == 0 {
	return replySaved(ctx, w, r.Header.Get("Idempotency-Key"))
}

Вставка ключа и списание идут в одной транзакции, иначе между ними снова есть окно. Повторять без ключа можно только чтения и ответы, где сервер явно сообщил, что ничего не начинал, например 503 от балансировщика до обработки.

Каждая настройка из этой статьи защищает от отказа один сервис, и каждую когда‑то добавили после конкретного инцидента. В цепочке они складываются в петлю, которая держит систему лежачей после того, как причина давно ушла.

По модели это три числа: 31 секунда восстановления без ретраев, «никогда» с тремя ретраями и ноль, когда сервис перестаёт обрабатывать запросы, которых никто не ждёт.

Сколько уровней ретраев у вас между пользователем и базой, если пройти по цепочке и посчитать вместе с сайдкарами?

Чтобы микросервисы сохраняли стабильность под нагрузкой, важно понимать особенности их взаимодействия и вовремя находить архитектурные узкие места. На бесплатных открытых уроках разберём, как проектировать взаимодействие сервисов, работать с нагрузкой и готовить инфраструктуру к росту.

  • 30 ноября, 20:00. «Почему Java-сервис тормозит: пулы и виртуальные потоки на нагрузочном тесте». Записаться.

  • 1 декабря, 20:00. «REST vs gRPC: что выбрать для взаимодействия микросервисов или внешнего API?». Записаться.

  • 15 декабря, 20:00. «Как подготовить систему к росту нагрузки и не переплачивать за инфраструктуру». Записаться.

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.