読んでも消えないキュー — Kafkaとオフセット

Kafkaとオフセット。保存されたメッセージの列と読んだ位置を示すしおり、戻る矢印。

※本記事はアフィリエイト広告(PR)を含みます。

メッセージキューの回で、RabbitMQ を立てて「あとでやる」を作りました。ワーカーが ack を返すと、そのメッセージはキューから消えます。それが正しい動作でした。仕事が終わったのだから、置いておく理由がありません。

前回: 書いた直後に読むと無い — レプリケーションとCAP 作業場所はVMの中(Ubuntu Server)です。Docker と Docker Composeの書き方|複数コンテナをまとめて起動する が動いていて、RabbitMQで非同期処理にする|メッセージキューの基本で RabbitMQ を触ったところから始めます。RabbitMQ が動いたままなら、この回では止めてください(メモリが足りません)。

ですが、あの回のあと、答えを出していない問いが1つ残っています。

「さっき処理したあれ、もう一度やり直したい」

具体的には、こういうときです。

  • ワーカーのコードにバグがあった。直したので、昨日の1万件をもう一度流したい
  • 集計を1つ足したくなった。過去の注文を全部、頭から読み直したい
  • 「注文が入った」を、いまはメールを送るワーカーだけが読んでいる。あとから「在庫を減らす」ワーカーも同じものを読みたい

RabbitMQ では、どれもできません。 理由は1つです。

消えているからです。 ack を返した時点で、そのメッセージはブローカーのどこにも残っていません。

やり直したければ、送った側にもう一度送ってもらうしかありません。 ですが送った側も、送ったあとの控えを持っていないのが普通です。つまり、そのデータはもう世界のどこにもありません。

この記事で立てるものは、その一点だけが違います。

Kafka は、読んでも消えません。 どこまで読んだかは、ブローカーではなく、読む側が数字で覚えます。 だから、その数字を戻せば、もう一度読めます。

「メッセージキュー」という同じ棚に並んでいますが、中でやっていることは別物です。 そこを最初に、図で並べます。

対象レベル: 中級 / 区分: 必修

目次

この記事でわかること

  • Kafka はキューではなくログだということ。読んでも消えず、消えるのは「時間が来たとき」だけであること
  • 「どこまで読んだか」を持っているのが誰かが RabbitMQ と正反対で、それがこの記事の全部だということ
  • 順序が保証されるのはパーティションの中だけで、トピック全体では順序は無いこと。ここを誤解すると事故ること
  • コンシューマーグループが同じなら分担、違えば両方に届くこと。「増やす」と「配る」が同じ仕組みで書けること
  • 保持期間は永久ではないこと。既定では1週間で消えること
  • 読む側が遅いとき、Kafka は溜まるだけで、RabbitMQ は送る側が止まること
  • 個人のサービスには、Kafka は重すぎること

この記事でやること

  1. メモリの空きを先に見る(Kafka は RabbitMQ の5倍近く使います)
  2. Kafka を Docker Compose で1ノード立てる(KRaft モード。ZooKeeper は使いません)
  3. トピックを作って、CLI で送って、CLI で読む
  4. オフセットを巻き戻して、同じメッセージをもう一度読む(この記事の山場)
  5. コンシューマーを2つ立てて、同じグループと別グループの違いを目で見る
  6. 後片づけして、メモリを返す

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
トピック(topic)メッセージの置き場所の名前。 RabbitMQ の「キュー」に当たる位置ですが、中身は下記のログです
ログ(log)ここでは「末尾に追記するだけのファイル」の意味。障害調査で見るあのログとは別の話です
オフセット(offset)ログの何番目まで読んだかを表す通し番号。 0 から始まります
パーティション(partition)1つのトピックを分割した、実体としてのログ。 順序が守られる単位でもあります
コンシューマーグループ「同じ仕事をする読み手の集まり」の名前。 オフセットはこのグループ単位で記録されます
ラグ(lag)末尾のオフセット − いま読んだオフセット。 つまりまだ読んでいない件数
KRaft(クラフト)Kafka が自分でクラスタの管理をする仕組み。以前は ZooKeeper という別サーバーが必要でした
保持期間(retention)メッセージをディスクに置いておく期間。 これを過ぎると、読まれていても消えます
背圧(バックプレッシャ)受け取る側が追いつかないとき、その圧力が送る側まで戻ってくること

「ログ」という言葉が、この記事では2つの意味で出てきます。 混乱しやすいので先に断っておきます。 Lokiの回で集めたアプリのログ(人が読む文字列)とは別に、 Kafka の言う「ログ」は、末尾にしか書けないデータ構造そのものを指します。ここでは後者です。

① 一番大事な違い —— キューではなく、ログ

先にここを飲み込んでください。 ここが分かっていないと、以降のコマンドは全部「なんとなく動いた」で終わります。

キューの絵

RabbitMQ はこうでした。

  送る側 →  [ D ][ C ][ B ]  → 読む側
                              ↑ B を取り出して ack
                              
  ack のあと:  [ D ][ C ]     ← B はもう存在しない

箱から取り出したら、箱から無くなります。 取り出したものを誰が持っているかは、ブローカーが管理しています。「まだ ack が来ていない」を覚えているのはブローカー側です。

ログの絵

Kafka はこうです。

  送る側 → 末尾に追記するだけ
           ┌────┬────┬────┬────┬────┬────┐
  ログ:    │ 0  │ 1  │ 2  │ 3  │ 4  │ 5  │  ← 消えない
           └────┴────┴────┴────┴────┴────┘
                      ↑              ↑
                読み手A(g1)      読み手B(g2)
                offset=2         offset=5

