Может ли Kafka заменить Redis для синхронизации кэша? Ответ из продакшена

Недавно на r/apachekafka мне попался вопрос, который хорошо показывает типичную проблему синхронизации кэша: Может ли Kafka заменить Redis для синхронизации кэша между несколькими подами Spring Boot?

Вопрос в пересказе

Spring Boot на GCP, ~25 подов, сейчас синхронизацией кэша занимается Redis. Рассматриваем Kafka вместо него: публикуем событие при изменении записи кэша, каждый под потребляет его и обновляет свой локальный кэш. Хорошо ли Kafka подходит для этой задачи? С 25 подами — получит ли обновление каждый под, или Kafka отдаст его лишь одному consumer'у? Нужна ли каждому поду своя consumer group? Запускал ли кто-нибудь такое на практике, и какие плюсы и минусы?

С задачами такого класса я работал. Подход, который я опишу, — компактированный топик Kafka, из которого каждый под материализует локальный кэш, — распространённый паттерн, годами работающий в продакшене. Это не универсальная замена Redis, но практичный вариант, если его компромиссы по согласованности и эксплуатации вас устраивают. В статье я объясню паттерн, разберу детали, которые важны на практике, и покажу небольшой запускаемый пример.

Продюсер конфигурации публикует в компактированный топик Kafka, который три consumer group реплеят в отдельные локальные кэши подов A, B и C
Каждый под использует отдельную consumer group, получает полный топик и обслуживает чтения из собственного локального кэша.

Проблема: общая конфигурация на быстром пути чтения

Предположим, в приложении есть конфигурация или справочные данные, которые нужны каждому инстансу постоянно: правила фич, настройки маршрутизации, настройки тенантов и тому подобное. Читать их нужно быстро, но и менять без передеплоя каждого пода.

Общий кэш в Redis — естественное решение. Каждый под читает одно и то же централизованно управляемое значение, поэтому после обновления существует единственное актуальное представление. Цена в том, что каждое чтение выходит за пределы процесса и зависит от доступности и скорости ответа кэш-сервиса. В зависимости от выбранной стратегии кэширования промах по Redis может означать и дополнительный запрос: при cache-aside, например, приложение читает источник истины и лишь затем наполняет Redis, прежде чем следующий запрос сможет воспользоваться кэшем.

Kafka предлагает другой подход. Обновление дописывается в компактированный топик, и каждый инстанс реплеит этот топик в собственный кэш в памяти. Чтения превращаются в локальные обращения к map. Реплики согласуются в конечном счёте (eventual consistency): пока под догоняет, у него может быть устаревшее значение, а если потребление сломалось, то и вообще никакого. Ниже я покажу, как не дать поду выполнять реальную работу, пока он не прочитал конфигурацию. Взамен Kafka даёт долговременный лог для реплея и восстановления, оставляет путь чтения внутри пода и позволяет использовать явную схему сериализации: Avro, Protobuf или JSON Schema.

Ни Kafka, ни Redis не застрахованы от сбоев. Но если Kafka у вас уже есть, раздавать через неё эту конфигурацию — способ не тащить Redis как ещё одну runtime-зависимость и ещё одну систему в эксплуатации. Движущихся частей и режимов отказа, о которых нужно думать, становится меньше, хотя сбои Kafka это не отменяет. Такой обмен оправдан, только если для этих данных допустима eventual consistency.

Kafka к тому же развязывает сервис, публикующий конфигурацию, и сервисы, которые её читают. Им достаточно договориться о контракте записи и её схеме; consumer’ам не нужна прямая runtime-зависимость от продюсера. С Redis обычно обе стороны должны согласовать формат ключей и формат сериализованного значения (часто это один и тот же DTO или общая модель), а consumer’ы должны знать, откуда читать.

Аспект Redis (общий кэш) Kafka (компактированный топик → локальный кэш)
Представление данных Один централизованно управляемый кэш Своё материализованное представление у каждого инстанса
Согласованность Одно общее представление кэша; изменения источника всё равно требуют корректной инвалидации Eventual consistency между локальными репликами
Путь чтения Сетевой round-trip; промах может потребовать запроса к источнику истины Локальный поиск по map после начального реплея
Восстановление / новые инстансы Наполнить или прогреть кэш Реплей компактированного топика
История записей Не присуща кэшу Воспроизводимое текущее состояние; компакция удаляет перезаписанные значения, так что это не audit log
Связанность сервисов Общий формат ключ/значение и доступ к Redis Общая схема записи; прямой зависимости от продюсера нет
Эксплуатационная стоимость Общий кэш-тир, плюс Kafka, если она тоже нужна Хранилище и consumer’ы Kafka плюс по одному кэшу на инстанс

