Kafkaはキャッシュ同期でRedisを置き換えられるか? 本番からの答え

最近、r/apachekafkaで、よくあるキャッシュ同期問題を的確に捉えた質問を見かけました: 複数のSpring Bootポッド間のキャッシュ同期に、KafkaはRedisを置き換えられるか?

元の質問の要約

GCP上のSpring Boot、約25ポッド、現在はRedisがキャッシュ同期を担っている。Kafkaへの移行を検討中: キャッシュエントリが変わったらイベントを発行し、全ポッドがそれを消費して自分のローカルキャッシュを 更新する。Kafkaはここに適しているか? 25ポッドいる場合、全ポッドが更新を受け取るのか、それとも Kafkaは1つのコンシューマーにだけ渡すのか? ポッドごとにコンシューマーグループが必要か? 実際に運用した人はいるか — 長所と短所は?

この種の問題は、私自身が解決した経験があります。ここで説明するアプローチ——コンパクションされた Kafkaトピックを使って、各ポッドのローカルキャッシュをマテリアライズする方法——は一般的な パターンであり、何年も前から本番システムで動いています。Redisの万能な代替品ではありませんが、 その整合性と運用のトレードオフがワークロードに合うなら、実用的な選択肢です。この記事では、 このパターンと、実務で効いてくる細部、そして動かせる小さな例を説明します。

設定プロデューサーがコンパクションされたKafkaトピックへ発行し、3つのコンシューマーグループがそれをリプレイして、Pod A、Pod B、Pod Cそれぞれのローカルキャッシュを構築する様子
各ポッドは個別のコンシューマーグループを使い、トピック全体を受け取り、自分のローカルキャッシュから読み取りに応答します。

問題: 高速な読み取りパス上の共有設定

アプリケーションに、すべてのインスタンスが頻繁に必要とする設定や参照データがあるとします。 機能のルール、ルーティング設定、テナント設定などです。取得は高速であるべきで、かつすべての ポッドを再デプロイせずに変更できる必要があります。

共有Redisキャッシュは自然な解決策です。すべてのポッドが同じ中央管理の値を読むため、更新後には 参照すべき1つの現行ビューが存在します。トレードオフは、読み取りのたびにプロセスの外に出て、 キャッシュサービスの可用性と応答性に依存することです。選んだキャッシュ戦略によっては、Redisミスが 追加のルックアップを引き起こすこともあります。たとえばcache-asideなら、アプリケーションが ソースオブトゥルースを読み、次のリクエストがキャッシュを使えるようにする前にRedisを埋めます。

Kafkaは別のアプローチを取ります。更新はコンパクションされたトピックに追記され、各インスタンスが そのトピックを自分のインメモリキャッシュへリプレイします。読み取りはローカルのマップルックアップに なります。レプリカは結果整合的です。ポッドが処理を始めるとき、追いつくまでの間は古い値を 持っているかもしれませんし、消費に失敗していれば値がまったくないかもしれません。後ほど、設定を 消費し終えるまでポッドが実際の仕事をしないようにする方法を示します。見返りとして、Kafkaは リプレイと回復のための永続ログを提供し、読み取りパスをポッド内に留め、Avro、Protobuf、 JSON Schemaのような明示的なスキーマベースのシリアライズを支えられます。

KafkaもRedisも障害に対して無敵ではありません。しかしKafkaがすでに依存関係として存在するなら、 この設定の配布にKafkaを使うことで、Redisを新たなランタイム依存として、そして運用すべき新たな システムとして追加するのを避けられます。考慮すべき可動部と障害モードの数が減るのです。 Kafkaの障害が消えるわけではありません。このトレードが割に合うのは、データに対して結果整合性が 許容できるときだけです。

Kafkaは、設定を発行するサービスと消費するサービスをデカップリングすることもできます。両者は レコードの契約とそのスキーマに合意するだけでよく、コンシューマーはプロデューサーへの直接的な ランタイム依存を持ちません。Redisでは、両側が通常、キー形式とシリアライズされた値——多くの 場合同じDTOか共有表現——に合意する必要があり、コンシューマーはどこから読むかを知って いなければなりません。