メッセージは、書かれた場所から動きません。 動くのは「いまここを読んでいる」という指の位置だけです。

そして、その指を持っているのは読む側です。 Kafka のブローカーは「A は 2 番まで読んだと言っていた」を記録しているだけで、A に何かを配ったりはしていません。

表で並べる

RabbitMQ(キュー)Kafka(ログ)
読んだあと消える残る
「どこまで」を持つのはブローカー(未 ack を覚えている)読む側(オフセットという数字)
もう一度読むできない数字を戻すだけ
読み手を増やす仕事を分け合う(同じものは来ない)グループ次第。 分けることも、全員に配ることもできる
消えるのは読まれたとき時間かサイズが上限に来たとき
メッセージの寿命処理されるまで保持期間のあいだ(既定7日)
向いている問い「この仕事、誰かやっといて」「こういう出来事が起きた」

一番下の行が、実は本質です。

RabbitMQ は「仕事を配る」道具。 Kafka は「出来事を記録する」道具。

記録なので、読まれても消えないのは当たり前です。 帳簿は、誰かが読んだからといって消えません。

すでに見たことがある発想です

この「変更を追記したログを、あとから再生する」は、初めてではありません。

レプリケーションの回で、MySQL のバイナリログを複製先に送って、同じ順番でもう一度実行させました。 複製先がやっていたことは「ログを読んで再生する」で、GTID は「どこまで反映したか」の目印でした。

Kafka のオフセットは、あの GTID とまったく同じ役割です。 送っているものが「SQLの変更」か「アプリの出来事」かが違うだけで、仕組みの発想は同じです。

だから Kafka は「データベースのレプリケーションを、アプリのレベルでやる道具」だと思うと、いちばん近いです。

② 先にメモリを見る

Kafka は Java で動きます。 JVM が起動しただけで数百MBを取ります。RabbitMQ が130MBだったのに対して、Kafka は600MB前後です。学習用のVMでは、これが一番の事故ポイントです。

立てる前に、いまの空きを見ます。

bash
$ free -h

出力例(この記事の実機)

               total        used        free      shared  buff/cache   available
Mem:           3.8Gi       1.2Gi       1.4Gi        14Mi       1.2Gi       2.4Gi

available を見てください。

availableどうする
1.5GB 以上そのまま進めます
1.0〜1.5GB動きますが、他のコンテナは止めてください
1.0GB 未満止めてください。 何かを止めてから戻ってきます

いま何が動いているかを確かめます。

bash
$ docker ps

RabbitMQ、MySQLのコンテナ、Prometheus など、この回で使わないものは止めます。

bash
$ cd ~/queue && docker compose stop
$ cd ~/repl && docker compose stop
$ cd ~/monitoring && docker compose stop

available が足りないまま Kafka を起動すると、Killed とだけ出て落ちます。 これは Linux の OOM Killer が、メモリを一番使っているプロセスを問答無用で殺した印です。 エラーの理由がどこにも書かれないので、原因が分からず何時間も溶かします。 レプリケーションの回と同じ話です。先に見れば5秒で分かります。

JVM が数百 MB を取る Kafka のようなものを何度も立てる段階になると、VM の割り当てより、自宅に常時動かす検証機を 1 台置くほうが落ち着く場合があります。GMKtecのミニ PC なら G11 PLUS(Ryzen 5 3500U)の 16GB+256GB SSD が 49,599 円(税込・2026 年 10 月 3 日時点の公式ストア表示)で、1 年保証が付きます。安く見える「〜円から」はメモリ・SSD・OS 非搭載のベアボーンの価格で、基本は香港からの発送なので、到着までの日数も見込んでください。

③ Kafka を Docker Compose で立てる

ZooKeeper は使いません

ネットで Kafka の記事を探すと、ほぼ必ず ZooKeeper という別のサーバーが一緒に出てきます。

ZooKeeper は「クラスタの誰が親分か」を決めるための、Kafka とは別のソフトです。 Kafka を1台立てるのに、サーバーを2種類立てる必要がありました。

これは古い形です。 Kafka はKRaft モードという、自分でその役をやる仕組みを持つようになり、4.0 では ZooKeeper が完全に削除されました。

つまり、ZooKeeper が出てくる手順書は、いま読むべきものではありません。 メモリの少ないVMで2種類立てるのは、そもそも無理です。 この記事では KRaft の1ノードだけを立てます。

compose.yaml

bash
$ mkdir -p ~/kafka/data
$ cd ~/kafka
$ nano compose.yaml
services:
  kafka:
    image: apache/kafka:3.9.0
    restart: unless-stopped
    ports:
      - "127.0.0.1:9092:9092"
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@127.0.0.1:9093
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_NUM_PARTITIONS: 1
      KAFKA_LOG_DIRS: /var/lib/kafka/data
      KAFKA_LOG_RETENTION_CHECK_INTERVAL_MS: 30000
      KAFKA_HEAP_OPTS: -Xmx512m -Xms256m
    volumes:
      - ./data:/var/lib/kafka/data
    mem_limit: 1g

1行ずつ

