Чи може Kafka замінити Redis для синхронізації кешу? Відповідь із продакшену
Нещодавно натрапив на запитання в r/apachekafka, яке точно схоплює типову проблему синхронізації кешу: Чи може Kafka замінити Redis для синхронізації кешу між кількома pod’ами Spring Boot?
Оригінальне запитання, переказанеSpring Boot на GCP, ~25 pod’ів, синхронізацією кешу зараз займається Redis. Розглядаємо Kafka натомість: публікуємо подію, коли змінюється запис кешу, кожен pod споживає її та оновлює власний локальний кеш. Чи добре Kafka пасує тут? З 25 pod’ами — чи отримає оновлення кожен pod, чи Kafka віддасть його лише одному споживачу? Чи потрібна кожному pod’у власна consumer group? Хтось реально так робив — які плюси й мінуси?
З такими задачами я стикався на практиці. Підхід, описаний тут, — компактований топік Kafka, з якого кожен pod матеріалізує локальний кеш, — поширений патерн, що роками працює в продакшен-системах. Це не універсальна заміна Redis, але практичний варіант, коли його компроміси узгодженості та експлуатації пасують навантаженню. Ця стаття пояснює патерн, деталі, важливі на практиці, і невеликий приклад, який можна запустити.
Проблема: спільна конфігурація на швидкому шляху читання
Припустімо, застосунок має конфігурацію чи довідкові дані, потрібні кожному інстансу часто: правила фіч, налаштування маршрутизації, налаштування тенантів чи схожі дані. Отримувати їх треба швидко, але вони також мають змінюватися без повторного деплою кожного pod’а.
Спільний кеш Redis — природне рішення. Кожен pod читає те саме централізовано кероване значення, тож після оновлення є одне актуальне джерело, до якого можна звернутися. Компроміс — кожне читання виходить за межі процесу й залежить від того, що кеш-сервіс доступний і швидко відповідає. Залежно від обраної кеш-стратегії промах у Redis може спричинити ще й додатковий запит: з cache-aside, наприклад, застосунок читає джерело істини, а потім заповнює Redis, перш ніж наступний запит зможе скористатися кешем.
Kafka діє інакше. Оновлення дописується в компактований топік, і кожен інстанс програє цей топік у власний in-memory кеш. Читання стають локальними пошуками в мапі. Репліки — зрештою узгоджені: коли pod починає обробляти роботу, він може мати старіше значення, поки наздоганяє, — або взагалі нічого, якщо споживання завершилося помилкою. Далі я покажу, як не пускати pod до реальної роботи, доки він не спожив конфігурацію. Натомість Kafka дає довговічний лог для повторного програвання та відновлення, тримає шлях читання всередині pod’а і може підтримувати явну серіалізацію на основі схем, як-от Avro, Protobuf або JSON Schema.
Ні Kafka, ні Redis не застраховані від збоїв. Але якщо Kafka вже є залежністю, використання її для розповсюдження цієї конфігурації може позбавити потреби додавати Redis як ще одну runtime-залежність і ще одну систему для супроводу. Це зменшує кількість рухомих частин і режимів відмов, які треба враховувати; збої Kafka від цього нікуди не зникають. Така заміна виправдана лише тоді, коли зрештою-узгодженість прийнятна для цих даних.
Kafka також послаблює зв’язаність між сервісом, що публікує конфігурацію, і сервісами, що її споживають. Їм достатньо погодити контракт запису та його схему; споживачам не потрібна пряма рантайм-залежність від продюсера. З Redis обидві сторони зазвичай мають погодити формат ключів і серіалізоване значення — часто той самий DTO чи спільне представлення, — а споживачі мають знати, звідки читати.
| Аспект | Redis (спільний кеш) | Kafka (компактований топік → локальний кеш) |
|---|---|---|
| Погляд на дані | Один централізовано керований кеш | Один матеріалізований кеш на інстанс |
| Узгодженість | Один спільний погляд на кеш; зміни джерела все одно потребують коректної інвалідації | Зрештою-узгодженість між локальними репліками |
| Шлях читання | Мережевий round-trip; промахи можуть вимагати запиту до джерела істини | Локальний пошук у мапі після початкового програвання |
| Відновлення / нові інстанси | Заповнити або прогріти кеш | Програти компактований топік |
| Історія записів | Не властива кешу | Повторюваний актуальний стан; компакція прибирає замінені значення, тож це не аудит-лог |
| Зв’язаність сервісів | Спільний формат ключ/значення та доступ до Redis | Спільна схема запису; без прямої залежності від продюсера |
| Експлуатаційна вартість | Шар спільного кешу, плюс Kafka, якщо вона теж потрібна | Сховище Kafka, споживачі та по одному кешу на інстанс |
Ця стаття зосереджена на тому, як безпечно побудувати бік Kafka: трансляція кожного оновлення кожному інстансу, перебудова кешу на старті та відмова робити реальну роботу, доки ця перебудова не завершена.
Примітка щодо коду: репозиторій — демонстрація, яку можна запустити, а не готова продакшен-бібліотека. Я перевірив його Docker-потік з кінця в кінець: стартове програвання, readiness, живі оновлення та виселення через tombstone. Перш ніж застосовувати патерн, протестуйте його проти власних обсягів, ребалансувань, серіалізації, повторів і сценаріїв збоїв.
TL;DR
- Так, із застереженням: Kafka замінює Redis для трансляції стану кожному pod’у, а не для читання з одного спільного кешу. Кожен pod отримує власну зрештою-узгоджену локальну копію.
- Кожному pod’у потрібна власна Kafka consumer group. Pod’и зі спільною групою ділять партиції (load balancing); pod’и, кожен у своїй групі, отримують весь топік (broadcast).
- Топік має бути компактованим. Використовуйте більше однієї партиції, коли стартове програвання потребує паралелізму, і зробіть локальний кеш thread-safe, якщо ввімкнена конкурентність лістенера.
- Тримайте набір даних малим і відносно низькопоточним. Цей патерн пасує feature flags, правилам маршрутизації та конфігурації сервісів — не великому чи інтенсивно мінливому бізнес-набору даних.
- Видалення — це tombstone: запис із нульовим значенням, а не спеціальний тип повідомлення «delete».
- Чекайте завершення стартового програвання перед взаємодією із зовнішнім світом. Не обслуговуйте ендпоінти, не запускайте заплановані задачі, не обробляйте повідомлення черг і не виконуйте іншу зовні видиму роботу з часткового локального кешу. Відкривайте readiness лише після завершення програвання.
- Унікальні групи залишають неактивні метадані офсетів, поки налаштоване утримання Kafka їх не прибере. Очікуйте тимчасового шуму в інструментах consumer-group і моніторте відповідні налаштування брокера.
Як працює весь потік
Є дві фази: перебудувати локальну репліку, потім тримати її оновленою.
- Продюсер пише upsert у компактований топік. Ключ запису Kafka — ключ конфігурації; його значення — актуальна конфігурація. Нульове значення — tombstone, що означає видалення.
- Новий pod стартує з новою consumer group та
auto.offset.reset=earliest, тож Kafka призначає кожну партицію топіка групі цього pod’а, і програвання починається з найстаріших утримуваних офсетів. - Під час призначення readiness gate зчитує два числа для кожної партиції: поточну позицію споживача та кінцевий офсет партиції. Цей кінцевий офсет стає фіксованою стартовою ціллю.
- Лістенер застосовує кожен запис до thread-safe локальної мапи. Лише після успішного повернення лістенера трекінг-аспект просуває оброблену позицію цієї партиції. Відмова лістенера тому не може змусити гейт стверджувати, що невдалий запис застосовано.
- Коли кожна партиція досягає зафіксованої цілі, readiness змінюється на
UP. Платформа розгортання може відтепер маршрутизувати запити на pod, а заплановані задачі, закриті readiness-гейтом, можуть виконуватися. Читання використовують локальну мапу і не викликають Kafka. - Той самий споживач лишається активним після старту. Нові записи оновлюють або видаляють локальні записи в міру надходження, тож pod’и сходяться незалежно й є зрештою узгодженими один з одним.
Фіксована ціль у кроці 3 — важлива. Якщо продюсер пише, поки триває програвання, новий запис не пересуває стартову фінішну лінію назавжди. Споживач усе одно обробляє його через звичайний шлях лістенера, але readiness визначається відносно знімка, зафіксованого при призначенні. Повільним старт робить великий наявний лог, а не потік пізніших низькопоточних оновлень. Тому патерн призначений для малих, низькочастотних upsert-наборів, як-от feature flags, правила маршрутизації та конфігурація сервісів.
Публікуйте актуальний стан у компактований топік
Почніть зі створення конфігураційного топіка з cleanup.policy=compact. Компакція утримує
останній запис для кожного ключа, тож pod, що стартує пізніше, може програти топік з початку
і відновити актуальну конфігурацію, не просячи інший сервіс прогріти йому кеш.
Це найкраще працює для малого, відносно низькочастотного upsert-топіка: feature flags, правила маршрутизації, налаштування тенантів чи схожа конфігурація. Це не гарний дефолт для великого чи інтенсивно мінливого набору даних, який кожен pod мав би програвати й тримати в пам’яті.
Створіть достатньо партицій, щоб один pod міг програвати топік паралельно кількома
consumer-потоками, коли час старту має значення. Корисний паралелізм обмежений кількістю
партицій, а локальний кеш має бути thread-safe, якщо конкурентність лістенера налаштована
понад одиницю. У прикладі одноразовий сервіс kafka-topic-init створює та засіває топік перед
стартом застосунку.
Наступна вимога — гарантія, що цей стан отримає кожен pod.
Дайте кожному pod’у власну consumer group
Consumer group у Kafka має один незалежний погляд на топік: всередині групи кожна партиція призначається одному споживачу. Тому pod’и зі спільною групою ділять роботу; pod’и в окремих групах кожен споживають повний топік.
Дайте кожному pod’у унікальний group.id. У цьому прикладі спільний префікс ідентифікує
розгортання, а ${random.uuid} Spring постачає суфікс на інстанс:
app:
config-topic: ${CONFIG_TOPIC:local-cache-config}
kafka:
bootstrap-servers: ${KAFKA_BOOTSTRAP_SERVERS:localhost:9092}
consumer-group: ${CONSUMER_GROUP_PREFIX:local-cache-demo}-${random.uuid}
Кожен старт створює нову групу і має перебудувати локальний кеш. Тому задайте auto.offset.reset
на earliest у властивостях споживача. latest залишив би новий pod порожнім до наступного
оновлення.
Map<String, Object> consumerProperties = Map.of(
// other consumer properties...
ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
Коли топік і broadcast-поведінка на місці, кожен pod може матеріалізувати той самий локальний стан.
Матеріалізуйте оновлення в локальному кеші
Щойно топік містить актуальний стан і кожен pod його отримує, лістенер навмисно малий: звичайні записи — у локальний кеш, а для tombstone — видалити ключ.
@Slf4j
@Component
@RequiredArgsConstructor
public class ConfigTopicListener {
private final LocalConfigCache cache;
@ConfigConsumer("config-topic")
@KafkaListener(topics = "${app.config-topic}")
public void onMessage(ConsumerRecord<String, String> record) {
if (record.value() == null) {
log.debug("Tombstone for key '{}' — evicting from local cache", record.key());
cache.remove(record.key());
return;
}
cache.put(record.key(), record.value());
}
}
Звичайні записи покривають створення та оновлення. Видаленню потрібна ще одна домовленість.
Видаляйте конфігурацію tombstone’ами
Запис із тим самим ключем і нульовим значенням — це tombstone. Компакція утримує його
досить довго, щоб споживачі побачили видалення, а згодом прибирає. delete.retention.ms — також
межа, у межах якої споживач, що стартує з нульового офсета, мусить завершити сканування, щоб
отримати гарантовано валідний знімок фінального стану, як пояснює
довідник конфігурації брокера Kafka.
Налаштовуйте це вікно за виміряним найгіршим часом програвання; не припускайте, що дефолт
автоматично безпечний для великого топіка.
Жорстке видалення доречне лише коли застосунок має справді забути конфігурацію. Якщо неактивна
конфігурація має лишатися доступною для аудиту, старих даних чи пізнішого повторного ввімкнення,
публікуйте звичайний запис із active: false чи deactivatedAt і тримайте його в кеші.
Якщо записів небагато, утримувати всю конфігурацію локально може бути простіше. Компактований
топік тримає останнє значення на ключ, а не всі ревізії назавжди; для повної історії
використовуйте версійовані ключі або окремий топік історії.
Приклад використовує ConcurrentHashMap для LocalConfigCache. Spring Kafka стартує з одним
consumer-потоком за замовчуванням, але налаштована конкурентність лістенера може оновлювати
той самий кеш із кількох потоків. Анотація @ConfigConsumer на лістенері пов’язує його
з readiness gate, описаним далі.
На цей момент кожен pod може побудувати коректний локальний стан. Але використовувати його досі не можна, доки програвання не завершене.
Не обслуговуйте трафік, доки програвання не завершилося
Не приймайте трафік, не запускайте заплановані задачі і не виконуйте іншу зовнішню роботу, доки не спожито конфігурацію.
Це та частина, яку легко пропустити і дорого пропустити. Pod, що повідомляє «ready» у мить призначення партицій, готовий лише номінально — він міг програти три записи з трьох тисяч. Запити б’ють у майже порожній кеш; запланована задача працює зі застарілих дефолтів; ніхто не помічає, доки хтось не спитає, чому pod 14 дві хвилини після деплою поводився інакше.
Приклад виносить це в невеликий модуль readiness-gate. Коли Kafka призначає партиції,
гейт фіксує їхні поточні кінцеві офсети як стартову ціль. Кожен успішно оброблений запис просуває
відстежувану позицію своєї партиції. Readiness відкривається лише після того, як кожна партиція
досягає зафіксованої цілі і не лишається жодної помилки обробки. Порожні топіки теж працюють:
їхні стартові позиції вже дорівнюють кінцевим офсетам.
Ціль — фіксований знімок. Записи, опубліковані після призначення партицій, не розширюють його, тож топік, що безперервно оновлюється, не може тримати pod у старті назавжди. Щойно зафіксована ціль досягнута, пізніші записи йдуть звичайним шляхом живих оновлень і залишаються під дією компромісу зрештою-узгодженості, описаного нижче.
Потік має чотири відповідальності. Перше: маркерна анотація ідентифікує метод @KafkaListener,
чиї аргументи ConsumerRecord відстежує readiness gate:
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ConfigConsumer {
String value() default "";
}
Друге: трекер фіксує цільові кінцеві офсети, захоплені при призначенні, і наступний офсет після кожного успішно обробленого запису:
@Component
public class ConsumptionTracker {
private final ConcurrentMap<String, ConsumerReplayProgress> progressByConsumerId =
new ConcurrentHashMap<>();
public void register(String consumerId) {
progressByConsumerId.computeIfAbsent(consumerId, ignored -> new ConsumerReplayProgress());
}
public void onPartitionsAssigned(
String consumerId,
Map<TopicPartition, Long> currentPositions,
Map<TopicPartition, Long> targetEndOffsets) {
progressFor(consumerId).assign(currentPositions, targetEndOffsets);
}
public void onRecordProcessed(String consumerId, ConsumerRecord<?, ?> record) {
progressFor(consumerId).recordSuccess(
new TopicPartition(record.topic(), record.partition()),
positionAfter(record));
}
public boolean isFullyConsumed() {
return progressByConsumerId.isEmpty()
|| progressByConsumerId.values().stream()
.allMatch(ConsumerReplayProgress::isCaughtUp);
}
// Kafka positions identify the next record to read, not the last one already processed.
private long positionAfter(ConsumerRecord<?, ?> record) {
return Math.incrementExact(record.offset());
}
}
ConsumerReplayProgress володіє призначеними партиціями, а малий
PartitionReplayProgress — поточною позицією, фіксованою ціллю та помилкою однієї партиції.
Розділення цих відповідальностей робить правило readiness явним: кожна призначена партиція має
досягти власної цілі, і помилку знімає лише успішний запис із тієї самої партиції.
Аспект @Around повідомляє трекеру про кожен успішно оброблений ConsumerRecord
автоматично — сам метод лістенера ніколи не викликає його напряму, саме тому в
ConfigTopicListener.onMessage вище немає жодного коду, пов’язаного з readiness, — лише
анотація @ConfigConsumer("config-topic").
Окремий регістратор попередньо реєструє кожен метод @ConfigConsumer на старті, до першого
повідомлення. ConsumerAwareRebalanceListener постачає призначення та їхні захоплені кінцеві
офсети. Це тримає readiness у DOWN від старту, доки лістенер не обробить до кожної цілі,
і перераховує ціль після ребалансування.
Третє: виставте гейт через звичайний HealthIndicator у readiness-групі здоров’я Spring Boot.
Це поєднує стан кешу з власним readiness-станом Boot і дає платформі розгортання один стабільний
ендпоінт для опитування. Це також уникає конкуренції з подіями доступності застосунку Boot
під час старту:
@Component("configConsumption")
@RequiredArgsConstructor
public class ConfigConsumptionHealthIndicator implements HealthIndicator {
private final ConsumptionTracker tracker;
@Override
public Health health() {
var details = tracker.describe();
return tracker.isFullyConsumed()
? Health.up().withDetails(details).build()
: Health.down().withDetails(details).build();
}
}
management:
endpoint:
health:
"group[readiness]":
include: readinessState,configConsumption
/actuator/health/readiness тепер повідомляє UP лише після того, як кожна призначена партиція
досягає зафіксованої стартової цілі. Налаштуйте платформу розгортання утримувати трафік, доки
цей ендпоінт не поверне успіх.
Сервіс Docker Compose з прикладу використовує той самий ендпоінт як healthcheck, тож Docker
позначає застосунок здоровим лише після завершення програвання. Це дзеркалить перевірку
доступності платформи розгортання; статус здоров’я Compose сам по собі не керує маршрутизацією
трафіку.
Четверте: захист запланованих задач (або будь-яких інших методів бінів) тим самим
способом, без повторення перевірки if (!tracker.isFullyConsumed()) return; у кожному місці
виклику: друга анотація, @ReadinessGated, плюс власний малий аспект, що пропускає виклик
повністю, доки гейт не відкриється, — саме цим анотований CacheSnapshotJob.logSnapshot вище:
@Aspect
@Component
@RequiredArgsConstructor
public class ReadinessGateAspect {
private final ConsumptionTracker tracker;
@Around("@annotation(com.example.company.readinessgate.ReadinessGated)")
public Object skipUntilReady(ProceedingJoinPoint joinPoint) throws Throwable {
if (!tracker.isFullyConsumed()) {
log.debug("Skipping {} — readiness gate not open yet", joinPoint.getSignature().toShortString());
return null;
}
return joinPoint.proceed();
}
}
Та сама схема, що й аспект @ConfigConsumer раніше, просто спрямований в інший бік: той
повідомляє трекеру про активність, цей читає її і вирішує, чи взагалі пропустити виклик. Має сенс
лише на void-методах — пропущений виклик повертає null — а це рівно те, чим є
@Scheduled-задача.
Застосування readiness gate
Застосунок має блокувати кожну взаємодію із зовнішнім світом, що залежить від цієї конфігурації; інакше він може діяти на основі порожнього чи застарілого кешу. Приклад реалізує два такі гейти, але той самий принцип застосовний ширше.
Для HTTP-трафіку ConfigConsumptionHealthIndicator тримає readiness-ендпоінт у DOWN, доки
програвання не завершене. Контролерам не треба повторювати tracker.isFullyConsumed() у кожному
ендпоінті, коли платформа розгортання використовує цей ендпоінт, щоб утримувати трафік.
Наприклад, у Kubernetes використовуйте readinessProbe для маршрутизації і дайте startupProbe
достатньо часу на велике початкове програвання:
@GetMapping("/api/cache")
public ResponseEntity<Map<String, CacheEntry>> all() {
return ResponseEntity.ok(cache.snapshot());
}
Для запланованої задачі @ReadinessGated перешкоджає виклику, доки той самий трекер не готовий:
@ReadinessGated
@Scheduled(fixedDelayString = "${app.cache-snapshot-job.interval}")
public void logSnapshot() {
log.info("Local cache holds {} entries", cache.size());
}
Інші зовнішні взаємодії потребують еквівалентного гейту. Наприклад, лістенер черги, що залежить від цієї конфігурації, не має починати обробку, доки кеш не готовий; організуйте це на рівні лістенера/контейнера або стратегією підтверджень, яка не підтверджує і не втрачає повідомлення, поки гейт закритий. Цей приклад постачає гейти лише для HTTP-трафіку та запланованих задач, але той самий сигнал readiness може керувати еквівалентним захистом для споживачів черг, вихідних викликів чи будь-якої іншої роботи, що залежить від конфігурації.
Де цей патерн болить
Щасливий шлях привабливий: програти раз, потім обслуговувати локальні читання. Експлуатаційна вартість проявляється на межах — старт, лаг, утримання, збої. Ось рішення, які я б зробив явними перед вибором патерну.
Кожен перезапуск платить за програвання
Нова група не має офсетів, тож кожен pod перебудовується з початку. Вартість тому зростає
з кількістю записів, досі наявних у компактованому лозі, — а не просто з кількістю актуальних
ключів, бо компакція асинхронна і старі сегменти можуть лишатися якийсь час. Виміряйте час
програвання на продакшен-подібних даних і дайте startupProbe достатній бюджет. Kafka і так
забирає записи батчами, тож підлаштуйте max.poll.records і тримайте роботу на запис дешевою.
Для більших програвань переключіть лістенер у batch-режим і застосовуйте кожен повернутий список
одним викликом; трекінг-аспект прикладу підтримує і окремі аргументи ConsumerRecord, і
ітерабельні батчі. Додавайте конкурентність лістенера лише коли в топіка достатньо партицій
для неї. Три партиції дозволяють щонайбільше трьом consumer-потокам в одному pod’і просуватися
паралельно.
Найгірше програвання також має вміщатися у вікно утримання tombstone топіка, інакше сканування
з нульового офсета не гарантовано відновить валідний знімок.
Зафіксовані цілі не зсуваються, коли продюсери дописують нові записи під час програвання, тож безперервні записи не роблять старт необмеженим. Час старту визначає наявний лог. Якщо цей лог настільки великий, що readiness стає повільним чи непередбачуваним, топік, імовірно, поза призначеним для патерну низькочастотним конфігураційним кейсом.
Унікальні групи залишають тимчасові метадані
Кожен pod генерує нову consumer group. Після зникнення pod’а його закомічені офсети лишаються видимими, поки Kafka не прибере метадані неактивної групи за налаштуваннями утримання брокера. Це зазвичай операційний шум, а не вічне зростання живого навантаження, але це впливає на дашборди та будь-яку автоматизацію, що припускає активність кожної переліченої групи. Використовуйте впізнаваний префікс, моніторте політику утримання офсетів брокера і фільтруйте неактивні групи в інструментах.
Велика конфігурація не належить кожному pod’у
Цей патерн добре пасує малому, часто читаному наборі конфігурації. Якщо конфігурація велика, тримати весь набір у локальній пам’яті зазвичай погана ідея. Кожному pod’у потрібен достатній heap для власної копії, а додавання pod’ів множить цю вартість пам’яті. Тримайте велику конфігурацію в спільному сховищі або матеріалізуйте лише малу підмножину, потрібну кожному сервісу насправді.
Зрештою-узгодженість — частина контракту
Кожен pod споживає оновлення незалежно, тож два pod’и можуть короткий час повертати різні значення. Повільний споживач, ребалансування, повтор чи збій Kafka можуть розтягнути цей розрив. Це прийнятно для feature flags, підказок маршрутизації та іншої конфігурації, що терпить короткочасну застарілість; це погано пасує рішенням про авторизацію, залишкам, балансам чи будь-якому правилу, що має змінитися всюди в ту саму мить. Визначте терпимий лаг, моніторте його і явно опишіть поведінку при застарілих даних до вибору цього дизайну.
Ці витрати не роблять патерн неправильним. Вони визначають його корисний діапазон: компактні, повторювані, зрештою узгоджені довідкові дані з дуже гарячим шляхом читання і командою, що вже комфортно супроводжує Kafka.
Код
Код із цієї статті доступний у github.com/javaAndScriptDeveloper/kafka-backed-local-read-replica-article. README репозиторію містить інструкції з налаштування та запуску, зокрема як інспектувати consumer group, спостерігати розповсюдження tombstone’ів і масштабувати застосунок локально.
Поговоримо
Якщо ви запускаєте — або запускали — щось подібне, хочу почути, де для вас осіли компроміси. Контактні посилання — у футері.
Часті запитання
Чи може Kafka замінити Redis для синхронізації кешу між pod’ами?
Так — для конкретної задачі трансляції стану кожному інстансу; це інший інструмент для спорідненої роботи, а не заміна «під ключ». Redis дає всім pod’ам один спільний погляд на кеш, а Kafka дає кожному pod’у власну зрештою узгоджену копію, побудовану програванням компактованого топіка. Застосовуйте цей патерн, коли важлива затримка локальних читань і короткочасна застарілість після оновлення прийнятна.
Кожен pod отримує всі повідомлення Kafka, чи Kafka розподіляє їх між pod’ами?
Це повністю залежить від consumer group, а не від самої Kafka. Pod’и зі спільною групою ділять партиції між собою (load balancing) — кожне повідомлення потрапляє рівно до одного pod’а. Дайте кожному pod’у власну окрему consumer group, і кожна група незалежно отримає весь топік, тож кожен pod побачить кожне повідомлення. Це і є патерн broadcast, який розбирає ця стаття.
Як дати кожному pod’у власну Kafka consumer group?
Поєднайте префікс, керований людиною, зі значенням Spring ${random.uuid} на інстанс: group-id: ${CONSUMER_GROUP_PREFIX}-${random.uuid}. Кожен інстанс застосунку отримує унікальну групу, тож кожен pod незалежно споживає весь топік.
Як видалити ключ, коли топік Kafka компактований?
Опублікуйте tombstone: запис із тим самим ключем і нульовим значенням. Споживачі, зіткнувшись із ним, виселяють ключ замість кешування null. Kafka з часом прибирає і замінене значення, і tombstone; підберіть delete.retention.ms так, щоб повне програвання вкладалося в це вікно, — Kafka документує його як межу для відновлення валідного знімка з нульового офсета.
Чи мають планувальники та трафік чекати, поки споживання Kafka наздожене?
Так. Pod, який починає обслуговувати запити чи виконувати заплановані задачі до завершення програвання топіка, працює з порожнім або частковим кешем. Тримайте readiness у DOWN, доки стартове програвання не завершене. Приклад фіксує кінцевий офсет кожної партиції при її призначенні та відкриває readiness лише після того, як кожна оброблена позиція досягає своєї цілі.
Чи може постійний потік оновлень тримати новий pod у стані запуску назавжди?
Ні. Readiness gate фіксує сталу кінцеву позицію кожної партиції в момент призначення. Записи, додані після цього знімка, не пересувають стартову ціль; pod обробляє їх як звичайні зрештою-узгоджені оновлення. Старт усе одно може тривати довго, якщо наявний компактований лог великий, — одна з причин, чому цей патерн найкраще пасує малим низькопоточним upsert-топікам, як-от feature flags і конфігурація сервісів.