В первой статье сервис научился стартовать, останавливаться и переживать отказ базы на пути чтения. Здесь — путь записи. Клик — событие, которое уходит в NATS JetStream и превращается в агрегат у consumer’а на Java. Создание ссылки — тоже событие: другим сервисам нужно знать, что ссылка появилась. На этом пути три места, где события теряются или удваиваются, и в каждом решение известно заранее — вопрос в том, работает ли оно так, как о нём пишут.
Вторая статья серии «От кода до прода: сервис с нуля». Теория гарантий
доставки — в
статье о гарантиях доставки и идемпотентности,
outbox и inbox подробно — в
статье о transactional outbox.
Здесь — как это выглядит в одном сервисе под опытом. Стенд —
digital-cookbook/capstone/shortlinks,
оси broker_down, outbox и consumer.
Брокер недоступен: кто ждёт
Клик — аналитика, редирект — продукт. Если брокер недоступен, редирект
должен работать, а клики — либо дождаться брокера, либо потеряться так, чтобы
это было видно. Сервис публикует клики в одном из двух режимов: sync — в
обработчике редиректа, async — в ограниченный буфер, из которого публикует
фоновая горутина:
// internal/events/events.go
if p.Mode == "sync" {
return p.publish(ctx, c, h)
}
// Обработчик, начавший клик до остановки, может дойти сюда уже после Close: отмена контекста не
// останавливает горутину. Проверка closed и отправка — под одним RLock, Close закрывает очередь под
// Lock, поэтому отправки в закрытый канал (и паники) не бывает: поздний клик отклоняется и считается.
p.mu.RLock()
defer p.mu.RUnlock()
if p.closed {
p.Late.Add(1)
return nil
}
select {
case p.queue <- queued{c, h}:
default:
p.Dropped.Add(1)
}
return nil
Буфер полон — клик отбрасывается и считается в clicks_dropped_total.
Блокировка чтения вокруг постановки в очередь — для остановки: клик, пришедший
после закрытия буфера, отклоняется и считается, а не уходит в закрытый канал
(подробно — в первой статье). Это
сознательный выбор: неограниченный буфер при долгом отказе брокера съест
память процесса, блокирующая запись в буфер вернёт ожидание в редирект.
Ограниченный буфер со счётчиком потерь — честный компромисс: потеря есть, но
её видно и на неё можно повесить алерт.
Опыт: NATS остановлен, 300 редиректов, буфер на 100 кликов. Затем то же в
режиме sync.
$ python3 scripts/run-checks.py broker_down
{"variant": "broker_down", "outcome": "match", "detail": "NATS остановлен. async: все редиректы 302 — да, быстро — да, клики отброшены — да, потеря видна в метрике — да; sync: все 302 — да, быстро — нет; consumer после перезапуска NATS молчит больше 20 с при expiresIn 30s — да, меньше 15 с при 5s — да"}
В этом прогоне в режиме async отброшено 199 кликов, ещё 100 ждали в буфере, опубликовано 0. Медиана редиректа в режиме sync — примерно в 371 раз больше, чем в async.
В обоих режимах редиректы отвечают 302: ошибка публикации не доходит до
клиента. Разница в задержке. В sync каждый редирект ждёт таймаут публикации
— при недоступном брокере сервис становится медленным для всех, хотя
брокер нужен только аналитике. В async редирект не знает о брокере вовсе.
Брокер вернулся, а consumer — нет
Эта проверка появилась после первой полной сессии стенда, где две оси,
стоящие сразу после остановки брокера, разошлись с гипотезой: события
создания ссылок и клики не доходили до агрегата. Обвязка была ни при чём.
После перезапуска NATS сервис на Go переподключился сразу, поток и
durable-consumer analytics в брокере сохранились, а consumer на Java не
обрабатывал ничего — и не сообщал об этом ничем, кроме строки
heartbeatAlarm в логе.
Причина — в устройстве упрощённого API jnats. consume держит pull-запрос
к брокеру со сроком expiresIn и ждёт внутри него heartbeat. Когда брокер
перезапущен, старый pull-запрос на сервере исчез вместе с процессом, а
клиент узнаёт об этом только по пропуску heartbeat — и только после этого
переподписывается. Срок по умолчанию — 30 секунд. Настройка вынесена в
CONSUME_EXPIRES:
// consumer-java/src/main/java/shortlinks/consumer/Main.java
ConsumeOptions co = ConsumeOptions.builder().expiresIn(cfg.consumeExpires().toMillis()).build();
MessageConsumer mc = ctx.consume(co, m -> {
Опыт — тот же перезапуск NATS и время до первого клика, дошедшего до агрегата, при сроке по умолчанию и при 5 секундах. Гипотеза записана до прогона: молчание больше 20 секунд и меньше 15.
Клик дошёл до агрегата через 42 с после запуска брокера при expiresIn 30 с и через 5 с — при 5 с.
Сообщения при этом не теряются: они копятся в потоке и обрабатываются после
возобновления. Теряется время, и теряется незаметно. Метрики consumer’а —
число обработанных сообщений — в эти секунды просто не растут, и на графике
это неотличимо от «кликов сейчас нет». Видно молчание только снаружи —
по num_pending durable-consumer’а в мониторинге NATS. Именно по нему
в третьей статьеготовится, с 2 декабря
масштабируется consumer, и по нему же стоит ставить алерт на отставание.
Короткий expiresIn сокращает молчание ценой более частых запросов к брокеру.
Падение между записью и публикацией
Создание ссылки — две операции: запись в PostgreSQL и публикация события
links.created. Если делать их по очереди, между ними есть момент, когда
ссылка уже записана, а событие ещё не отправлено. Процесс, упавший в этот
момент, оставляет ссылку без события — навсегда: при перезапуске сервис не
знает, что что-то не отправлено.
Outbox закрывает этот момент: событие пишется строкой в таблицу outbox в
той же транзакции, что и ссылка, а отдельный ретранслятор публикует строки и
отмечает отправленные. Либо есть и ссылка, и событие, либо нет ни того, ни
другого:
// internal/store/postgres.go
if !p.Outbox {
return nil
}
payload, _ := json.Marshal(map[string]any{"code": l.Code, "url": l.URL, "created_at": l.CreatedAt})
_, err = tx.Exec(ctx, `INSERT INTO outbox (subject, payload) VALUES ('links.created', $1)`, payload)
return err
Ретранслятор публикует с Msg-Id вида outbox-<id>: если процесс упадёт
после публикации, но до отметки, строка будет отправлена ещё раз, и брокер
склеит повтор в окне дедупликации. Окно конечно — у потока стенда две
минуты, — поэтому дедупликация брокера не заменяет идемпотентности получателя.
Опыт: CRASH_AFTER_INSERT=true — процесс выходит сразу после коммита ссылки,
до публикации события. Два режима: прямая публикация после коммита и outbox.
После перезапуска сервиса — дошло ли событие до consumer’а.
$ python3 scripts/run-checks.py outbox
{"variant": "outbox", "outcome": "match", "detail": "падение между записью ссылки и публикацией. direct: ссылка в базе — да, событие дошло — нет; outbox: ссылка — да, событие — да"}
В режиме прямой публикации ссылка в базе есть, а события нет и не будет. С outbox ретранслятор после перезапуска находит неотправленную строку и доставляет событие.
Одно сообщение дважды
JetStream доставляет at-least-once: сообщение, не подтверждённое за
ACK_WAIT, приходит снова. Значит, consumer однажды получит то же сообщение
второй раз — если упадёт после записи в базу, но до подтверждения брокеру.
Защита — учёт обработанных событий в той же транзакции, что и агрегат:
// consumer-java/src/main/java/shortlinks/consumer/Main.java
String id = ev.path("id").asText();
boolean count = true;
if (cfg.idempotent()) {
try (PreparedStatement st = db.prepareStatement("INSERT INTO processed_events (event_id) VALUES (?) ON CONFLICT DO NOTHING")) {
st.setString(1, id);
count = st.executeUpdate() == 1;
}
}
Если строка с этим идентификатором уже есть, вставка ничего не меняет, и клик не учитывается второй раз. Подтверждение брокеру — после коммита. Порядок важен: подтвердить до коммита значит потерять клик при падении между ними.
Опыт: 100 кликов. Контроль — без падений. Затем CRASH_AFTER_COMMIT=50 —
consumer падает после 50-го коммита, не подтвердив сообщение, перезапускается,
и брокер доставляет неподтверждённое снова. Без учёта обработанных событий и с
ним.
$ python3 scripts/run-checks.py consumer
{"variant": "consumer", "outcome": "match", "detail": "без падений счёт точный — да; падение после коммита до ack: без идемпотентности пересчёт — да, с ней счёт точный — да, повторы распознаны — да; PostgreSQL перезапущен: редиректы без базы — да, consumer восстановился без перезапуска — да, счёт точный — да, соединение пересоздано — да"}
Из 100 кликов агрегат насчитал без учёта обработанных событий — 101, с учётом — 100; повторов распознано: 1.
Повтор здесь не теоретический: он случился в каждом прогоне, где consumer падал. Без учёта обработанных событий он молча завышает агрегат, и в данных это неотличимо от настоящего клика.
Последний опыт этой оси — отказ базы под consumer’ом. Первая версия
consumer’а открывала одно JDBC-соединение на всё время жизни: после
перезапуска PostgreSQL соединение мертво, каждая повторная доставка падала
на нём, и consumer крутился в ошибках, пока его не перезапустят. Теперь после
ошибки соединение проверяется и пересоздаётся, а сообщение возвращается
брокеру с задержкой — nakWithDelay, а не немедленный nak, иначе пока база
недоступна, повтор шёл бы без паузы:
// consumer-java/src/main/java/shortlinks/consumer/Main.java
db[0] = revive(db[0], cfg);
log("warn", "сообщение не обработано, придёт снова", Map.of("subject", m.getSubject(), "err", String.valueOf(e)));
// с задержкой: пока база недоступна, немедленный повтор крутил бы цикл ошибок
m.nakWithDelay(Duration.ofSeconds(1));
Опыт: ссылка прогрета в кэше, PostgreSQL остановлен, 100 редиректов (они идут из Redis, клики — в брокер), PostgreSQL запущен; consumer не перезапускается. Контроль — что соединение действительно рвалось: счётчик пересозданий больше нуля.
После перезапуска PostgreSQL кликов в агрегате — 101 из 101: без перезапуска consumer’а и без завышения.
Что гарантировано, а что нет
Слова «без потерь» в заголовке относятся не ко всем событиям одинаково. Сервис сознательно различает их по цене потери. Для клика у публикации три исхода, и считать их надо отдельно: подтверждено брокером, точно не отправлено, неизвестно.
| исход клика | счётчик | что это значит |
|---|---|---|
| подтверждён | clicks_published_total |
JetStream записал событие и ответил |
| точно не отправлен: буфер полон | clicks_dropped_total |
редирект важнее аналитики, клик отброшен до публикации |
| точно не отправлен: кончился срок остановки | clicks_unsent_on_shutdown_total и лог |
остаток буфера не публиковался (первая статья) |
| точно не отправлен: пришёл после закрытия публикатора | clicks_late_after_close_total |
обработчик дошёл до публикации, когда буфер уже закрыт: клик отклонён, а не брошен в закрытый канал |
| неизвестно | clicks_publish_failed_total |
ошибка или таймаут публикации; клик уже извлечён из буфера, повтора нет. Таймаут — это отсутствие подтверждения, а не отказ: событие могло сохраниться в потоке, а потеряться ответ |
| не учтён вовсе | — | процесс убит SIGKILL: содержимое буфера в памяти пропадает без следа |
Создание ссылки устроено иначе: outbox держит событие в той же транзакции, что и ссылку, ретранслятор дошлёт его после перезапуска, повтор публикации брокер склеит в окне дедупликации. Consumer считает клик ровно один раз — учёт обработанных событий в той же транзакции, что и агрегат, — и переживает перезапуск брокера и базы, не перезапускаясь сам.
Клики — аналитика: их потеря допустима, если она ограничена и видна. Создание ссылки — факт, на который опираются другие сервисы: его потеря недопустима, и за это платят таблицей outbox и ретранслятором.
Все эти гарантии стоят на одной предпосылке: хранилища сами не теряют
данных. На стенде в Kubernetes PostgreSQL и NATS живут на emptyDir — так
проще для опытов, но это граница. Перезапуск контейнера внутри того же пода
данные сохраняет, замена пода — удаляет. Показательный случай: PostgreSQL
цел, под NATS заменён. Поток пуст, а строки outbox уже отмечены
опубликованными — ретранслятор их не пошлёт снова, и события создания ссылок
пропадут, хотя каждая отдельная часть сделала всё правильно. В проде
хранилищам нужны постоянные тома (и для NATS — кластер JetStream с
репликацией потока), а таблице outbox — срок хранения отправленных строк,
достаточный, чтобы переиграть их после восстановления брокера.
Что дальше
Путь записи держит три отказа: брокер недоступен, процесс упал между записью и событием, сообщение пришло дважды. И один, которого не было в плане: consumer, переживший перезапуск брокера, молчит, пока не заметит пропуск heartbeat. Дальше сервис становится артефактом — образом, который повторяется байт в байт и подписан по дайджесту, — и едет на кластер: третья статьяготовится, с 2 декабря.
Обсуждение в Telegram
Присоединиться →