К содержимому
Войти

Java Road Map

✅ Гарантии доставки

Гарантия доставки отвечает на один вопрос: что будет с сообщением, если что-то упало посередине. Его можно потерять, можно обработать дважды, и третьего варианта брокер сам не даёт. На собеседовании по брокерам от кандидата ждут, что он назовёт, где теряются и дублируются сообщения, и покажет обработчик, которому дубли не страшны

🧠 Три гарантии и где они ломаются

Сообщение проходит три участка: продюсер → брокер, хранение в брокере, брокер → потребитель → результат обработки (строка в базе, письмо, списание денег). Гарантия считается для всей цепочки, и на каждом участке есть свой сбой

ГарантияЧто значитКак получается
at-most-onceсообщение обработано не больше одного раза, может потерятьсяпродюсер не повторяет отправку, потребитель подтверждает сообщение до обработки
at-least-onceсообщение не теряется, может прийти несколько разпродюсер повторяет, пока не получит подтверждение, потребитель подтверждает после обработки
exactly-onceрезультат такой, будто сообщение обработали ровно один разat-least-once плюс отсев дублей на стороне, которая пишет результат

Дубли при надёжной доставке неизбежны. Продюсер отправил сообщение, брокер записал его и ответил, но ответ потерялся в сети. Продюсер не знает, дошло ли сообщение, и у него два выхода: отправить снова (риск дубля) или не отправлять (риск потери). С потребителем то же самое: он обработал сообщение и упал до того, как подтвердил. Брокер не знает, была ли обработка, и отдаст сообщение ещё раз

Поэтому сильный ответ на вопрос «как получить exactly-once» звучит так: доставку ровно один раз в общем случае получить нельзя, можно получить обработку ровно один раз. Сообщение придёт сколько угодно раз, а результат останется один, потому что обработчик отсеивает повторы. Поэтому обычная схема на брокерах — at-least-once с идемпотентным потребителем

📤 Сторона продюсера

Kafka. Начиная с версии 0.11 у продюсера есть идемпотентный режим, а в актуальных версиях он включён по умолчанию (enable.idempotence=true). Брокер выдаёт продюсеру идентификатор (producer ID), а продюсер нумерует каждую пачку для каждой партиции. Если пришёл повтор с уже записанным номером, брокер его отбрасывает и отвечает успехом. Так ретраи после потерянного ответа не дают дублей в логе

У идемпотентного режима есть условия: acks=all, retries больше нуля и max.in.flight.requests.per.connection не больше 5. Если явно поставить что-то несовместимое, например acks=1, идемпотентность молча выключится. А если при этом явно написать enable.idempotence=true, клиент не запустится с ConfigException. Попутно идемпотентный режим сохраняет порядок внутри партиции при ретраях

Дубли отсекаются только в пределах одной сессии продюсера. Перезапустился процесс — он получит новый producer ID, и если приложение после рестарта отправит то же событие заново, в логе будет два сообщения. От этого защищают либо транзакции с постоянным transactional.id (о них ниже), либо отсев дублей на стороне потребителя по бизнес-ключу

RabbitMQ. Надёжность публикации даёт publisher confirms: брокер подтверждает, что принял сообщение и записал его в очередь. Без подтверждения продюсер переотправляет, и дубли возможны. Встроенного отсева повторов для обычных и quorum-очередей нет. Отсев есть только у streams: брокер помнит последний номер публикации для каждого именованного продюсера, но в клиентских библиотеках это выключено по умолчанию. Как включать confirms в Go, показано на странице «RabbitMQ»

📥 Сторона потребителя

Гарантию на этом участке задаёт момент, когда потребитель говорит брокеру «готово». В Kafka это коммит офсета, в RabbitMQ — ack

  • Подтвердил до обработки — at-most-once. Упал во время обработки, и сообщение потеряно: брокер считает его доставленным. В RabbitMQ так работает режим автоподтверждения (autoAck: true), документация прямо называет его небезопасным. В Kafka так выходит при коммите сразу после poll или при автокоммите, когда обработка ушла в фоновые горутины
  • Подтвердил после обработки — at-least-once. Упал между обработкой и подтверждением, и сообщение придёт снова. В RabbitMQ неподтверждённые сообщения возвращаются в очередь, когда закрылся канал или соединение, и приходят с флагом redelivered. В Kafka группа продолжит с последнего закоммиченного офсета, и всё после него прочитается повторно

Флаг redelivered подсказывает, что сообщение могло уже обрабатываться, но не доказывает этого. И наоборот: дубль может прийти без флага, если продюсер сам отправил сообщение дважды. Решать по флагу, обрабатывать или нет, нельзя

🔁 Идемпотентный потребитель

Идемпотентный обработчик даёт один и тот же результат, сколько бы раз его ни вызвали с одним сообщением. Есть три способа этого добиться, от простого к общему

1. Операция идемпотентна сама. «Поставить заказу статус paid» можно выполнить десять раз, результат один. «Прибавить 100 к балансу» — нельзя. Иногда операцию удаётся переписать: вместо balance = balance + 100 хранить список платежей с уникальным payment_id и считать баланс суммой. INSERT ... ON CONFLICT DO NOTHING по уникальному ключу превращает вставку в идемпотентную