書いたものなぜ
apache/kafka:3.9.0Apache 公式のイメージ。 タグは固定します(latest は黙って上がります)。3.9 は ZooKeeper を選べる最後の版ですが、ここでは使いません
ports: "127.0.0.1:9092:9092"左端の 127.0.0.1 が本体。 VMの中からしか繋げません(下記)
KAFKA_NODE_ID: 1このノードの背番号。 1台でも必要です
KAFKA_PROCESS_ROLES: broker,controllerこれが KRaft の指定。 「メッセージを預かる係」と「まとめ役」を、1つのプロセスが兼任するという意味です。ZooKeeper が消えたのはここです
KAFKA_LISTENERSどのポートで待つか。 9092 がアプリ用、9093 がまとめ役どうしの内部通信用
KAFKA_ADVERTISED_LISTENERS「私にはこの住所で繋いでください」とクライアントに教える値。 ここを間違えるのが、Kafka で一番多い事故です(下記)
KAFKA_CONTROLLER_QUORUM_VOTERS: 1@...まとめ役の一覧。 1台なので自分だけです
..._REPLICATION_FACTOR: 1 の3行Kafka が内部で使うトピックを、何台に複製するか。 既定は3で、1台だと作成に失敗します。 1台構成では必ず 1 にします
KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0読み手が繋いだあと、担当を決めるまでの待ち時間。 既定は3秒。学習中は待ちたくないので0にします
KAFKA_NUM_PARTITIONS: 1トピックを作るときの、既定の分割数(⑦で明示的に変えます)
KAFKA_LOG_RETENTION_CHECK_INTERVAL_MS: 30000「保持期間を過ぎたものが無いか」を見に行く間隔。 既定は5分ですが、⑧の実験を待たずに済むよう30秒にしています
KAFKA_HEAP_OPTS: -Xmx512mJVM が使ってよいメモリの上限。 書かないと1GBを取りに行きます
./data:/var/lib/kafka/dataメッセージの実体を置く場所。 バインドマウントにしているのは、⑦で実物のファイルを見るためです
mem_limit: 1gコンテナ全体の上限。 JVM のヒープ以外(スレッド・バッファ)も使うので、少し上に取ります

mem_limit は保険です。 これを書いておくと、暴走しても他のプロセスを巻き添えにしません。 VM全体が固まって強制電源断、を避けられます。

ADVERTISED_LISTENERS の話

ここだけ、他のミドルウェアに無い癖があります。

クライアントは、最初に 9092 に繋いで「担当ブローカーの住所」を聞きます。 そして、返ってきた住所に繋ぎ直します。 その「返す住所」が ADVERTISED_LISTENERS です。

つまり、最初に繋げたのに、そのあと繋がらないという状態が起こりえます。

  クライアント → 127.0.0.1:9092 に接続  → OK
  ブローカー   → 「kafka:9092 に繋いで」と返す
  クライアント → kafka という名前が引けない → 失敗

127.0.0.1 と書いているのは、そのためです。 VMの中から見ても、コンテナの中から見ても、127.0.0.1:9092 で Kafka に届くようにポートを公開してあります。

VM の外(Windows)から繋ぎたくなったら、ここを VM の IP に変えることになります。 ですが、この記事ではやりません。 Kafka は認証なしで立てています。 外に出した瞬間、誰でもトピックを消せます。

外に出さない

RabbitMQ の回と同じ注意です。

    ports:
      - "9092:9092"        # ← これは駄目

これは「どこからでも繋いでいい」という意味です。 そして、あの回で確かめたとおり——

Docker の ports: は、ufw を素通りします。

ufw で閉じてあっても、ufw status に出てこない穴が開きます。 左端の 127.0.0.1: が唯一の守りです。

起動する

bash
$ cd ~/kafka
$ docker compose up -d

初回はイメージのダウンロードで数分かかります。 起動を確かめます。

bash
$ docker compose ps
$ docker compose logs --tail 5 kafka
kafka-1  | [KafkaRaftServer nodeId=1] Kafka Server started

Kafka Server started が出ていれば成功です。

[スクリーンショット: 01_kafka起動確認.png] docker compose ps と docker compose logs --tail 5 kafka を実行して、Kafka Server started が出ているところを撮ってください。

外に出ていないことを、目で確かめる

bash
$ ss -tlnp | grep 9092
LISTEN 0  4096  127.0.0.1:9092  0.0.0.0:*

左側が 127.0.0.1 なら正解です。 0.0.0.0 なら外に出ています。compose.yaml を直して docker compose up -d をやり直してください。

メモリをもう一度見る

bash
$ docker stats --no-stream
$ free -h
CONTAINER ID   NAME       CPU %   MEM USAGE / LIMIT   MEM %
9f1c2b3a4d5e   kafka-1    2.1%    611.8MiB / 1GiB     59.75%

何もしていない状態で600MB前後です。 RabbitMQ の130MB、Redis の十数MBと比べてください。 この数字は、あとで「使い分け」を考えるときに効いてきます。 覚えておいてください。

④ トピックを作って、送って、読む

まずCLIでやります。 アプリのコードは書きません。コードを書くと、そこで詰まったときに Kafka の問題なのかコードの問題なのか分からなくなるからです。

Kafka の CLI ツールは、コンテナの中の /opt/kafka/bin/ に入っています。 VMに何も入れずに使えます。

トピックを作る

bash
$ cd ~/kafka
$ docker compose exec kafka /opt/kafka/bin/kafka-topics.sh \
    --bootstrap-server 127.0.0.1:9092 \
    --create --topic orders --partitions 1 --replication-factor 1
