Привет, Хабр!

Платёжный сервис лёг на десять секунд. Перезапустился под, пересобрался пул соединений к базе. Через десять секунд он здоров, 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. «Как подготовить систему к росту нагрузки и не переплачивать за инфраструктуру». Записаться.

Комментарии (0)