Circuit Breaker: состояния, ретраи с jitter, таймауты и bulkhead на Python
Как работает Circuit Breaker: closed, open и half-open, окно ошибок, ретраи с экспоненциальной задержкой и jitter, таймауты и дедлайны, bulkhead и порядок обёрток. Код на Python.
Коротко
Circuit Breaker (автоматический выключатель) стоит между сервисом и его зависимостью. Когда зависимость начинает массово падать, он перестаёт её вызывать и сразу возвращает ошибку. Это даёт ей время подняться и не даёт вашему сервису захлебнуться в ожидании.
| Паттерн | От чего защищает | Главный параметр |
|---|---|---|
| Таймаут | вечное ожидание зависшего ответа | сколько ждать одну попытку и всю цепочку |
| Ретрай | случайных, коротких сбоев | число попыток, задержка, jitter |
| Circuit Breaker | долгого сбоя, который ретраи только усиливают | порог ошибок, окно, время в open |
| Bulkhead | одна медленная зависимость съедает все потоки | лимит одновременных вызовов |
- Состояний три: closed (вызовы идут, ошибки считаются), open (вызовы отклоняются сразу), half-open (несколько пробных вызовов решают, закрываться или снова размыкаться).
- Ретраи без jitter синхронизируют клиентов, и те бьют по серверу волнами. Ретраи без breaker'а добивают упавший сервис.
- Таймаут ставится на каждую попытку и на всю операцию целиком. Без общего дедлайна три ретрая по 5 секунд превращаются в 15 секунд ожидания для пользователя.
- Порядок обёрток важен: ретрай снаружи, breaker внутри, таймаут ближе всего к вызову.
Зачем это нужно: каскадный отказ
Сервис заказов ходит в сервис рекомендаций. У рекомендаций проблемы с базой, и ответ приходит не за 50 мс, а за 30 секунд. Что происходит дальше:
- Каждый запрос к заказам держит поток (или соединение из пула) по 30 секунд.
- Пул на 200 потоков заполняется за секунды.
- Заказы перестают отвечать на все запросы, включая те, которым рекомендации вообще не нужны.
- Сервисы, которые зовут заказы, тоже копят зависшие запросы. Отказ ползёт вверх по графу вызовов.
Быстрая ошибка лучше медленной. Если рекомендации недоступны, лучше за миллисекунду показать страницу без них, чем через 30 секунд не показать ничего. Именно эту идею Майкл Найгард описал в книге «Release It!» (2007), а Мартин Фаулер популяризировал заметкой в своём блоге в 2014 году. Общую картину паттернов устойчивости в микросервисах можно посмотреть в статье про микросервисную архитектуру.
Три состояния
доля ошибок ≥ порога
┌────────┐ ─────────────────────► ┌──────┐
│ CLOSED │ │ OPEN │ ◄─┐
└────────┘ ◄──┐ └──────┘ │
│ │ │ пробный вызов
пробные вызовы │ прошло │ │ упал
успешны │ open_timeout ▼ │
│ ┌───────────┐│
└──────────────── │ HALF-OPEN │┘
└───────────┘
Closed. Обычный режим. Вызовы проходят, breaker записывает результат каждого. Если в последнем окне доля ошибок превысила порог, он переходит в open.
Open. Вызовы не доходят до зависимости: breaker сразу бросает исключение. Вызывающий код ловит его и деградирует — отдаёт кэш, значение по умолчанию или ставит задачу в очередь. Через open_timeout breaker переходит в half-open.
Half-open. Пропускается несколько пробных вызовов. Все успешны — цепь замыкается, статистика начинается заново. Хоть один упал — снова open, и таймер стартует сначала. Остальные запросы в это время отклоняются: если пустить весь поток трафика в только что поднявшийся сервис, он упадёт обратно.
Как считать ошибки
Есть три распространённых способа.
- Подряд идущие ошибки. «5 ошибок подряд — размыкаемся». Просто, но при 50% ошибок breaker может не сработать никогда: успех между ошибками каждый раз сбрасывает счётчик.
- Окно по количеству. Последние вызовов в кольцевом буфере, размыкаемся, если доля ошибок не меньше порога. Так сделано в примере ниже. Устройство такого буфера разобрано в статье про кольцевой буфер.
- Окно по времени. Вызовы за последние секунд, обычно бакетами по секунде. Лучше подходит для неравномерного трафика.
С окнами обязательно нужен минимум вызовов. Иначе в три часа ночи два вызова, из которых один упал, дадут 50% ошибок и разомкнут цепь на пустом месте.
Ещё один важный вопрос — что считать ошибкой. Таймауты, обрывы соединения, 502/503/504 — да. 400, 404, 409 — нет: это ошибки клиента, зависимость в порядке. Если считать 404 сбоем, один кривой запрос с фронтенда отключит вам целый сервис.
Многие библиотеки, например Resilience4j, считают ошибкой ещё и медленный вызов: если больше заданной доли вызовов дольше порога, цепь размыкается, даже если они формально успешны. Это ловит деградацию до того, как начнутся таймауты.
Реализация на Python
Код потокобезопасный, часы подменяются для тестов. Окно — deque(maxlen=...), которая сама выбрасывает старые записи.
import threading import time from collections import deque from enum import Enum class State(Enum): CLOSED = 'closed' OPEN = 'open' HALF_OPEN = 'half_open' class CircuitOpenError(Exception): """Вызов отклонён без обращения к зависимости.""" class CircuitBreaker: def __init__( self, failure_threshold=0.5, # доля ошибок, при которой размыкаемся window_size=20, # сколько последних вызовов учитываем min_calls=10, # меньше вызовов — статистике не верим open_timeout=30.0, # сколько секунд держим цепь разомкнутой half_open_max_calls=3, # пробных вызовов в half-open is_failure=lambda exc: True, # какие исключения считать сбоем clock=time.monotonic, ): self.failure_threshold = failure_threshold self.min_calls = min_calls self.open_timeout = open_timeout self.half_open_max_calls = half_open_max_calls self.is_failure = is_failure self.clock = clock self._lock = threading.Lock() self._state = State.CLOSED self._results = deque(maxlen=window_size) # True — успех self._opened_at = 0.0 self._trial_in_flight = 0 self._trial_successes = 0 @property def state(self): with self._lock: self._maybe_half_open() return self._state def call(self, func, *args, **kwargs): self._before_call() try: result = func(*args, **kwargs) except Exception as exc: self._on_result(success=not self.is_failure(exc)) raise self._on_result(success=True) return result # --- внутренности: всё под замком --- def _maybe_half_open(self): if ( self._state is State.OPEN and self.clock() - self._opened_at >= self.open_timeout ): self._state = State.HALF_OPEN self._trial_in_flight = 0 self._trial_successes = 0 def _before_call(self): with self._lock: self._maybe_half_open() if self._state is State.OPEN: raise CircuitOpenError('цепь разомкнута') if self._state is State.HALF_OPEN: if self._trial_in_flight >= self.half_open_max_calls: raise CircuitOpenError('идёт пробный вызов') self._trial_in_flight += 1 def _on_result(self, success): with self._lock: if self._state is State.HALF_OPEN: if not success: self._trip() # одна ошибка — снова open return self._trial_successes += 1 if self._trial_successes >= self.half_open_max_calls: self._state = State.CLOSED self._results.clear() return if self._state is State.OPEN: return # результат вызова, начатого до размыкания self._results.append(success) if len(self._results) >= self.min_calls: failures = self._results.count(False) if failures / len(self._results) >= self.failure_threshold: self._trip() def _trip(self): self._state = State.OPEN self._opened_at = self.clock() self._results.clear()
На что обратить внимание:
- Сам вызов идёт вне замка. Под замком только проверка состояния и запись результата. Держать замок, пока идёт сетевой вызов, значит выстроить все потоки в очередь.
- Переход в half-open ленивый. Таймер не нужен: при каждом обращении сравниваем текущее время с моментом размыкания.
time.monotonic, а неtime.time. Системные часы могут прыгнуть назад при синхронизации NTP, монотонные — нет.- Запоздавшие результаты игнорируются. Вызов начался в closed, а закончился, когда цепь уже разомкнулась. Его результат не должен влиять на статистику нового цикла.
count(False)— это на каждый вызов. Для окна в 20–100 элементов это неважно. Для большого окна держите отдельный счётчик ошибок и уменьшайте его, когда из буфера уходитFalse.
Проверим с подменными часами:
class FakeClock: def __init__(self): self.now = 0.0 def __call__(self): return self.now def ok(): return 'ok' def boom(): raise ConnectionError('нет связи') clock = FakeClock() cb = CircuitBreaker( window_size=10, min_calls=4, open_timeout=5, half_open_max_calls=2, clock=clock, ) for f in [ok, boom, boom, boom]: try: cb.call(f) except ConnectionError: pass print(cb.state) # State.OPEN: 3 ошибки из 4 try: cb.call(ok) except CircuitOpenError as e: print('отклонено:', e) # отклонено: цепь разомкнута clock.now = 5 print(cb.state) # State.HALF_OPEN print(cb.call(ok), cb.state) # ok State.HALF_OPEN print(cb.call(ok), cb.state) # ok State.CLOSED
Фильтр ошибок задаётся через is_failure. Например, is_failure=lambda e: not isinstance(e, ValueError) пропустит сколько угодно ValueError («400 Bad Request»), и цепь останется замкнутой.
Где хранить состояние
Breaker из примера живёт в памяти процесса. Если у вас 50 подов, у каждого свой breaker, и каждый сам узнаёт о сбое. Обычно это нормально и даже хорошо: решение принимается по тому, что видит конкретный экземпляр, нет лишней зависимости и сетевых походов. Общее состояние в Redis делают редко: это ещё одна точка отказа и задержка на каждый вызов. А в сервисной сетке (Envoy, Istio) похожую работу берёт на себя прокси — outlier detection выкидывает из балансировки отдельные больные экземпляры.
Отдельный breaker заводят на каждую зависимость, а иногда на пару «зависимость + операция». Один breaker на все внешние вызовы разомкнётся из-за платёжки и заодно отключит вам поиск.
Ретраи: экспоненциальная задержка и jitter
Ретрай лечит короткие случайные сбои: потерянный пакет, перезапуск одного экземпляра, кратковременный 503 от балансировщика. Но повторять можно не всё:
- Повторяем: таймауты, обрывы соединения, 502, 503, 504, 429 (с учётом
Retry-After). - Не повторяем: 400, 401, 403, 404, 422 — повтор вернёт то же самое.
- Повторяем осторожно: неидемпотентные операции.
POST /paymentsпосле таймаута мог уже пройти, и без ключа идемпотентности повтор спишет деньги второй раз. Подробно об этом — в статье про идемпотентность API.
Почему не повторять сразу
Сервис упал из-за перегрузки. Тысяча клиентов получила ошибку и мгновенно повторила запрос. Нагрузка не уменьшилась, она удвоилась. Поэтому между попытками ждут, и ожидание растёт экспоненциально:
Но и этого мало. Если все клиенты упали в один момент, с одинаковой формулой они вернутся тоже одновременно: через 100 мс, через 300 мс, через 700 мс — синхронными волнами. Нужен случайный разброс, jitter. Варианты, которые разбирал Марк Брукер в известной статье в блоге AWS Architecture «Exponential Backoff And Jitter»:
| Вариант | Формула |
|---|---|
| Full jitter | |
| Equal jitter | , где |
| Decorrelated jitter |
Небольшая симуляция
Проверим на модели. 1000 клиентов одновременно приходят на сервер, который за слот 100 мс успешно обрабатывает 50 запросов, а остальным отвечает ошибкой. Клиенты повторяют, пока не получат ответ. Считаем, сколько всего запросов получил сервер и когда закончился последний клиент.
import heapq import random from collections import Counter BASE, CAP = 0.1, 10.0 def no_jitter(attempt, prev): return min(CAP, BASE * 2**attempt) def full_jitter(attempt, prev): return random.uniform(0, min(CAP, BASE * 2**attempt)) def equal_jitter(attempt, prev): half = min(CAP, BASE * 2**attempt) / 2 return half + random.uniform(0, half) def decorrelated_jitter(attempt, prev): return min(CAP, random.uniform(BASE, prev * 3)) def simulate(strategy, clients=1000, capacity=50, slot=0.1, seed=42): """Сервер обслуживает capacity запросов за слот, остальным отвечает ошибкой.""" random.seed(seed) events = [(0.0, c, 0, BASE) for c in range(clients)] # все стартуют разом heapq.heapify(events) load = Counter() # слот -> сколько запросов пришло total = 0 finish = 0.0 while events: t, client, attempt, prev = heapq.heappop(events) s = int(t / slot) load[s] += 1 total += 1 if load[s] <= capacity: finish = max(finish, t) continue # успех delay = strategy(attempt, prev) heapq.heappush(events, (t + delay, client, attempt + 1, delay)) return total, round(finish, 1) print(f"{'стратегия':<22}{'запросов':>10}{'время, с':>10}") for name, strategy in [ ('без jitter', no_jitter), ('full jitter', full_jitter), ('equal jitter', equal_jitter), ('decorrelated jitter', decorrelated_jitter), ]: total, finish = simulate(strategy) print(f'{name:<22}{total:>10}{finish:>10}')
Результат:
стратегия запросов время, с
без jitter 10500 132.7
full jitter 5005 5.8
equal jitter 4854 5.6
decorrelated jitter 3742 3.8
Без jitter все 1000 клиентов каждый раз приходят в один слот. Успевают 50, остальные 950 уходят на следующий круг, задержка удваивается и упирается в потолок 10 секунд. Сервер получил в 10 раз больше запросов, чем клиентов, а последний клиент ждал больше двух минут. Любой вариант jitter сокращает число запросов в 2–3 раза, а время — на порядок, хотя теоретический минимум здесь 2 секунды (1000 запросов по 50 за 100 мс).
Цифры между вариантами jitter зависят от параметров и сида: с другими значениями full jitter то обгоняет equal, то отстаёт, потому что время определяет самый невезучий клиент. Вывод устойчивый один: jitter нужен всегда, а какой именно — вопрос второго порядка. Full jitter проще всего объяснить и реализовать.
Ретрай с общим дедлайном
import random import time class RetryError(Exception): pass def full_jitter(attempt, base=0.1, cap=10.0): return random.uniform(0, min(cap, base * 2**attempt)) def retry( func, max_attempts=4, deadline=5.0, # общий бюджет времени на все попытки, секунды retry_on=(ConnectionError, TimeoutError), backoff=full_jitter, sleep=time.sleep, clock=time.monotonic, ): start = clock() for attempt in range(max_attempts): try: return func() except retry_on as exc: last = exc if attempt == max_attempts - 1: break delay = backoff(attempt) if clock() - start + delay > deadline: break # до следующей попытки не доживём — нет смысла ждать sleep(delay) raise RetryError(f'сдались после {attempt + 1} попыток') from last
Исключения не из retry_on пролетают наружу сразу, без повторов: ValueError от «400 Bad Request» вернётся с первой попытки. Последняя причина сохраняется через from last, чтобы в логах было видно, из-за чего сдались.
Шторм ретраев
Самая коварная проблема — умножение ретраев по слоям. Мобильный клиент делает 3 попытки, API-шлюз — 3, сервис заказов — 3 к сервису склада. Когда склад лежит, на каждое нажатие пользователя он получает запросов. Ретраи, которые должны были помогать, становятся DDoS-атакой на собственный бэкенд.
Что с этим делают:
- Ретраят в одном слое, обычно ближайшем к упавшей зависимости. Остальные слои пробрасывают ошибку.
- Бюджет ретраев. Повторы разрешены, только пока они составляют не больше, скажем, 10% от обычных запросов за последнюю минуту. Так устроен retry budget в Finagle и Linkerd. Когда сбой массовый, бюджет кончается, и ретраи сами выключаются.
- Circuit Breaker. Когда цепь разомкнута, повторять нечего: вызов отклоняется локально.
- Уважение к
Retry-Afterи 429. Если сервер прямо говорит «приходи через 30 секунд», формула backoff не нужна. Как сервер решает, кому отказать, — в статье про rate limiter.
Таймауты
Без таймаута нет и breaker'а: если вызов висит вечно, ошибка никогда не будет записана. Многие HTTP-клиенты по умолчанию ждут бесконечно, например requests без параметра timeout. Это первое, что стоит проверить в любом сервисе.
Какие бывают
- Таймаут подключения — сколько ждать установки TCP-соединения. Короткий, сотни миллисекунд: если хост недоступен, это обычно понятно быстро.
- Таймаут чтения — сколько ждать данных после подключения. Зависит от операции.
- Общий дедлайн — сколько всего мы готовы потратить на операцию, со всеми ретраями.
Как выбрать число: смотрите на перцентили задержки зависимости. Таймаут чуть выше p99 отсекает зависшие вызовы и почти не трогает нормальные. Таймаут «на всякий случай 30 секунд» не защищает ни от чего.
Дедлайн, а не сумма таймаутов
Пользователь готов ждать 2 секунды. Таймаут попытки 1 секунда, попыток 3. Без общего дедлайна худший случай — 3 секунды плюс паузы. Правильно считать остаток бюджета и не давать попытке больше, чем осталось:
import time class DeadlineExceeded(TimeoutError): pass class Deadline: def __init__(self, seconds, clock=time.monotonic): self.clock = clock self.expires_at = clock() + seconds def remaining(self): return max(0.0, self.expires_at - self.clock()) def timeout_for(self, per_call): """Таймаут очередного вызова: не больше лимита и не больше остатка.""" left = self.remaining() if left == 0: raise DeadlineExceeded('бюджет времени исчерпан') return min(per_call, left)
С бюджетом 2 секунды и лимитом попытки 1,5 секунды первая попытка получит 1,5, а вторая, начатая через 1,2 секунды, — только 0,8.
Дедлайн стоит передавать и дальше по цепочке. В gRPC это встроено: клиент задаёт deadline, он уходит в заголовке grpc-timeout, и сервер знает, когда клиенту ответ уже не нужен. В HTTP то же делают вручную через свой заголовок. Без этого нижний сервис продолжает считать ответ, который вызывающий давно выбросил. Сравнение протоколов — в статье REST vs gRPC.
Таймаут в Python: где его ставить
В синхронном коде нельзя «прервать» функцию снаружи: поток в Python не убить. Обёртка через ThreadPoolExecutor и future.result(timeout=...) вернёт управление вызывающему, но сам вызов продолжит висеть в потоке пула. Поэтому таймаут передают в клиент: requests.get(url, timeout=(0.3, 2)) (подключение и чтение), timeout в httpx, statement_timeout в PostgreSQL.
В асинхронном коде отмена работает по-настоящему:
import asyncio async def slow_inventory(): await asyncio.sleep(3) # сервис склада завис return 42 async def get_stock(): try: async with asyncio.timeout(0.5): # Python 3.11+ return await slow_inventory() except TimeoutError: return None # показываем «наличие уточняется» print(asyncio.run(get_stock())) # None через 0,5 секунды
В версиях до 3.11 то же делает asyncio.wait_for.
Bulkhead: переборки
Название из кораблестроения: корпус делят на отсеки, и пробоина в одном не топит весь корабль. В сервисе отсеки — это отдельные лимиты одновременных вызовов для каждой зависимости. Медленные рекомендации займут свои 10 слотов, а не все 200 потоков сервера.
import threading class BulkheadFullError(Exception): pass class Bulkhead: def __init__(self, max_concurrent, max_wait=0.0): self._sem = threading.BoundedSemaphore(max_concurrent) self.max_wait = max_wait # 0 — не ждём вообще def call(self, func, *args, **kwargs): if not self._sem.acquire(timeout=self.max_wait): raise BulkheadFullError('все слоты заняты') try: return func(*args, **kwargs) finally: self._sem.release()
Проверим: пять параллельных запросов, лимит два, зависимость отвечает 200 мс.
import time from concurrent.futures import ThreadPoolExecutor recommendations = Bulkhead(max_concurrent=2) def slow_recommendations(): time.sleep(0.2) # зависимость тормозит return ['товар 1', 'товар 2'] def handle_request(i): try: return recommendations.call(slow_recommendations) except BulkheadFullError: return [] # деградируем: страница без рекомендаций with ThreadPoolExecutor(max_workers=5) as pool: results = list(pool.map(handle_request, range(5))) print(sum(1 for r in results if r), 'с рекомендациями,', sum(1 for r in results if not r), 'без') # 2 с рекомендациями, 3 без
Два вызова заняли слоты, три сразу получили отказ и отдали пустой блок. Сервер при этом свободен для остальной работы. В asyncio то же делается через asyncio.Semaphore.
Есть два вида переборок:
- Семафор — лимит одновременных вызовов в общем пуле потоков. Дёшево, но если вызов завис без таймаута, поток всё равно занят.
- Отдельный пул потоков на зависимость. Изоляция сильнее, зато больше потоков и переключений контекста. Так по умолчанию работал Hystrix от Netflix.
Размер переборки прикидывают по закону Литтла: одновременных вызовов в среднем . При 200 RPS к зависимости и задержке 50 мс это 10 вызовов. Лимит ставят с запасом, в 2–3 раза выше: если он сработает при нормальной задержке, вы сами себе устроите отказ.
Пулы соединений к базе и к HTTP-сервисам — тоже переборки, только неявные. Их размер и таймаут ожидания свободного соединения стоит настраивать осознанно.
Как всё собрать вместе
Порядок обёрток, от внешней к внутренней:
retry → circuit breaker → bulkhead → timeout → вызов
- Таймаут ближе всего к вызову — каждая попытка ограничена отдельно.
- Bulkhead под breaker'ом — разомкнутая цепь отклоняет вызов, не занимая слот.
- Breaker под ретраем — каждая попытка записывается в статистику, а когда цепь размыкается, ретрай получает
CircuitOpenErrorи сразу прекращает попытки.
Похожий порядок по умолчанию использует модуль Resilience4j для Spring Boot: Retry ( CircuitBreaker ( RateLimiter ( TimeLimiter ( Bulkhead ( Function ) ) ) ) ).
from breaker import CircuitBreaker, CircuitOpenError from bulkhead import Bulkhead, BulkheadFullError from deadline import Deadline from retry import RetryError, retry payments_breaker = CircuitBreaker(min_calls=5, window_size=10, open_timeout=10) payments_bulkhead = Bulkhead(max_concurrent=20) def call_payments(send, request, budget=2.0, per_try=0.5): deadline = Deadline(budget) def attempt(): timeout = deadline.timeout_for(per_try) return payments_breaker.call( payments_bulkhead.call, send, request, timeout=timeout ) try: return retry( attempt, max_attempts=3, deadline=budget, retry_on=(ConnectionError, TimeoutError), # но не CircuitOpenError ) except (CircuitOpenError, BulkheadFullError, RetryError) as exc: return {'status': 'pending', 'reason': type(exc).__name__}
Функция send получает таймаут и передаёт его HTTP-клиенту. Прогоним сначала нестабильный шлюз, а потом мёртвый:
import random random.seed(3) def flaky(request, timeout): if random.random() < 0.3: # каждый третий ответ — 502 raise ConnectionError('502') return {'status': 'ok', 'id': request['id']} def dead(request, timeout): raise TimeoutError() for i in range(3): print(call_payments(flaky, {'id': i}), payments_breaker.state.value) for i in range(3): print(call_payments(dead, {'id': i}), payments_breaker.state.value)
{'status': 'ok', 'id': 0} closed
{'status': 'ok', 'id': 1} closed
{'status': 'ok', 'id': 2} closed
{'status': 'pending', 'reason': 'CircuitOpenError'} open
{'status': 'pending', 'reason': 'CircuitOpenError'} open
{'status': 'pending', 'reason': 'CircuitOpenError'} open
С нестабильным шлюзом ретраи прячут единичные 502: одна ошибка была, но все три платежа прошли. С мёртвым шлюзом в окне из шести вызовов набирается три ошибки, цепь размыкается прямо посреди ретраев первого запроса, и третью попытку отклоняет уже сам breaker. Следующие запросы до шлюза не доходят вовсе, а отвечают за микросекунды.
Статус pending здесь не случаен. Платёж, который не удалось провести синхронно, лучше положить в очередь и довести позже, чем показать пользователю ошибку. Об этом подробнее — в статьях про очереди сообщений и паттерн Saga.
Fallback: что делать, когда цепь разомкнута
Breaker только сообщает «туда сейчас нельзя». Что показать пользователю, решает бизнес:
- Кэш. Последний успешный ответ, даже немного устаревший. Курс валют пятиминутной давности обычно лучше, чем ошибка. Стратегии разобраны в статье про кэширование.
- Значение по умолчанию. Нет персональных рекомендаций — показываем популярные товары.
- Отложенная обработка. Принимаем заказ, отправку письма ставим в очередь.
- Честная ошибка. Если без зависимости операция невозможна (списание денег без платёжки), быстрый понятный отказ всё равно лучше 30-секундного зависания.
Мониторинг
Breaker, который никто не видит, опасен. Минимум метрик:
- состояние каждого breaker'а и число переходов между состояниями;
- число отклонённых вызовов:
CircuitOpenErrorиBulkheadFullError; - доля ретраев от всех запросов — главный индикатор начинающегося шторма;
- перцентили задержки зависимости — по ним настраиваются таймауты.
Переход в open — повод для алерта: это значит, что пользователи уже получают деградированный ответ.
Готовые библиотеки
Писать всё самому в продакшене не обязательно. На собеседовании, впрочем, могут попросить именно реализацию.
| Язык / уровень | Что использовать |
|---|---|
| Python | pybreaker (breaker), tenacity (ретраи с backoff и jitter) |
| Java / Kotlin | Resilience4j. Hystrix от Netflix с 2018 года в режиме поддержки |
| .NET | Polly |
| Go | sony/gobreaker |
| Инфраструктура | Envoy, Istio, Linkerd: таймауты, ретраи, лимиты соединений, outlier detection |
Если ретраи настроены и в сервисной сетке, и в коде, они перемножаются так же, как слои из примера про шторм. Договоритесь, кто за них отвечает. Шлюзы на входе в систему тоже умеют всё это, см. статью про API Gateway.
Типичные ошибки
- Нет таймаута. Breaker никогда не узнает о зависшем вызове.
- Ретраи на каждом уровне. Умножение нагрузки при сбое: запросов на одно действие.
- Ретраи без jitter. Клиенты синхронизируются и бьют волнами.
- Ретрай неидемпотентной операции без ключа идемпотентности — двойное списание.
- 4xx считаются сбоем. Ошибки клиента размыкают цепь на здоровом сервисе.
- Нет минимума вызовов. Две случайные ошибки ночью — и цепь разомкнута.
- Один breaker на всё. Сбой одной зависимости отключает остальные.
- Half-open пропускает весь трафик. Только что поднявшийся сервис падает обратно.
- Ретрай ловит
CircuitOpenError. Повторять локальный отказ бессмысленно, только лишние паузы. - Таймаут через поток в синхронном Python. Вызывающий освободился, а поток с зависшим запросом — нет.
Как рассказывать на собеседовании
Circuit Breaker редко бывает отдельной задачей. Обычно он всплывает на вопросе «а что будет, если сервис X упадёт?» в середине любого системного дизайна. Хороший ответ укладывается в несколько шагов (общая схема разговора — в статье про подходы к проектированию систем):
- Таймауты на каждый вызов и общий дедлайн, по p99 задержки.
- Ретраи только для временных ошибок и идемпотентных операций, экспоненциальная задержка с jitter, в одном слое, с бюджетом.
- Circuit Breaker на каждую зависимость: окно, порог, минимум вызовов, half-open с несколькими пробными запросами.
- Bulkhead, чтобы медленная зависимость не съела все потоки.
- Fallback для каждого случая: кэш, значение по умолчанию, очередь.
- Метрики и алерты на переходы состояний и долю ретраев.
Частые уточняющие вопросы и короткие ответы на них:
- Почему не держать цепь открытой, пока сервис не поднимется? Breaker не знает, когда сервис поднялся. Half-open — дешёвый способ это проверить.
- Чем breaker отличается от rate limiter? Limiter защищает сервер от клиентов, breaker защищает клиента и сервер от последствий сбоя. Первый смотрит на число запросов, второй на их результат.
- Почему не использовать общий breaker на все поды через Redis? Лишняя точка отказа и задержка на каждый вызов, а локальная статистика быстро сходится сама.
- Что выбрать: full или decorrelated jitter? Оба сильно лучше, чем без jitter. Full проще, decorrelated в некоторых моделях даёт меньше запросов.