観点 Redis(共有キャッシュ) Kafka(コンパクションされたトピック → ローカルキャッシュ)
データビュー 中央管理の1つのキャッシュ インスタンスごとにマテリアライズされたキャッシュ
整合性 1つの共有キャッシュビュー。ソースの変更には正しい無効化が依然必要 ローカルレプリカ間の結果整合性
読み取りパス ネットワークラウンドトリップ。ミス時はソースオブトゥルースへのルックアップが必要なことも 初期リプレイ後はプロセス内のマップルックアップ
回復/新しいインスタンス キャッシュの投入とウォームアップ コンパクションされたトピックのリプレイ
レコード履歴 キャッシュには固有ではない リプレイ可能な現行状態。コンパクションが置き換えられた値を除去するため、監査ログではない
サービス結合 共有のキー/値形式とRedisアクセス 共有のレコードスキーマ。プロデューサーへの直接依存なし
運用コスト 共有キャッシュ層。Kafkaも必要ならその分も Kafkaのストレージとコンシューマー、そしてインスタンスごとのキャッシュ

この記事は、Kafka側を安全に構築する方法に焦点を当てます。すべての更新をすべてのインスタンスへ 配信すること、起動時にキャッシュを再構築すること、そしてその再構築が完了するまで実際の仕事を 拒否すること。

コードについての注意: リポジトリは動かせるデモンストレーションであり、そのまま本番に投入できる ライブラリではありません。Dockerフローはエンドツーエンドで検証済みです。起動時リプレイ、レディネス、 ライブ更新、トゥームストーンによる削除。パターンを採用する前に、自分のボリューム、リバランス、 シリアライズ、リトライ、障害のシナリオで試してください。

TL;DR

  • 結論はイエス、ただし条件付き: KafkaがRedisを置き換えられるのは、状態を全ポッドへブロードキャストする場合であり、1つの共有キャッシュから読む場合ではありません。各ポッドは自分専用の結果整合的なローカルコピーを持ちます。
  • すべてのポッドに固有のKafkaコンシューマーグループが必要です。 グループを共有するポッドはパーティションを分割して受け取り(ロードバランス)、それぞれが固有グループを持つポッドはトピック全体を受け取ります(ブロードキャスト)。
  • トピックはコンパクション必須です。起動時リプレイに並行性が必要なら複数パーティションを使い、リスナーの並行性を有効にするときはローカルキャッシュをスレッドセーフにします。
  • データセットは小さく、比較的低ボリュームに保ちます。このパターンが合うのは機能フラグ、ルーティングルール、サービス設定であり、大きいまたは高頻度更新のビジネスデータセットではありません。
  • 削除はトゥームストーンです: null値のレコードであり、特別な「削除」メッセージ型ではありません。
  • 外部とやり取りする前に、起動時リプレイの完了を待ちます。 部分的なローカルキャッシュからエンドポイントを提供したり、定時ジョブを実行したり、キューメッセージを処理したり、その他外から見える仕事をしたりしてはいけません。レディネスはリプレイ完了後にのみ開放します。
  • 固有のグループは、Kafkaに設定された保持期間が除去するまで非アクティブなオフセットメタデータを残します。コンシューマーグループのツール類に一時的なノイズが出るものと考え、関連するブローカー設定を監視してください。

フロー全体の仕組み

フェーズは2つあります。ローカルレプリカを再構築すること、そしてそれを最新に保つことです。

2フェーズのKafkaローカルキャッシュライフサイクル: 起動時は固定のパーティションターゲットを記録してレコードを適用し、その間レディネスはDOWNを保つ。定常状態ではレディネスを開放し、ローカル読み取りに応答し、以降の更新も適用し続ける
起動には固定のフィニッシュラインがあります。すべてのパーティションがそれに達した後は、同じリスナーがレディなポッドのローカルキャッシュを最新に保ちます。
  1. プロデューサーがコンパクションされたトピックへupsertを書き込みます。Kafkaレコードのキーは設定キーで、値が最新の設定です。null値は削除を意味するトゥームストーンです。
  2. 新しいポッドは新しいコンシューマーグループとauto.offset.reset=earliestで起動するため、Kafkaはすべてのトピックパーティションをそのポッドのグループに割り当て、リプレイは最古の保持オフセットから始まります。
  3. 割り当ての際、レディネスゲートはすべてのパーティションについて2つの数字を読みます。コンシューマーの現在位置と、パーティションのエンドオフセットです。このエンドオフセットが固定の起動ターゲットになります。
  4. リスナーは各レコードをスレッドセーフなローカルマップに適用します。リスナーが正常に返った後にのみ、トラッキングアスペクトがそのパーティションの処理済み位置を進めます。したがって、リスナーの失敗によって、失敗したレコードが適用済みだとゲートが主張することはありません。
  5. すべてのパーティションが記録したターゲットに達すると、レディネスがUPに変わります。デプロイプラットフォームはここで初めてリクエストをポッドにルーティングでき、レディネスゲート付きの定時ジョブも実行できます。読み取りはローカルマップを使い、Kafkaを呼びません。
  6. 同じコンシューマーが起動後もアクティブのままです。新しいレコードは到着時にローカルエントリを更新または削除するため、ポッドは独立に収束し、互いに結果整合的になります。