Эта статья о том, как безопасно построить сторону Kafka: рассылать каждое обновление каждому инстансу, перестраивать кэш на старте и не выполнять реальную работу, пока перестройка не завершена.

Примечание о коде: репозиторий — запускаемая демонстрация, а не готовая продакшен-библиотека. Я проверил его Docker-сценарий от начала до конца: стартовый реплей, readiness, живые обновления и удаление по tombstone. Прежде чем применять паттерн, проверьте его на своих объёмах и своих сценариях ребалансировки, сериализации, ретраев и сбоев.

TL;DR

  • Да, с оговоркой: Kafka заменяет Redis для рассылки состояния каждому поду, но не для чтения из одного общего кэша. У каждого пода своя локальная копия с eventual consistency.
  • Каждому поду нужна своя Kafka consumer group. Поды в общей группе делят партиции (балансировка нагрузки); поды в отдельных группах получают полный топик каждый (broadcast).
  • Топик должен быть компактированным. Если стартовому реплею нужна конкурентность, партиций должно быть больше одной, а при включённой конкурентности листенера локальный кэш должен быть потокобезопасным.
  • Держите набор данных маленьким и сравнительно низкообъёмным. Паттерн подходит для feature flags, правил маршрутизации и конфигурации сервисов, но не для большого или часто меняющегося бизнес-датасета.
  • Удаления — это tombstone: запись с null-значением, а не отдельный тип сообщения «delete».
  • Внешние взаимодействия — только после завершения стартового реплея. Эндпоинты не принимают трафик, шедулер-джобы не запускаются, сообщения очередей не обрабатываются: никакой внешне заметной работы на неполном локальном кэше. Readiness открывается только после завершения реплея.
  • Уникальные группы оставляют после себя неактивные offset-метаданные, пока их не удалит настроенный retention Kafka. Готовьтесь к временному мусору в инструментах для работы с consumer group и следите за соответствующими настройками брокера.

Как устроен весь процесс

Фаз две: сначала перестроить локальную реплику, затем поддерживать её в актуальном состоянии.

Двухфазный жизненный цикл локального кэша на Kafka: на старте фиксируются целевые позиции партиций и readiness держится закрытым, пока записи применяются; в установившемся режиме readiness открывается, локальные чтения обслуживаются, а последующие обновления продолжают применяться
У старта есть фиксированная финишная черта. Когда каждая партиция её достигает, тот же листенер поддерживает локальный кэш готового пода в актуальном состоянии.
  1. Продюсер пишет upsert в компактированный топик. Ключ записи Kafka — ключ конфигурации; значение — актуальная конфигурация. Null-значение — это tombstone, означающий удаление.
  2. Новый под стартует с новой consumer group и auto.offset.reset=earliest, поэтому Kafka назначает каждую партицию топика группе этого пода, и реплей начинается с самых старых удерживаемых offset’ов.
  3. При назначении партиций readiness-гейт считывает для каждой партиции два числа: текущую позицию consumer’а и конечный offset партиции. Этот конечный offset становится фиксированной стартовой целью.
  4. Листенер применяет каждую запись к потокобезопасной локальной map. Позиция обработанных записей партиции сдвигается аспектом отслеживания только после успешного возврата из листенера. Поэтому при сбое листенера гейт не посчитает упавшую запись применённой.
  5. Когда каждая партиция достигает зафиксированной цели, readiness переключается в UP. Теперь платформа деплоя может направлять запросы на под, а шедулер-джобы за readiness-гейтом могут выполняться. Чтения используют локальную map и не обращаются к Kafka.
  6. Тот же consumer остаётся активным и после старта. Новые записи обновляют или удаляют локальные записи по мере прибытия, поэтому поды независимо сходятся к одному состоянию и согласуются друг с другом в конечном счёте.

Фиксированная цель из шага 3 важна. Если продюсер пишет во время реплея, новая запись не отодвигает финишную черту старта до бесконечности. Consumer всё равно обрабатывает её обычным путём листенера, но readiness определяется относительно снимка, снятого при назначении партиций. Замедлить старт может большой существующий лог, а не поток последующих низкообъёмных обновлений. Поэтому паттерн предназначен для маленьких, слабо меняющихся upsert-датасетов вроде feature flags, правил маршрутизации и конфигурации сервисов.


Публикуем актуальное состояние в компактированный топик