Created topic orders.
オプション意味
--bootstrap-server最初に聞きに行く先。 ここから「本当の住所」を教わります(③の話)
--partitions 1分割しない。 ⑦まではこれで進めます
--replication-factor 1複製しない。 1台しか無いので、これ以外に選択肢がありません

確かめます。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-topics.sh \
    --bootstrap-server 127.0.0.1:9092 --describe --topic orders
Topic: orders   TopicId: xQ1s...  PartitionCount: 1   ReplicationFactor: 1
        Topic: orders   Partition: 0    Leader: 1   Replicas: 1     Isr: 1

Partition: 0 が、実体としてのログ1本です。 トピックは、この束につけた名前でしかありません。

送る

bash
$ printf 'order-1\norder-2\norder-3\n' | docker compose exec -T kafka \
    /opt/kafka/bin/kafka-console-producer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic orders

何も表示されずに戻ってきたら成功です。

-T は「端末を割り当てない」という指定です。 これが無いと、パイプで流し込んだものが読まれずに固まります。 手で打ち込みたいときは -T を外して、> のプロンプトに1行ずつ入力し、Ctrl+C で抜けます。

読む

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic orders --from-beginning \
    --property print.offset=true
Offset:0        order-1
Offset:1        order-2
Offset:2        order-3

Ctrl+C で抜けます。

--from-beginning が無いと、何も出ません。 既定は「これから来るものだけ」です。 「送ったのに何も出てこない」の9割はこれです。 送信済みのものを見たいなら、必ず付けてください。

そして、ここで一度立ち止まってください。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic orders --from-beginning \
    --property print.offset=true

まったく同じコマンドを、もう一度打ってください。

Offset:0        order-1
Offset:1        order-2
Offset:2        order-3

同じものが、もう一度出ました。 RabbitMQ なら、1回目で消えています。 2回目は何も出ません。

これが「読んでも消えない」の意味です。 ここまでは、まだ準備運動です。

⑤ 同じメッセージを、意図的にもう一度読む

さっきのは「毎回頭から読んだ」だけで、実務では使えません。 実際のワーカーは、続きから読む必要があります。

続きから読むために「どこまで読んだか」を記録する。 記録する単位が、コンシューマーグループです。

グループを付けて読む

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic orders \
    --group mailer --from-beginning --property print.offset=true
Offset:0        order-1
Offset:1        order-2
Offset:2        order-3

Ctrl+C で抜けます。 そして、同じコマンドをもう一度打ってください。

(何も出ない)

今度は何も出ませんでした。 --group mailer を付けたことで、「mailer は 2 番まで読んだ」がブローカーに記録されたからです。 --from-beginning は「記録が無いときだけ」効きます。 記録があれば、その続きから読みます。

Ctrl+C で抜けます。

いま、どこを読んでいるか

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-consumer-groups.sh \
    --bootstrap-server 127.0.0.1:9092 --group mailer --describe
GROUP   TOPIC   PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
mailer  orders  0          3               3               0
列意味
CURRENT-OFFSETこのグループが「次に読む」位置。 3件読んだので 3
LOG-END-OFFSETログの末尾。 いま3件入っているので 3
LAG末尾との差。 まだ読んでいない件数です。0 なら追いついています

この LAG の1列が、Kafka の監視のほぼ全部です。 ⑨でもう一度出てきます。

巻き戻す

ここが、この記事の山場です。

「ワーカーにバグがあったので、3件をもう一度処理したい」を、やります。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-consumer-groups.sh \
    --bootstrap-server 127.0.0.1:9092 --group mailer \
    --reset-offsets --to-earliest --topic orders --execute
GROUP      TOPIC   PARTITION  NEW-OFFSET
mailer     orders  0          0

--execute を付けないと、何も起きません。 付けないときは「こうなります」と表示するだけの下見(dry run)です。これは親切な仕様です。 そして、そのグループで誰かが読んでいる最中だと、断られます。

Error: Assignments can only be reset if the group 'mailer' is inactive

さっきの Ctrl+C を、ちゃんとやっていないと、これが出ます。consumer を全部止めてから打ってください。

もう一度、同じ読み方をします。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic orders \
    --group mailer --property print.offset=true
Offset:0        order-1
Offset:1        order-2
Offset:2        order-3

--from-beginning を付けていないのに、頭から出ました。

[スクリーンショット: 02_オフセットを戻して再生.png] --reset-offsets --to-earliest --execute を実行した結果と、そのあと consumer が Offset:0 から読み直しているところを、続けて撮ってください。

これが、RabbitMQ では絶対にできなかったことです。 メッセージは消えていない。 消えていたのは、読んだという記録のほうです。 記録を戻せば、実体はまだそこにあります。

Ctrl+C で抜けます。

戻し方は「頭から」だけではない

指定どこへ
--to-earliest残っている一番古いところへ。 よく使います
--to-latest末尾へ。 溜まったものを全部捨てて追いつくときに使います
--shift-by -100100件だけ戻す
--to-datetime 2026-09-11T00:00:00.000その時刻以降の最初のものへ。 「昨日の分をやり直す」はこれです

--to-latest は、事故を止めるときの手です。 壊れたメッセージが大量に溜まって処理が進まないとき、「読まなかったことにして追いつく」ができます。 RabbitMQ で同じことをしようとすると、キューごと消すしかありませんでした。

オフセットは、どこに書かれているのか

ブローカーが特別な場所に持っているわけではありません。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-topics.sh \
    --bootstrap-server 127.0.0.1:9092 --list
__consumer_offsets
orders

