События без потерь: брокер, outbox, идемпотентный consumer

Вторая часть капстона: путь записи. Брокер недоступен — редирект не должен ждать его, а потеря кликов должна быть видна; процесс упал между записью ссылки и публикацией — событие не должно пропасть; сообщение пришло дважды — счёт не должен вырасти. И находка, которой не было в плане: после перезапуска брокера consumer на Java молчит десятки секунд, не сообщая об этом ничем, кроме строки в логе

В первой статье сервис научился стартовать, останавливаться и переживать отказ базы на пути чтения. Здесь — путь записи. Клик — событие, которое уходит в NATS JetStream и превращается в агрегат у consumer’а на Java. Создание ссылки — тоже событие: другим сервисам нужно знать, что ссылка появилась. На этом пути три места, где события теряются или удваиваются, и в каждом решение известно заранее — вопрос в том, работает ли оно так, как о нём пишут.

События без потерь: брокер, outbox, идемпотентный consumer

Вторая статья серии «От кода до прода: сервис с нуля». Теория гарантий доставки — в статье о гарантиях доставки и идемпотентности, 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

Присоединиться →