Начнём с создания топика конфигурации с cleanup.policy=compact. Компакция удерживает последнюю запись для каждого ключа, поэтому под, стартующий позже, может реплеить топик с самого начала и восстановить актуальную конфигурацию, не прося другой сервис прогреть его кэш.

Лучше всего это работает для маленького, сравнительно низкообъёмного upsert-топика: feature flags, правила маршрутизации, настройки тенантов и подобная конфигурация. Для большого или активно меняющегося набора данных, который каждому поду пришлось бы реплеить и держать в памяти, это плохой выбор по умолчанию.

Партиций должно быть достаточно, чтобы один под мог реплеить топик в несколько consumer-потоков, если важно время старта. Полезная конкурентность ограничена числом партиций, а локальный кэш должен быть потокобезопасным, если конкурентность листенера настроена больше единицы. В примере одноразовый сервис kafka-topic-init создаёт и наполняет топик до старта приложения.

Дальше нужно гарантировать, что это состояние получит каждый под.

Каждому поду — собственная consumer group

У каждой consumer group в Kafka своё независимое представление топика: внутри группы каждая партиция назначается одному consumer’у. Поэтому поды в общей группе делят работу между собой, а поды в отдельных группах потребляют полный топик — каждый сам по себе.

Сравнение общей Kafka consumer group, где партиции делятся между подами, с одной уникальной группой на каждый под, где каждый под получает все партиции
Общая группа делит состояние. Уникальная группа на каждый под даёт каждому локальному кэшу полное состояние.

Каждому поду назначается уникальный 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}

Каждый старт создаёт новую группу и должен перестроить локальный кэш, поэтому в свойствах consumer’а auto.offset.reset выставлен в earliest. С latest новый под остался бы с пустым кэшем до ближайшего обновления.

Map<String, Object> consumerProperties = Map.of(
        // other consumer properties...
        ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

Когда топик и broadcast-поведение настроены, каждый под может материализовать одно и то же локальное состояние.

Материализуем обновления в локальном кэше

Когда топик содержит актуальное состояние и каждый под его получает, листенер намеренно прост: обычные записи кладутся в локальный кэш, а 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

Запись с тем же ключом и null-значением — это tombstone. Компакция хранит её достаточно долго, чтобы consumer’ы успели увидеть удаление, а затем удаляет. delete.retention.ms — также граница, в пределах которой consumer, стартующий с offset ноль, должен завершить сканирование, чтобы гарантированно получить корректный снимок итогового состояния, как объясняет справочник конфигурации брокера Kafka. Окно настраивают по измеренному худшему времени реплея; не стоит считать, что значение по умолчанию безопасно для большого топика.

Администратор конфигурации публикует null-значение как Kafka tombstone, и каждый под потребляет его и удаляет соответствующий ключ из своего локального кэша
Tombstone рассылается как любая другая запись; каждый под трактует её null-значение как команду удалить ключ.

Жёсткое удаление уместно, только если приложение действительно должно забыть конфигурацию. Если неактивная конфигурация должна оставаться доступной для аудита, исторических данных или последующего повторного включения, публикуйте вместо этого обычную запись с active: false или deactivatedAt, и она останется в кэше. Если записей мало, проще может оказаться хранить все конфигурации локально. Компактированный топик хранит последнее значение для каждого ключа, а не все версии навсегда; если нужна полная история, используйте версионированные ключи или отдельный history-топик.

В примере для LocalConfigCache используется ConcurrentHashMap. Spring Kafka по умолчанию стартует с одним consumer-потоком, но настроенная конкурентность листенера может обновлять тот же кэш из нескольких потоков. Аннотация @ConfigConsumer на листенере связывает его с readiness-гейтом, который описывается далее.

К этому моменту каждый под может построить корректное локальное состояние, но пользоваться им рано, пока реплей не завершён.

Не принимайте трафик, пока не догнали топик

Не принимайте трафик, не запускайте шедулер-джобы и не выполняйте другую внешнюю работу, пока конфигурация не прочитана.

Эту часть легко пропустить, и пропуск обходится дорого. Под, который сообщает «ready» в момент назначения партиций, готов лишь на словах: возможно, он реплеил три записи из трёх тысяч. Запросы попадают в почти пустой кэш, шедулер-джоб работает на устаревших значениях по умолчанию, и никто этого не замечает, пока кто-нибудь не спросит, почему под 14 первые две минуты после деплоя вёл себя иначе.

В примере эта забота упакована в небольшой модуль readiness-gate. Когда Kafka назначает партиции, гейт фиксирует их текущие конечные offset’ы как стартовую цель. Каждая успешно обработанная запись сдвигает отслеживаемую позицию своей партиции. Readiness открывается, только когда каждая партиция достигла зафиксированной цели и не осталось ни одной ошибки обработки. Пустые топики тоже работают: их стартовые позиции уже равны конечным.

Цель — фиксированный снимок. Записи, опубликованные после назначения партиций, его не продлевают, поэтому непрерывно обновляемый топик не может держать под в старте вечно. Когда зафиксированная цель достигнута, последующие записи идут по обычному пути живых обновлений и подпадают под компромисс eventual consistency, описанный ниже.

Четыре стадии readiness-гейта: регистрация конфигурационного consumer'а, фиксация целевых позиций партиций, реплей записей с продвижением позиций только после успеха, затем открытие readiness, когда все цели достигнуты
Гейт стартует закрытым, отслеживает успешный реплей относительно фиксированных целей и открывается, только когда каждая назначенная партиция догнала.

У процесса четыре составляющие. Во-первых, маркерная аннотация идентифицирует метод @KafkaListener, чьи аргументы ConsumerRecord отслеживает readiness-гейт:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ConfigConsumer {
    String value() default "";
}

Во-вторых, трекер хранит целевые конечные offset’ы, снятые при назначении, и следующий offset после каждой успешно обработанной записи:

@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 поставляет назначения партиций и снятые для них конечные offset’ы. Благодаря этому readiness остаётся в DOWN с самого старта, пока листенер не дойдёт до всех целей, а после ребалансировки цель пересчитывается.

В-третьих, гейт выставляется наружу через обычный HealthIndicator в health-группе 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 помечает приложение здоровым только после завершения реплея. Это аналог проверки готовности в платформе деплоя; сам по себе health-статус 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-гейт

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

Для 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());
}