__consumer_offsets という、Kafka 自身のトピックに書かれています。 「どこまで読んだか」もまた、追記されていく出来事の1つとして扱われているわけです。 compose.yaml の KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1 は、このトピックを何台に複製するかの設定でした。既定の 3 のままだと、1台構成では作れずに詰まります。

⑥ コンシューマーグループ —— 分担と、同報

もう1つのトピックを、分割ありで作ります。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-topics.sh \
    --bootstrap-server 127.0.0.1:9092 \
    --create --topic events --partitions 3 --replication-factor 1

同じグループなら、分担する

ターミナルを3つ使います。 VS Code のターミナルを分割しても構いません。

ターミナル①(グループ worker)

bash
$ cd ~/kafka
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events \
    --group worker --property print.partition=true

ターミナル②(同じグループ worker)

bash
$ cd ~/kafka
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events \
    --group worker --property print.partition=true

ターミナル③(送る側)。キーを付けて送ります(1:e1 の : の左がキー。キーで行き先のパーティションが決まります。詳しくは⑦)。 キーを付けずにまとめて送ると、Kafka 2.4 以降の既定では数件が同じパーティションにまとまって入るため、片方のターミナルにしか出ないことがあります。

bash
$ cd ~/kafka
$ printf '1:e1\n2:e2\n3:e3\n4:e4\n5:e5\n6:e6\n' | docker compose exec -T kafka \
    /opt/kafka/bin/kafka-console-producer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events \
    --property parse.key=true --property key.separator=:

①と②に、バラバラに出ます。(どのパーティションがどちらに割り当たるか、行の並ぶ順は、実行によって変わります)

(片方のターミナル)
Partition:0     e1
Partition:1     e4
Partition:0     e5
Partition:1     e6

(もう片方のターミナル)
Partition:2     e2
Partition:2     e3

同じメッセージは、どちらか一方にしか出ません。 これが「分担」です。 仕事を分けたいなら、グループ名を揃える。 RabbitMQ でワーカーを2本立てたときと、外から見た挙動は同じです。

別のグループなら、両方に届く

ターミナル②を Ctrl+C で止めて、グループ名だけ変えて立て直します。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events \
    --group audit --property print.partition=true

ターミナル③から、もう一度送ります。

bash
$ printf 'x1\nx2\nx3\n' | docker compose exec -T kafka \
    /opt/kafka/bin/kafka-console-producer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events

今度は、①にも②にも、同じ3件が出ます。

[スクリーンショット: 03_コンシューマーグループ.png] worker と audit の2つのコンシューマーに、同じメッセージが両方出ているところを、2画面が並んだ状態で撮ってください。

Ctrl+C で両方止めます。

何が起きたか

                    ┌──────────────┐
   送る側 ─────────→│  events      │
                    └──────────────┘
                        ↓        ↓
             group=worker      group=audit
            (2人で分担)      (全部読む)

グループが違えば、オフセットも別々に持ちます。 お互いの存在を知りません。

これが効くのは、こういうときです。

やりたいことどうする
処理が追いつかない同じグループで、コンシューマーを増やす
「注文が入った」で、別のこともやりたくなった新しいグループで、同じトピックを読む
その新機能で、過去の分も処理したい新しいグループなので、--from-beginning で頭から読める

3行目が、Kafka を使う一番の理由です。 あとから来た読み手が、過去に遡れる。 送る側は、何も変えなくていい。送る側と読む側が、時間の面でも切り離されています。

コンシューマーは、パーティションより多くしても無駄

さっきのトピックはパーティションが3本でした。 同じグループでコンシューマーを4つ立てるとどうなるか。

4つ目は、何も割り当てられず、ずっと暇なままです。

1つのパーティションは、同じグループの中で1人しか読めません。 順序を守るためです。

つまり、パーティション数が「同じグループで並列に処理できる上限」です。 あとから増やせますが、減らせません。 そして増やすと、⑦の話が壊れます。

⑦ パーティション —— 順序が守られるのは、中だけ

ここを誤解すると、静かに壊れます。

実物を見る

バインドマウントにしたので、ホスト側からファイルが見えます。

bash
$ ls ~/kafka/data | head
events-0
events-1
events-2
orders-0
bash
$ ls -l ~/kafka/data/events-0/
-rw-r--r-- 1 ubuntu ubuntu 10485760 Sep 11 10:22 00000000000000000000.index
-rw-r--r-- 1 ubuntu ubuntu      263 Sep 11 10:22 00000000000000000000.log
-rw-r--r-- 1 ubuntu ubuntu 10485760 Sep 11 10:22 00000000000000000000.timeindex

.log が、追記されていく実体です。 パーティションごとに、別のディレクトリ・別のファイルになっています。 「1つのトピック」は、ディスクの上では複数の別々のファイルです。 ここが分かると、次の話が当たり前に聞こえます。

順序の保証

Kafka が保証するのは「1つのパーティションの中で、書いた順に読める」ことだけです。 トピック全体で、書いた順に読めるとは、一言も言っていません。

⑥で e1 〜 e6 を送ったとき、こう出ました。

Partition:0     e1
Partition:2     e2
Partition:2     e3
Partition:1     e4

送った順は e1, e2, e3, e4 ですが、読む側から見た順序は保証されていません。 別のファイルに書かれているので、当然です。

これが事故になるとき

  「ユーザー42 が住所を A に変更した」   → パーティション 1 へ
  「ユーザー42 が住所を B に変更した」   → パーティション 0 へ