ステップ3の固定ターゲットが重要です。リプレイの実行中にプロデューサーが書き込んでも、新しい レコードが起動のフィニッシュラインを永久に先送りすることはありません。コンシューマーは通常の リスナーパスでそれを処理しますが、レディネスは割り当て時に記録したスナップショットに対して 定義されます。起動を遅くしうるのは大きい既存ログであり、その後の低ボリュームな更新の流れでは ありません。だからこそこのパターンは、機能フラグ、ルーティングルール、サービス設定のような、 小さく更新頻度の低いupsertデータセットを想定しているのです。


コンパクションされたトピックで現行状態を発行する

まずcleanup.policy=compactで設定トピックを作成します。コンパクションは各キーの最新レコードを 保持するため、後から起動するポッドもトピックを最初からリプレイでき、別のサービスにキャッシュの ウォームアップを頼むことなく現行の設定を再構築できます。

これが最も効果を発揮するのは、小さく比較的低ボリュームのupsertトピックです。機能フラグ、ルーティング ルール、テナント設定など。すべてのポッドがリプレイしてメモリに保持する必要がある、大きいまたは 高頻度更新のデータセットには、良いデフォルトではありません。

起動時間が重要な場合、1つのポッドが複数のコンシューマースレッドで並行にトピックをリプレイできるよう、 十分なパーティションを作成します。実質的な並行性はパーティション数で頭打ちになり、リスナーの 並行性を1より大きく設定するなら、ローカルキャッシュはスレッドセーフでなければなりません。 この例では、1回限りのkafka-topic-initサービスがアプリケーションの起動前にトピックを作成し、 初期データを投入します。

次の要件は、すべてのポッドがその状態を受け取ることの保証です。

ポッドごとに固有のコンシューマーグループを与える

Kafkaのコンシューマーグループは、トピックに対する1つの独立したビューを持ちます。そのグループ内では、 各パーティションは1つのコンシューマーに割り当てられます。したがって、グループを共有するポッドは 仕事を分割し、別々のグループのポッドはそれぞれトピック全体を消費します。

Kafkaのコンシューマーグループを共有してパーティションがポッド間で分割される場合と、ポッドごとに固有のグループを持ちすべてのポッドが全パーティションを受け取る場合の比較
共有グループは状態を分割します。ポッドごとの固有グループは、すべてのローカルキャッシュに完全な状態を与えます。

各ポッドに一意なgroup.idを与えます。この例では、共有プレフィックスがデプロイを識別し、Springの ${random.uuid}がインスタンスごとのサフィックスを供給します:

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では、次の更新が 届くまで新しいポッドのキャッシュは空のままです。

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

トピックとブロードキャストの動きが揃えば、各ポッドは同じローカル状態をマテリアライズできます。

ローカルキャッシュに更新をマテリアライズする

トピックが現行状態を持ち、すべてのポッドがそれを受け取ったら、リスナーは意図的に小さく保ちます。 通常のレコードはローカルキャッシュへ入れ、トゥームストーンならキーを削除します。

@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());
    }
}

通常のレコードが作成と更新を担います。削除には、もう1つの取り決めが必要です。

トゥームストーンで設定を削除する

同じキーで値がnullのレコードがトゥームストーンです。コンパクションは、コンシューマーが 削除を観察できるよう十分長くこれを保持し、やがて取り除きます。delete.retention.msは、 Kafkaブローカー設定リファレンス が説明するように、オフセットゼロから始まるコンシューマーが有効な最終状態スナップショットの保証を 得るためにスキャンを完了しなければならない窓でもあります。この窓は実測した最悪ケースのリプレイ時間から 設定してください。大きなトピックでデフォルトが自動的に安全だと想定しないこと。