2. Условное обновление по версии. В сообщении лежит версия или время изменения сущности, обработчик пишет update ... where id = $1 and version < $2. Повтор и устаревшее сообщение ничего не изменят. Так заодно решается проблема сообщений, пришедших не по порядку

3. Таблица обработанных сообщений. Общий способ для любой операции. У каждого сообщения есть уникальный id, обработчик в одной транзакции записывает этот id в таблицу и выполняет действие. Если id уже есть, вставка ничего не делает, и действие пропускается

create table processed_messages (
    consumer     text not null,
    message_id   text not null,
    processed_at timestamptz not null default now(),
    primary key (consumer, message_id)
);

В ключе есть consumer, потому что одно событие обрабатывают разные сервисы, и каждый ведёт свой учёт. На той же идее строится inbox — входящая таблица на стороне получателя, она разобрана на странице «Transactional outbox» вместе с отправкой

Надёжнее всего брать id, который продюсер положил в сообщение или заголовок (UUID события, payment_id). Пара «топик, партиция, офсет» в Kafka уникальна для записи в логе, но не спасёт, если продюсер сам записал событие дважды после рестарта: у копии будет другой офсет

Таблица растёт, поэтому строки старше окна возможных повторов удаляют по processed_at. Окно берут с запасом над сроком хранения в брокере и максимальной задержкой ретраев: если сообщение может вернуться через неделю, хранить id сутки бессмысленно

🛠️ На практике

Ниже два обработчика платежа на Go с pgx. Первый прибавляет сумму к балансу, второй делает то же через таблицу обработанных сообщений. Каждый получил один платёж три раза подряд, как после рестартов, и другой платёж десять раз одновременно из десяти горутин, как бывает при ребалансе. Запуск на PostgreSQL 16 в Docker:

naive      подряд ×3: 300   одновременно ×10: 1000
idempotent подряд ×3: 100   одновременно ×10: 100

Одновременные доставки тоже отсеялись. Первая транзакция вставила id и держит блокировку на этой строке уникального индекса. Остальные девять ждут на своей вставке, после коммита первой видят конфликт, ON CONFLICT DO NOTHING возвращает ноль строк, и они выходят без изменений

Go · Идемпотентный обработчик платежа через таблицу обработанных сообщений

type Payment struct {
	ID      string // id сообщения, его задаёт продюсер
	Account int
	Amount  int
}

func handlePayment(ctx context.Context, db *pgxpool.Pool, p Payment) error {
	return pgx.BeginFunc(ctx, db, func(tx pgx.Tx) error {
		tag, err := tx.Exec(ctx,
			`insert into processed_messages (consumer, message_id) values ('billing', $1)
			 on conflict do nothing`, p.ID)
		if err != nil {
			return err
		}
		if tag.RowsAffected() == 0 {
			return nil // уже обработано: дубль подтверждаем и пропускаем
		}
		_, err = tx.Exec(ctx,
			`update accounts set balance = balance + $1 where id = $2`, p.Amount, p.Account)
		return err
	})
}

После того как handlePayment вернул nil, потребитель подтверждает сообщение: коммитит офсет или шлёт ack. Если вернулась ошибка, транзакция откатилась целиком, id в таблице не остался, и повтор обработает платёж заново

🔐 Exactly-once в Kafka

Kafka умеет больше, чем at-least-once, но в узких рамках. Транзакции (тоже с версии 0.11) дают атомарную запись в несколько партиций и топиков: либо видны все сообщения транзакции, либо ни одного. Продюсеру задают transactional.id, он открывает транзакцию, пишет и коммитит или отменяет

Видимость решает потребитель настройкой isolation.level. По умолчанию она read_uncommitted, и отменённые сообщения тоже приходят. Проверка на Kafka 3.9 в Docker: продюсер с transactional.id записал три сообщения и закоммитил, потом записал ещё три и отменил. Два потребителя прочитали топик с начала:

read_uncommitted: [ok-1 ok-2 ok-3 bad-1 bad-2 bad-3]
read_committed:   [ok-1 ok-2 ok-3]

Без read_committed транзакции продюсера ничего не дают читателю. Поэтому, когда продюсер переводят на транзакции, настройку меняют и у всех потребителей топика

Где транзакции дают настоящий exactly-once — цепочка «прочитал из Kafka → обработал → записал в Kafka». Продюсер отправляет офсеты прочитанных сообщений в ту же транзакцию (sendOffsetsToTransaction в Java-клиенте), и запись результата вместе со сдвигом офсета происходят атомарно. На этом построен processing.guarantee=exactly_once_v2 в Kafka Streams. Постоянный transactional.id ещё и отсекает зомби: когда стартует новый экземпляр с тем же id, брокер увеличивает эпоху, и старый процесс, который завис и очнулся, уже не сможет ничего закоммитить

Результат, который уходит за пределы Kafka, транзакция не покрывает: строку в Postgres, HTTP-вызов, письмо. Документация Kafka пишет, что exactly-once для внешних систем требует их участия. Обычно это значит, что офсет хранят в той же базе, что и результат, или делают обработчик идемпотентным