この2つを、別々のコンシューマーが同時に処理します。

どちらが先に処理されるかは、運です。 最終的な住所が A になることがあります。 利用者は B に変えたのに。

そして、これはエラーになりません。 ログにも何も出ません。「ときどきデータがおかしい」という、一番厄介な壊れ方をします。

直し方 —— キーで振り分ける

答えは1つです。

「順序が大事な相手」を、必ず同じパーティションに入れる。

Kafka は、メッセージにキーを付けると、そのキーのハッシュでパーティションを決めます。 同じキーは、必ず同じパーティションに行きます。

bash
$ printf 'u42:住所をAに\nu42:住所をBに\nu7:名前を変更\nu42:住所をCに\n' | \
  docker compose exec -T kafka /opt/kafka/bin/kafka-console-producer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events \
    --property parse.key=true --property key.separator=:

読んで確かめます。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-console-consumer.sh \
    --bootstrap-server 127.0.0.1:9092 --topic events --from-beginning \
    --property print.key=true --property print.partition=true \
    --property print.offset=true

u42 の3件が、すべて同じ Partition: の番号に並んでいるはずです。

Partition:1     Offset:3        u42     住所をAに
Partition:1     Offset:4        u42     住所をBに
Partition:1     Offset:5        u42     住所をCに
Partition:2     Offset:2        u7      名前を変更

Ctrl+C で抜けます。

キーは「誰の話か」を書くものです。ユーザーID、注文ID、機器のシリアル番号。 「同じものについての出来事は、一列に並ぶ」——これが、キーを付ける唯一の目的です。

パーティション数を増やすと、この保証は壊れる

あとからパーティションを3本から6本に増やすと、割り当てを決めるハッシュの計算結果が変わります。

昨日まで u42 が入っていたパーティションと、今日から入るパーティションが、変わります。 古い出来事と新しい出来事が、別の場所に並びます。 順序は、そこで切れます。

だから、パーティション数は最初に決めます。 迷ったら少なめにします(増やすことはできても、減らせません)。

キーの偏りにも注意してください。 特定のキーだけが極端に多いと、そのパーティションだけが混みます。 負荷分散の回で見た「均等に配ったつもりが、偏る」と同じ話です。

⑧ 保持期間 —— 永久には残りません

「読んでも消えない」を、「ずっと残る」と読まないでください。

Kafka は、時間かサイズの上限で、古いほうから消します。

いまの設定を見ます。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-configs.sh \
    --bootstrap-server 127.0.0.1:9092 \
    --entity-type topics --entity-name orders --describe --all | grep retention
設定既定値意味
retention.ms604800000(7日)これより古いものは消す
retention.bytes-1(無制限)パーティションがこのサイズを超えたら、古いほうから消す
segment.bytes1073741824(1GB)ログを何バイトごとに別ファイルに区切るか

既定は7日です。 「1か月前のデータをやり直したい」は、設定を変えていなければできません。 retention.bytes も併せて設定してください。 時間だけ決めていると、想定より流量が増えたときにディスクが埋まります。 Lokiの回で書いた「保持期間を忘れるとディスクが減り続ける」と、まったく同じ話です。

短くして、消えるところを見る

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-configs.sh \
    --bootstrap-server 127.0.0.1:9092 \
    --entity-type topics --entity-name orders --alter \
    --add-config retention.ms=10000,segment.bytes=200

1分ほど待ってから、一番古いオフセットを見ます。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-get-offsets.sh \
    --bootstrap-server 127.0.0.1:9092 --topic orders --time earliest
orders:0:3

一番古いオフセットが 0 ではなく 3 になりました。 0〜2 は、もうありません。 オフセットの番号は詰められません。 消えた分は、欠番になるだけです。

segment.bytes=200 を一緒に指定したのには理由があります。 Kafka は、いま書き込み中のファイル(アクティブセグメント)を絶対に消しません。 ファイルを区切らないと、何日経っても1件も消えません。 「保持期間を過ぎたのに減らない」の原因は、ほぼこれです。 本番でこんな小さい値にはしません(200バイトごとにファイルが増えます)。

元に戻します。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-configs.sh \
    --bootstrap-server 127.0.0.1:9092 \
    --entity-type topics --entity-name orders --alter \
    --delete-config retention.ms,segment.bytes

「消したくない出来事」を Kafka に置きっぱなしにするのは、間違いです。 Kafka は、通り道です。 残すべきものは、読んだ側がデータベースに書きます。

⑨ 背圧 —— 読む側が遅いと、どうなるか

送る速さより、読む速さが遅い。 これは必ず起きます。そのとき何が起こるかが、RabbitMQ と Kafka で正反対です。

Kafka の場合 —— 溜まる

溜まっているかどうかは、⑤で見た LAG で分かります。

bash
$ docker compose exec kafka /opt/kafka/bin/kafka-consumer-groups.sh \
    --bootstrap-server 127.0.0.1:9092 --group worker --describe
GROUP   TOPIC   PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
worker  events  0          2               4               2
worker  events  1          3               6               3
worker  events  2          2               3               1
見え方意味
0 付近を上下する正常。 追いつけています
じわじわ増え続ける処理が追いついていない。 コンシューマーを増やす(パーティション数が上限)
一気に増えて減らないコンシューマーが死んでいる

絶対値では判断できません。見るのは傾きです。 RabbitMQ の messages_ready と同じ読み方をします。 監視の回で入れた Prometheus に食わせるなら、kafka_exporter のような別プロセスを立ててこの数字を出させます。