設定管理者がnull値をKafkaのトゥームストーンとして発行し、各ポッドがそれを消費してローカルキャッシュから対応するキーを削除する様子
トゥームストーンは他のレコードと同じようにブロードキャストされます。各ポッドはnull値をキー削除の指示として解釈します。

ハードデリートが適切なのは、アプリケーションがその設定を本当に忘れるべきときだけです。非アクティブな 設定を監査、過去データ、後日の再有効化のために残しておく必要があるなら、代わりにactive: falseや deactivatedAtを含む通常のレコードを発行し、キャッシュに保持します。エントリ数が少なければ、 すべての設定をローカルに保持する方がシンプルなこともあります。コンパクションされたトピックは キーごとの最新値を保持するのであり、すべてのリビジョンを永遠に保持するのではありません。完全な 履歴が必要なら、バージョン付きキーか、別の履歴トピックを使ってください。

この例ではLocalConfigCacheにConcurrentHashMapを使います。Spring Kafkaはデフォルトで1つの コンシューマースレッドで始まりますが、設定されたリスナーの並行性が複数スレッドから同じキャッシュを 更新し得ます。リスナーの@ConfigConsumerアノテーションが、次に説明するレディネスゲートと 結びついています。

この時点で、すべてのポッドが正しいローカル状態を構築できます。しかしリプレイが終わるまで、 その状態を使ってはいけません。

追いつくまでトラフィックを処理しない

設定が消費し終わるまで、トラフィックを受けず、定時ジョブを実行せず、その他の外部仕事も 行わないこと。

ここは省略しやすく、省略した代償が高い部分です。パーティションの割り当てを受けた瞬間に 「準備完了」を報告するポッドは、名ばかりの準備完了です。3000レコードのうち3つしかリプレイして いないかもしれない。リクエストはほぼ空のキャッシュに当たり、定時ジョブは古いデフォルト値で動き、 誰かが「なぜデプロイ後2分間、pod 14だけ挙動が違ったのか」と尋ねるまで誰も気づきません。

この例では、この懸念を小さなreadiness-gateモジュールとしてまとめています。Kafkaがパーティションを 割り当てるとき、ゲートは現在のエンドオフセットを起動ターゲットとして記録します。正常に処理された レコードごとに、そのパーティションの追跡位置が進みます。レディネスが開放されるのは、すべての パーティションが記録済みターゲットに達し、処理エラーが残っていないときだけです。空のトピックも 機能します。開始位置が最初からエンドオフセットと等しいからです。

ターゲットは固定のスナップショットです。パーティション割り当ての後に発行されたレコードはターゲットを 延長しないため、絶えず更新されるトピックがポッドを永久に起動中のままにすることはありません。 記録済みターゲットに達した後のレコードは、通常のライブ更新パスを流れ続け、後述の結果整合性の トレードオフの対象のままです。

レディネスゲートの4段階: 設定コンシューマーを登録し、固定のパーティションターゲットを記録し、成功後にのみ位置を進めながらレコードをリプレイし、全ターゲット達成時にレディネスを開放する
ゲートは閉じた状態で始まり、固定ターゲットに対するリプレイの成功を追跡し、割り当て済みの全パーティションが追いついたときにのみ開放します。

このフローには4つの責務があります。まず、マーカーアノテーションが、レディネスゲートが追跡すべき ConsumerRecord引数を持つ@KafkaListenerメソッドを識別します:

@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が 1つのパーティションの現在位置、固定ターゲット、エラーを所有します。この責務分離により、レディネスの ルールが明示的になります。割り当てられたすべてのパーティションが自分のターゲットに達すること、 そして失敗を消せるのは同じパーティションからの正常なレコードだけであること。

@Aroundアスペクトが、正常に処理されたすべてのConsumerRecordを自動的にトラッカーへ報告します。 リスナーメソッド自身が直接呼ぶことは決してなく、だからこそ前述のConfigTopicListener.onMessageには レディネス関連のコードが一切なく、@ConfigConsumer("config-topic")アノテーションがあるだけです。 別のレジストラーが、最初のメッセージが届く前の起動時にすべての@ConfigConsumerメソッドを事前登録します。 ConsumerAwareRebalanceListenerが割り当てと、その記録済みエンドオフセットを供給します。これにより、 レディネスは起動から、リスナーがすべてのターゲットを処理し終えるまでDOWNのままとなり、リバランス後には ターゲットを再計算します。