⚠️ Где ошибаются

Проверяют дубль отдельно от действия. Записали id в Redis через SETNX, потом пошли в базу и упали. Сообщение придёт снова, Redis скажет «уже было», и платёж не проведётся никогда. Отметка и действие должны жить в одной транзакции одного хранилища

Делают отметку после действия, без транзакции. Списали деньги, упали до вставки id — повтор спишет второй раз. Порядок не спасает, спасает только атомарность

Отправляют письмо или HTTP-запрос внутри транзакции с отметкой. Транзакция откатилась, а письмо уже ушло, повтор отправит второе. Внешний вызов делают идемпотентным на стороне получателя (ключ идемпотентности в запросе, об этом страница «Идемпотентность» в модуле «Микросервисы и паттерны») или выносят в отдельный шаг со своим статусом

Считают, что идемпотентный продюсер Kafka решает всё. Он убирает дубли от сетевых ретраев внутри одной сессии. Дубль после рестарта приложения и повторное чтение после падения потребителя остаются, отсев на стороне потребителя всё равно нужен

Берут id сообщения, которого нет. Генерируют UUID в потребителе или берут id из тела, которое продюсер пересоздаёт при каждой попытке. Тогда у каждого повтора свой id, и таблица ничего не отсеивает

🎯 Вопросы с собеседований

Какие бывают гарантии доставки сообщений?

At-most-once: сообщение может потеряться, но не повторится, так выходит при подтверждении до обработки. At-least-once: не теряется, но может прийти несколько раз, так выходит при подтверждении после обработки и ретраях у продюсера. Exactly-once: результат такой, будто сообщение обработали один раз. На практике его получают как at-least-once плюс идемпотентный потребитель

Возможен ли exactly-once?

Доставка ровно один раз в общем случае невозможна: если потерялось подтверждение, отправитель не знает, дошло ли сообщение, и выбирает между дублем и потерей. Возможна обработка ровно один раз, когда повторы отсеиваются там, где пишется результат. Внутри Kafka это делают транзакции: результат и офсеты коммитятся вместе, потребители читают с read_committed. Для внешней базы — таблица обработанных id в одной транзакции с изменением данных

Как сделать потребителя идемпотентным?

Если операцию можно сделать идемпотентной саму по себе, лучше так: выставить статус, upsert по уникальному ключу, условное обновление по версии. Если нельзя, завожу таблицу обработанных сообщений с первичным ключом (consumer, message_id). В одной транзакции вставляю id через ON CONFLICT DO NOTHING и, если вставка прошла, выполняю действие. Только после коммита подтверждаю сообщение брокеру. Id беру из сообщения, его задаёт продюсер

Откуда берутся дубли в Kafka?

Со стороны продюсера — ретрай после потерянного ответа брокера. Его отсекает идемпотентный продюсер, но только в пределах одной сессии: после рестарта приложение может отправить событие ещё раз. Со стороны потребителя — падение или ребаланс между обработкой и коммитом офсета: группа перечитает всё после последнего коммита

Как работает идемпотентный продюсер Kafka?

Брокер выдаёт продюсеру producer ID, продюсер нумерует пачки для каждой партиции. Если повтор пришёл с номером, который уже записан, брокер его отбрасывает и отвечает успехом. Режим включён по умолчанию в актуальных клиентах и требует acks=all, retries больше нуля и не больше 5 запросов в полёте на соединение. Заодно он сохраняет порядок внутри партиции при ретраях

Зачем нужен isolation.level=read_committed?

Транзакционный продюсер пишет сообщения в лог сразу, а коммит или отмену отмечает отдельным маркером. С умолчанием read_uncommitted потребитель видит и сообщения отменённых транзакций. С read_committed он получает только закоммиченные и не читает дальше открытой транзакции, пока та не завершится. Без этой настройки на потребителях транзакции продюсера бессмысленны

Почему нельзя проверять дубли в Redis, а писать результат в Postgres?

Отметка и действие в двух хранилищах не атомарны. Если поставить отметку и упасть до записи в базу, повтор будет считаться дублем, и сообщение потеряется. Если сначала записать в базу и упасть до отметки, повтор выполнит действие второй раз. Отметка должна быть в той же транзакции, что и изменение данных

Сколько хранить id обработанных сообщений?

Дольше, чем сообщение может вернуться: с запасом над сроком хранения в брокере, временем ретраев и возможной перечиткой при восстановлении. Старые строки удаляют по времени обработки фоновой задачей. Если повтор может прийти через неделю после первой доставки, окно в сутки пропустит дубль

📚 Что почитать

  • Kafka Design: Message Delivery Semantics — официальный разбор трёх гарантий в Kafka, идемпотентного продюсера и транзакций
  • KIP-98 — исходное предложение про exactly-once: откуда дубли, как работают producer ID, эпохи и отсечение зомби
  • RabbitMQ: Consumer Acknowledgements and Publisher Confirms — когда сообщение возвращается в очередь, что значит redelivered и почему автоподтверждение небезопасно
  • Pattern: Idempotent Consumer — короткое описание паттерна с таблицей обработанных сообщений