Остальные внешние взаимодействия требуют аналогичного гейта. Например, листенер очереди, зависящий от этой конфигурации, не должен начинать обработку, пока кэш не готов. Это решается на уровне листенера или контейнера либо стратегией подтверждения, которая не делает ack и не теряет сообщения, пока гейт закрыт. В примере гейты есть только для HTTP-трафика и шедулер-джобов, но тот же сигнал readiness может защитить и consumer’ов очередей, и исходящие вызовы, и любую другую работу, зависящую от конфигурации.

Где паттерн кусается

Счастливый сценарий заманчив: один реплей, дальше только локальные чтения. Эксплуатационная цена проявляется на границах: старт, лаг, retention, отказ. Вот решения, которые я бы проговорил явно до выбора этого паттерна.

Каждый рестарт платит за реплей

У новой группы нет offset’ов, поэтому каждый под перестраивается с нуля. Цена растёт вместе с числом записей, всё ещё лежащих в компактированном логе, а не просто с числом актуальных ключей: компакция асинхронна, и старые сегменты какое-то время могут оставаться. Измеряйте время реплея на данных, похожих на продакшен, и выделяйте startupProbe достаточный бюджет. Kafka и так забирает записи батчами, так что настраивайте max.poll.records и следите, чтобы обработка каждой записи оставалась дешёвой. Для больших реплеев переведите листенер в batch-режим, чтобы каждая полученная коллекция применялась за один вызов; аспект отслеживания в примере поддерживает и одиночные ConsumerRecord, и итерируемые батчи. Конкурентность листенера стоит добавлять, только если у топика достаточно партиций. Три партиции позволяют одновременно работать максимум трём consumer-потокам в одном поде. Худший случай реплея также должен укладываться в окно retention для tombstone’ов топика, иначе сканирование с offset ноль не гарантирует восстановление корректного снимка.

Зафиксированные цели не сдвигаются, когда продюсеры дописывают записи во время реплея, поэтому непрерывная запись не растягивает старт до бесконечности. Время старта определяет уже существующий лог. Если он настолько велик, что readiness наступает медленно или непредсказуемо, топик, вероятно, вышел за рамки низкообъёмного конфигурационного сценария, для которого паттерн задуман.

Уникальные группы оставляют временные метаданные

Каждый под создаёт новую consumer group. После исчезновения пода его закоммиченные offset’ы остаются видимыми, пока Kafka не удалит метаданные неактивной группы согласно настройкам retention брокера. Обычно это эксплуатационный мусор, а не постоянно растущая живая нагрузка, но он влияет на дашборды и на любую автоматизацию, которая считает все показанные группы активными. Выберите узнаваемый префикс, следите за политикой retention offset’ов на брокере и отфильтровывайте неактивные группы в инструментах.