3つ目として、ゲートをSpring Bootのreadinessヘルスグループの通常のHealthIndicatorとして公開します。 これによりキャッシュの状態がBoot自身のレディネス状態と合成され、デプロイプラットフォームは ポーリングすべき1つの安定したエンドポイントを得ます。起動中に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のヘルスステータス自体はトラフィックのルーティングを 制御しません。

4つ目として、定時ジョブ(または他の任意のビーンメソッド)を同じ方法でゲートします。 if (!tracker.isFullyConsumed()) return;のチェックをすべての呼び出し箇所で繰り返さないために、 2つ目のアノテーション@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のジョブはまさにそういうメソッドです。

レディネスゲートの適用

アプリケーションは、この設定に依存する外部世界とのすべてのやり取りをブロックしなければなりません。 さもないと、空の、あるいは古いキャッシュに基づいて動作しかねません。この例では2つのゲートを 実装していますが、同じ原則はもっと広く適用できます。

HTTPトラフィックに対しては、ConfigConsumptionHealthIndicatorがリプレイ完了までレディネス エンドポイントを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トラフィックと定時ジョブだけですが、同じレディネスシグナルは、キューコンシューマー、 外向けの呼び出し、その他設定に依存するあらゆる仕事に対して、同等の保護を駆動できます。

このパターンの落とし穴

正常系は魅力的です。一度リプレイすれば、あとはローカルの読み取りだけで済みます。運用コストが現れるのは境界、 つまり起動、遅延、保持、障害です。このパターンを選ぶ前に、はっきり決めておきたい点がここにあります。

再起動のたびにリプレイコストを払う

新しいグループにはオフセットがないため、すべてのポッドが最初から再構築します。したがってコストは、 コンパクション済みログにまだ残っているレコード数に比例して伸びます。現行キーの数だけではありません。 コンパクションは非同期であり、古いセグメントはしばらく残り得るからです。リプレイ時間は本番同等の データで計測し、startupProbeに十分な予算を与えてください。Kafkaはすでにレコードをバッチで取得する ので、max.poll.recordsを調整し、レコードごとの作業を軽く保ちます。より大きいリプレイには、 リスナーをバッチモードに切り替えて、返されたリストを1回の呼び出しで適用します。この例のトラッキング アスペクトは、単一のConsumerRecord引数とイテラブルなバッチの両方をサポートしています。 リスナーの並行性は、トピックに十分なパーティションがあるときにだけ追加してください。3パーティション なら、1ポッド内で並行に前進できるコンシューマースレッドは最大3です。 最悪ケースのリプレイは、トピックのトゥームストーン保持窓の内に収まらなければなりません。 さもないと、オフセットゼロからのスキャンが有効なスナップショットを再構築する保証がありません。

記録されたターゲットは、リプレイ中にプロデューサーが新レコードを追記しても動きません。したがって 絶え間ない書き込みが起動を無限に引き延ばすことはありません。起動時間を決めるのは既存のログです。 そのログが大きすぎてレディネスが遅い、あるいは予測不能になるなら、そのトピックはおそらく、 このパターンが想定する低ボリュームの設定データというユースケースの外にあります。

固有グループは一時的なメタデータを残す

各ポッドは新しいコンシューマーグループを生成します。ポッドが消えた後も、コミットされたオフセットは、 ブローカーの保持設定に従ってKafkaが非アクティブなグループメタデータを除去するまで見え続けます。 通常これは増え続けるライブワークロードではなく、運用上のノイズですが、ダッシュボードや、 一覧に挙がるグループはすべてアクティブだと想定する自動化に影響します。識別可能なプレフィックスを 使い、ブローカーの オフセット保持ポリシー を監視し、ツール側で非アクティブなグループをフィルターしてください。

大きい設定は全ポッドに入れない

このパターンがよく合うのは、小さく頻繁に読まれる設定集合です。設定が大きいなら、データセット全体を ローカルメモリに置くのは通常、悪い考えです。すべてのポッドが自分のコピーの分だけヒープを必要とし、 ポッドを増やすほどそのメモリコストが掛け算されます。大きい設定は共有ストアに置くか、各サービスが 実際に必要とする小さなサブセットだけをマテリアライズしてください。

結果整合性は契約の一部

