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

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

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

Источник: habr.com

0 0 голоса
Рейтинг новости
1
0
Подписаться
Уведомить о
0 комментариев