そして、送る側はどうなるか。

何も起きません。 ディスクが埋まるまで、ずっと受け付け続けます。

RabbitMQ の場合 —— 詰まる

前回の RabbitMQ では、こうでした。

メモリが規定の割合を超えると、ブローカーが送る側を黙って止めます。 エラーも返りません。 API が固まります。

どちらが良いのか

KafkaRabbitMQ
溜まる場所ディスクメモリ(あふれるとディスクへ退避)
溜まりすぎたとき送る側は影響を受けない(ディスクが尽きるまで)送る側が止まる(フロー制御)
限界に来たらディスク満杯でブローカーが停止送る側が固まる

Kafka のほうが優しく見えますが、そうとも言えません。 「送る側が止まる」は、異常が上流まで伝わっているということでもあります。背圧が効いている状態です。 Kafka は、異常を隠したまま溜め続けます。 気づいたときには、7日分のディスクが埋まっています。

だから、Kafka では LAG の監視が必須です。 止まらないから、自分で見るしかありません。

なお Kafka の送る側も無敵ではありません。 ブローカーが応答しなくなると、送信バッファ(既定32MB)が埋まって、send() が待たされ、やがて例外になります。 「絶対に詰まらない」ではなく、「詰まるまでの余裕がとても大きい」です。

⑩ ストリーム処理という言葉

Kafka を調べると必ず出てくる言葉なので、1段落だけ。

流れてくるものを、溜めてからではなく、流れているその場で集計する——これがストリーム処理です。

いつもの集計は、こうです。 1日分をデータベースに溜めて、夜中に SELECT ... GROUP BY を流す。答えが出るのは翌朝です。

ストリーム処理は、1件届くたびに合計を更新します。 答えは常に「いまの値」です。 「直近5分間の注文数」のような、時間で区切った集計(ウィンドウ、と言います)もここに入ります。

Kafka にはそのための道具(Kafka Streams、ksqlDB、外側では Apache Flink)がありますが、この記事では立てません。

理由は2つです。 メモリが足りないことと、その前に覚えることが多すぎることです。 「そういう分野がある」だけ知っていれば、いまは十分です。 必要になったとき、この記事の「トピック・パーティション・オフセット」が、そのまま前提知識になります。

⑪ RabbitMQ と Kafka、どちらを使うのか

ここまでの全部を、1枚の表にします。

RabbitMQKafka
一言で仕事を配る出来事を記録する
中身キュー(取り出すと消える)ログ(追記だけ。消えない)
「どこまで」を持つのはブローカー読む側(オフセット)
やり直しできないオフセットを戻すだけ
読み手を増やす分担のみ分担も同報も、グループ名だけで切り替わる
順序1つのキューの中で保証(ただし複数ワーカーなら追い越す)1つのパーティションの中だけ
メッセージごとの再試行できる(1件だけ nack して DLQ へ)苦手。 1件だけ飛ばすのは、自分で書く
溜まったとき送る側が止まる溜まり続ける
メモリ130MB 前後600MB 前後
1台で動くか動く動くが、本来は3台以上を前提にした設計

選び方は、この2問だけ

問い答え
「これをやっといて」と、誰か1人に頼みたいか→ RabbitMQ
「こういうことが起きた」を、誰が読むか分からないまま置いておきたいか→ Kafka

具体例で並べます。

やりたいこと向いているのは
メール送信、画像変換、PDF生成RabbitMQ(1回やれば終わり。やり直したくもない)
決済処理のような、1件ずつ丁寧に再試行したい仕事RabbitMQ(DLQ が要る)
アクセスログ、クリック、センサーの値Kafka(大量。あとで何に使うか分からない)
「注文が入った」を、複数のサービスが別々に使うKafka(読み手が増えても送る側を変えない)
データベースの変更を、他のシステムに配るKafka(レプリケーションと同じ発想)

そして、個人のサービスには重すぎます

正直に書きます。

個人で作るサービスに、Kafka はまず要りません。

理由は、性能ではなく、割に合わなさです。

増えるもの具体的に
メモリ 600MB1台のVPSなら、これだけで予算の半分です
本来は3台以上1台で立てると、そのマシンが落ちた瞬間に全部消えます。 Kafka の強みは複製ですが、複製には台数が要ります
監視が必須溜まっても止まらないので、LAG を誰かが見ていないといけません
設計の決めごとパーティション数、キー、保持期間。 どれもあとから直しにくい
運用の知識リバランス、ISR、リーダー選出——この記事で触れていないものが、まだ大量にあります

入れる前に、この順で考えてください。

問い答えがこうなら
やり直しは本当に要るか要らないなら RabbitMQ。 軽くて、DLQ もある
1日に何件流れるか数万件までなら、MySQL にテーブルを1枚作って追記するだけで足ります。オフセットは自分で列に持てます
読み手は何種類あるか1種類なら、Kafka の一番の売り(同報)が効きません
サービスは分かれているかまだモノリスなら、そもそも間に何かを挟む理由がありません

「テーブルに追記して、処理済みの位置を別の行で持つ」——これは Kafka の縮小版です。 仕組みを理解したうえで手で書くほうが、規模が小さいうちは、ほぼ確実に正解です。 この記事の価値は、Kafka を導入することではなく、「読んでも消えない」という設計を知ったことのほうにあります。

つまずいたところ