各ポッドは独立に更新を消費するため、2つのポッドが一時的に異なる値を返すことがあります。遅い コンシューマー、リバランス、リトライ、Kafkaの障害は、その差を広げられます。機能フラグ、ルーティング ヒント、一時的な古さが許容できるその他の設定なら問題ありません。認可の判断、在庫、残高、同じ瞬間に どこでも変わらなければならないルールには不向きです。許容する遅延を定義し、監視し、この設計を 選ぶ前に、古いデータの振る舞いを呼び出し側に明示してください。

これらのコストは、パターンが間違っていることを意味しません。有用な適用範囲を定義しているのです。 コンパクトでリプレイ可能な、結果整合的な参照データ。非常にホットな読み取りパス。そしてKafkaの 運用にすでに慣れたチーム。

コード

この記事のコードは github.com/javaAndScriptDeveloper/kafka-backed-local-read-replica-articleで 公開しています。リポジトリのREADMEに、セットアップと実行の手順があります。コンシューマーグループの 調査、トゥームストーン伝播の観察、アプリケーションのローカルスケーリングの方法を含みます。


話しましょう

同じようなものを運用している、あるいは運用したことがあるなら、トレードオフがどこに落ち着いたかを ぜひ聞かせてください。連絡先はフッターにあります。

よくある質問

Kafkaはポッド間のキャッシュ同期でRedisを置き換えられますか?

状態をすべてのインスタンスへブロードキャストするという限定された役割なら、置き換えられます。ただしそれは完全互換の代替品ではなく、関連する役割を果たす別の道具です。Redisは全ポッドに1つの共有キャッシュビューを与えますが、Kafkaはコンパクションされたトピックをリプレイして構築する、各ポッド固有の結果整合的なコピーを与えます。ローカル読み取りのレイテンシーが重要で、更新後の一時的な古さが許容できるなら、このパターンを使ってください。

N個のポッドがいるとき、全ポッドがすべてのKafkaメッセージを受け取るのですか、それともKafkaがメッセージを分割するのですか?

それはKafkaそのものではなく、完全にコンシューマーグループ次第です。1つのグループを共有するポッドはパーティションを分割して受け取り(ロードバランス)、各メッセージはちょうど1つのポッドに届きます。すべてのポッドに固有のコンシューマーグループを与えれば、各グループがトピック全体を独立に受け取るため、全ポッドが全メッセージを見ます。これがこの記事で扱うブロードキャストパターンです。

ポッドごとに独自のKafkaコンシューマーグループを与えるには?

人間が管理するプレフィックスと、Springのインスタンスごとの${random.uuid}値を組み合わせます: group-id: ${CONSUMER_GROUP_PREFIX}-${random.uuid}。アプリケーションインスタンスごとに一意なグループが得られ、すべてのポッドがトピック全体を独立に消費します。

Kafkaトピックのコンパクションを使っているとき、キーの削除はどう扱えばよいですか?

トゥームストーンを発行します。同じキーで値がnullのレコードです。コンシューマーはこれに遭遇すると、nullをキャッシュする代わりにキーを削除します。Kafkaは最終的に置き換えられた値とトゥームストーンの両方を取り除きます。delete.retention.msは、オフセットゼロからのフルリプレイがこの窓の内に完了できるようサイズ設定してください。Kafkaはこれを、オフセットゼロから有効なスナップショットを再構築できる上限として文書化しています。

定時ジョブやトラフィックは、Kafkaの消費が追いつくまで待つべきですか?

はい。トピックのリプレイが終わる前にリクエストの処理や定時ジョブを始めるポッドは、空っぽか部分的なキャッシュで動いていることになります。起動時リプレイが完了するまでレディネスはDOWNのままにしてください。この例では、パーティション割り当て時に各パーティションのエンドオフセットを記録し、処理済み位置がすべてのターゲットに達した後にのみレディネスを開放します。

更新が絶えないと、新しいポッドは起動中のまま永久に止まりますか?

いいえ。レディネスゲートは、Kafkaがパーティションを割り当てた時点の固定エンドオフセットを記録します。そのスナップショットの後に追加されたレコードは起動ターゲットを動かさず、ポッドはそれらを通常の結果整合的な更新として処理します。ただし既存のコンパクション済みログが大きいと起動は長引きます。だからこそこのパターンは、機能フラグやサービス設定のような小さく低ボリュームのupsertトピックに最適なのです。