Большой конфигурации не место в памяти каждого пода

Паттерн хорошо подходит для маленького, часто читаемого набора конфигурации. Если конфигурация большая, держать весь набор данных в локальной памяти обычно плохая идея. Каждому поду нужен достаточно большой heap для собственной копии, а добавление подов умножает эти затраты памяти. Большую конфигурацию лучше хранить в общем хранилище или материализовывать только небольшое подмножество, которое каждому сервису действительно нужно.

Eventual consistency — часть контракта

Каждый под читает обновления независимо, поэтому два пода могут недолгое время возвращать разные значения. Медленный consumer, ребалансировка, ретрай или сбой Kafka могут растянуть этот разрыв. Для feature flags, подсказок маршрутизации и другой конфигурации, которая терпит кратковременную устарелость, это приемлемо; для решений об авторизации, складских остатков, балансов и любых правил, которые должны измениться везде в один и тот же момент, — нет. Определите допустимый лаг и мониторьте его, а поведение при устаревших данных заранее обсудите с теми, кто будет пользоваться этим решением.

Эти издержки не делают паттерн неправильным. Они очерчивают область, где он полезен: компактные, воспроизводимые справочные данные с согласованностью в конечном счёте и очень горячим путём чтения и команда, которой уже привычно эксплуатировать Kafka.

Код

Код из этой статьи доступен в github.com/javaAndScriptDeveloper/kafka-backed-local-read-replica-article. В README репозитория есть инструкции по настройке и запуску, включая то, как смотреть consumer groups, наблюдать за распространением tombstone и масштабировать приложение локально.


Обсудим

Если вы запускали или запускаете что-то похожее, мне было бы интересно узнать, как легли компромиссы. Контакты — в футере.

Частые вопросы

Может ли Kafka заменить Redis для синхронизации кэша между подами?

Да, но только для конкретной задачи: рассылки состояния каждому инстансу. Это другой инструмент для смежной работы, а не замена один в один. Redis даёт всем подам одно общее представление кэша, а Kafka даёт каждому поду собственную локальную копию с eventual consistency, которую под строит реплеем компактированного топика. Паттерн уместен, когда важна низкая задержка локальных чтений и после обновления допустимы кратковременно устаревшие данные.

Если подов N, каждый ли под получает все сообщения Kafka — или Kafka делит их между подами?

Это целиком определяется consumer group, а не самой Kafka. Поды в одной consumer group делят партиции между собой (балансировка нагрузки), и каждое сообщение достаётся ровно одному поду. Если дать каждому поду собственную группу, каждая группа получит весь топик независимо, и каждое сообщение увидит каждый под. Это broadcast-паттерн, о котором эта статья.

Как дать каждому поду собственную consumer group в Kafka?

Объедините задаваемый вручную префикс с уникальным для инстанса значением ${random.uuid} от Spring: group-id: ${CONSUMER_GROUP_PREFIX}-${random.uuid}. Каждый инстанс приложения получает уникальную группу, поэтому каждый под независимо читает топик целиком.

Как удалить ключ, когда топик Kafka компактирован?

Опубликуйте tombstone: запись с тем же ключом и null-значением. Встретив её, consumer удаляет ключ из кэша, а не кэширует null. Со временем Kafka удаляет и перезаписанное значение, и сам tombstone. Окно delete.retention.ms нужно подбирать так, чтобы полный реплей успевал завершиться внутри него: в документации Kafka это граница, в пределах которой с offset ноль можно восстановить корректный снимок.

Нужно ли ждать, пока под догонит Kafka, перед пуском трафика и шедулер-джобов?

Да. Под, который начал обслуживать запросы или запускать шедулер-джобы до завершения реплея топика, работает с пустым или неполным кэшем. Пока стартовый реплей не завершён, readiness должен оставаться в DOWN. В примере при назначении партиций фиксируется конечный offset каждой партиции, и readiness открывается, только когда обработка доходит до всех этих позиций.

Могут ли непрерывные обновления удерживать новый под в старте вечно?

Нет. Readiness-гейт фиксирует конечный offset каждой партиции в момент её назначения. Записи, дописанные после этого снимка, стартовую цель не сдвигают: под обрабатывает их как обычные обновления с eventual consistency. Но старт всё же может затянуться, если существующий компактированный лог большой. Это одна из причин, почему паттерн лучше всего подходит для небольших низкообъёмных upsert-топиков вроде feature flags и конфигурации сервисов.