症状原因
コンテナが起動してすぐ落ちる。ログに Killed だけメモリ不足で OOM Killer に殺されている。 他のコンテナを止めて free -h を見る(②)
ログに INVALID_REPLICATION_FACTOR..._REPLICATION_FACTOR を 1 にしていない。 1台構成では既定の 3 では作れません
Connection to node -1 could not be establishedKafka がまだ起動中。 docker compose logs kafka で Kafka Server started を待つ
最初は繋がるのに、そのあとタイムアウトするKAFKA_ADVERTISED_LISTENERS が違う。 返された住所に繋ぎ直せていません(③)
kafka-console-producer.sh がパイプで固まるdocker compose exec に -T を付けていない
送ったのに consumer に何も出ない--from-beginning が無い。 既定は「これから来るもの」だけです
2回目の consumer で何も出ない正常です。 --group を付けたので、オフセットが記録されています(⑤)
Assignments can only be reset if the group is inactiveそのグループの consumer が動いたまま。 全部 Ctrl+C で止めてから
--reset-offsets を打ったのに何も変わらない--execute を付けていない。 付けないと下見だけです
コンシューマーを増やしたのに1つが暇なままパーティション数が足りない。 パーティションより多くは並列にできません(⑥)
送った順と読んだ順が違う正常です。 順序はパーティションの中だけ。 キーを付けて振り分けます(⑦)
キーを付けたのに、同じキーが別のパーティションに入ったあとからパーティション数を増やした。 割り当てが変わっています(⑦)
retention.ms を短くしたのに、何も消えないアクティブセグメントは消えません。 segment.bytes も小さくします(⑧)
~/kafka/data に Permission denied で書けないVMのユーザーの UID が 1000 ではない。 id -u で確認し、sudo chown -R 1000:1000 ~/kafka/data
ディスクの空きが減り続ける保持期間を設定していない。 retention.ms と retention.bytes の両方を入れる
VM 全体が重いKafka が600MB使っています。 使わないときは docker compose stop

後片づけ

Kafka を動かしっぱなしにしないでください。 600MB は、学習用のVMでは無視できません。

1. すべてのコンシューマーとプロデューサーを止めます。 各ターミナルで Ctrl+C。

2. しばらく使わないだけなら、止めるだけ。

bash
$ cd ~/kafka
$ docker compose stop

次に使うときは docker compose start です。 トピックもメッセージもオフセットも残ります。

3. 完全に消すとき。

bash
$ cd ~/kafka
$ docker compose down -v

-v だけでは、この記事のデータは消えません。 -v が消すのは「名前付きボリューム」です。 この記事ではバインドマウント(./data)にしたので、中身は ~/kafka/data にそのまま残ります。 これはバインドマウントの利点でもあり、落とし穴でもあります。 Composeの回で見た down と down -v の違いに、もう1段あったわけです。

中身も消すなら、手で消します。

bash
$ rm -rf ~/kafka/data

Permission denied が出たら sudo rm -rf ~/kafka/data です。 コンテナの中のユーザーが書いたファイルだからです。

4. イメージも消して、ディスクを戻します。

bash
$ docker image rm apache/kafka:3.9.0
$ docker system df

apache/kafka のイメージは 400MB ほどあります。

5. 止めていたものを、戻します。

bash
$ cd ~/repl && docker compose start

②で止めたものを戻すのを忘れないでください。 「あの環境、なぜか動かない」の原因になります。

まとめ

  • Kafka はキューではなくログ。 読んでも消えない。 消えるのは保持期間が来たときだけ
  • 「どこまで読んだか」を持っているのは、ブローカーではなく読む側。それがオフセットという数字
  • だから、数字を戻せばもう一度読める。 RabbitMQ では原理的にできなかったこと
  • オフセットはコンシューマーグループ単位。 グループが違えば、互いを知らない
  • 同じグループなら分担、別グループなら両方に届く。 「増やす」と「配る」が、名前1つで切り替わる
  • あとから来た読み手が、過去に遡れる。 送る側を1行も変えずに。 これが Kafka を使う最大の理由
  • 順序が守られるのはパーティションの中だけ。 トピック全体の順序は保証されない
  • 順序が大事なものには、キーを付ける。 同じキーは同じパーティションに入る
  • パーティション数は増やせるが減らせない。 増やすとキーの割り当てが変わり、順序の保証が切れる
  • コンシューマーは、パーティション数より多くしても暇なだけ
  • 保持期間は既定7日。 永久ではない。 残すものは、読んだ側がデータベースへ書く
  • アクティブセグメントは消えない。 「保持期間を過ぎたのに減らない」の原因はほぼこれ
  • 読む側が遅いとき、Kafka は溜まるだけ。 止まらないので、LAG を自分で見張る
  • RabbitMQ は逆に、溜まると送る側を黙って止める。 どちらが良いかではなく、性格が違う
  • 1台の Kafka は、Kafka の強みをほぼ捨てている。 学習用と割り切る
  • KRaft を使う。 ZooKeeper が出てくる手順書は、いま読むべきものではない
  • そして、個人のサービスに Kafka はまず要らない。 テーブルに追記して位置を持つ、で足ります

参考リンク


次に読む

この記事は 【第8段階】深掘り の 10 / 30 本目です。

記事
← 前の記事書いた直後に読むと無い — レプリケーションとCAP
→ 次の記事落ちても全部は止めない — サーキットブレーカと縮退

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

Backend›Message Brokers
  • Kafka — 読んでも消えないログ型のキュー
  • ストリーム処理と背圧(バックプレッシャ)

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次