※本記事はアフィリエイト広告(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 は重すぎること
この記事でやること
- メモリの空きを先に見る(Kafka は RabbitMQ の5倍近く使います)
- Kafka を Docker Compose で1ノード立てる(KRaft モード。ZooKeeper は使いません)
- トピックを作って、CLI で送って、CLI で読む
- オフセットを巻き戻して、同じメッセージをもう一度読む(この記事の山場)
- コンシューマーを2つ立てて、同じグループと別グループの違いを目で見る
- 後片づけして、メモリを返す
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| トピック(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では、これが一番の事故ポイントです。
立てる前に、いまの空きを見ます。
出力例(この記事の実機)
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 未満 | 止めてください。 何かを止めてから戻ってきます |
いま何が動いているかを確かめます。
RabbitMQ、MySQLのコンテナ、Prometheus など、この回で使わないものは止めます。
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
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.0 | Apache 公式のイメージ。 タグは固定します(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: -Xmx512m | JVM が使ってよいメモリの上限。 書かないと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: が唯一の守りです。
起動する
初回はイメージのダウンロードで数分かかります。 起動を確かめます。
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 が出ているところを撮ってください。
外に出ていないことを、目で確かめる
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 をやり直してください。
メモリをもう一度見る
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に何も入れずに使えます。
トピックを作る
Created topic orders.
| オプション | 意味 |
|---|---|
--bootstrap-server | 最初に聞きに行く先。 ここから「本当の住所」を教わります(③の話) |
--partitions 1 | 分割しない。 ⑦まではこれで進めます |
--replication-factor 1 | 複製しない。 1台しか無いので、これ以外に選択肢がありません |
確かめます。
Topic: orders TopicId: xQ1s... PartitionCount: 1 ReplicationFactor: 1
Topic: orders Partition: 0 Leader: 1 Replicas: 1 Isr: 1
Partition: 0が、実体としてのログ1本です。 トピックは、この束につけた名前でしかありません。
送る
何も表示されずに戻ってきたら成功です。
-Tは「端末を割り当てない」という指定です。 これが無いと、パイプで流し込んだものが読まれずに固まります。 手で打ち込みたいときは-Tを外して、>のプロンプトに1行ずつ入力し、Ctrl+Cで抜けます。
読む
Offset:0 order-1
Offset:1 order-2
Offset:2 order-3
Ctrl+C で抜けます。
--from-beginningが無いと、何も出ません。 既定は「これから来るものだけ」です。 「送ったのに何も出てこない」の9割はこれです。 送信済みのものを見たいなら、必ず付けてください。
そして、ここで一度立ち止まってください。
まったく同じコマンドを、もう一度打ってください。
Offset:0 order-1
Offset:1 order-2
Offset:2 order-3
同じものが、もう一度出ました。 RabbitMQ なら、1回目で消えています。 2回目は何も出ません。
これが「読んでも消えない」の意味です。 ここまでは、まだ準備運動です。
⑤ 同じメッセージを、意図的にもう一度読む
さっきのは「毎回頭から読んだ」だけで、実務では使えません。 実際のワーカーは、続きから読む必要があります。
続きから読むために「どこまで読んだか」を記録する。 記録する単位が、コンシューマーグループです。
グループを付けて読む
Offset:0 order-1
Offset:1 order-2
Offset:2 order-3
Ctrl+C で抜けます。 そして、同じコマンドをもう一度打ってください。
(何も出ない)
今度は何も出ませんでした。
--group mailerを付けたことで、「mailer は 2 番まで読んだ」がブローカーに記録されたからです。--from-beginningは「記録が無いときだけ」効きます。 記録があれば、その続きから読みます。
Ctrl+C で抜けます。
いま、どこを読んでいるか
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件をもう一度処理したい」を、やります。
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 を全部止めてから打ってください。
もう一度、同じ読み方をします。
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 -100 | 100件だけ戻す |
--to-datetime 2026-09-11T00:00:00.000 | その時刻以降の最初のものへ。 「昨日の分をやり直す」はこれです |
--to-latestは、事故を止めるときの手です。 壊れたメッセージが大量に溜まって処理が進まないとき、「読まなかったことにして追いつく」ができます。 RabbitMQ で同じことをしようとすると、キューごと消すしかありませんでした。
オフセットは、どこに書かれているのか
ブローカーが特別な場所に持っているわけではありません。
__consumer_offsets
orders
__consumer_offsetsという、Kafka 自身のトピックに書かれています。 「どこまで読んだか」もまた、追記されていく出来事の1つとして扱われているわけです。compose.yamlのKAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1は、このトピックを何台に複製するかの設定でした。既定の 3 のままだと、1台構成では作れずに詰まります。
⑥ コンシューマーグループ —— 分担と、同報
もう1つのトピックを、分割ありで作ります。
同じグループなら、分担する
ターミナルを3つ使います。 VS Code のターミナルを分割しても構いません。
ターミナル①(グループ worker)
ターミナル②(同じグループ worker)
ターミナル③(送る側)。キーを付けて送ります(1:e1 の : の左がキー。キーで行き先のパーティションが決まります。詳しくは⑦)。 キーを付けずにまとめて送ると、Kafka 2.4 以降の既定では数件が同じパーティションにまとまって入るため、片方のターミナルにしか出ないことがあります。
①と②に、バラバラに出ます。(どのパーティションがどちらに割り当たるか、行の並ぶ順は、実行によって変わります)
(片方のターミナル)
Partition:0 e1
Partition:1 e4
Partition:0 e5
Partition:1 e6
(もう片方のターミナル)
Partition:2 e2
Partition:2 e3
同じメッセージは、どちらか一方にしか出ません。 これが「分担」です。 仕事を分けたいなら、グループ名を揃える。 RabbitMQ でワーカーを2本立てたときと、外から見た挙動は同じです。
別のグループなら、両方に届く
ターミナル②を Ctrl+C で止めて、グループ名だけ変えて立て直します。
ターミナル③から、もう一度送ります。
今度は、①にも②にも、同じ3件が出ます。
[スクリーンショット: 03_コンシューマーグループ.png] worker と audit の2つのコンシューマーに、同じメッセージが両方出ているところを、2画面が並んだ状態で撮ってください。
Ctrl+C で両方止めます。
何が起きたか
┌──────────────┐
送る側 ─────────→│ events │
└──────────────┘
↓ ↓
group=worker group=audit
(2人で分担) (全部読む)
グループが違えば、オフセットも別々に持ちます。 お互いの存在を知りません。
これが効くのは、こういうときです。
| やりたいこと | どうする |
|---|---|
| 処理が追いつかない | 同じグループで、コンシューマーを増やす |
| 「注文が入った」で、別のこともやりたくなった | 新しいグループで、同じトピックを読む |
| その新機能で、過去の分も処理したい | 新しいグループなので、--from-beginning で頭から読める |
3行目が、Kafka を使う一番の理由です。 あとから来た読み手が、過去に遡れる。 送る側は、何も変えなくていい。送る側と読む側が、時間の面でも切り離されています。
コンシューマーは、パーティションより多くしても無駄
さっきのトピックはパーティションが3本でした。 同じグループでコンシューマーを4つ立てるとどうなるか。
4つ目は、何も割り当てられず、ずっと暇なままです。
1つのパーティションは、同じグループの中で1人しか読めません。 順序を守るためです。
つまり、パーティション数が「同じグループで並列に処理できる上限」です。 あとから増やせますが、減らせません。 そして増やすと、⑦の話が壊れます。
⑦ パーティション —— 順序が守られるのは、中だけ
ここを誤解すると、静かに壊れます。
実物を見る
バインドマウントにしたので、ホスト側からファイルが見えます。
events-0
events-1
events-2
orders-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 は、メッセージにキーを付けると、そのキーのハッシュでパーティションを決めます。 同じキーは、必ず同じパーティションに行きます。
読んで確かめます。
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 は、時間かサイズの上限で、古いほうから消します。
いまの設定を見ます。
| 設定 | 既定値 | 意味 |
|---|---|---|
retention.ms | 604800000(7日) | これより古いものは消す |
retention.bytes | -1(無制限) | パーティションがこのサイズを超えたら、古いほうから消す |
segment.bytes | 1073741824(1GB) | ログを何バイトごとに別ファイルに区切るか |
既定は7日です。 「1か月前のデータをやり直したい」は、設定を変えていなければできません。
retention.bytesも併せて設定してください。 時間だけ決めていると、想定より流量が増えたときにディスクが埋まります。 Lokiの回で書いた「保持期間を忘れるとディスクが減り続ける」と、まったく同じ話です。
短くして、消えるところを見る
1分ほど待ってから、一番古いオフセットを見ます。
orders:0:3
一番古いオフセットが
0ではなく3になりました。 0〜2 は、もうありません。 オフセットの番号は詰められません。 消えた分は、欠番になるだけです。
segment.bytes=200を一緒に指定したのには理由があります。 Kafka は、いま書き込み中のファイル(アクティブセグメント)を絶対に消しません。 ファイルを区切らないと、何日経っても1件も消えません。 「保持期間を過ぎたのに減らない」の原因は、ほぼこれです。 本番でこんな小さい値にはしません(200バイトごとにファイルが増えます)。
元に戻します。
「消したくない出来事」を Kafka に置きっぱなしにするのは、間違いです。 Kafka は、通り道です。 残すべきものは、読んだ側がデータベースに書きます。
⑨ 背圧 —— 読む側が遅いと、どうなるか
送る速さより、読む速さが遅い。 これは必ず起きます。そのとき何が起こるかが、RabbitMQ と Kafka で正反対です。
Kafka の場合 —— 溜まる
溜まっているかどうかは、⑤で見た LAG で分かります。
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 が固まります。
どちらが良いのか
| Kafka | RabbitMQ | |
|---|---|---|
| 溜まる場所 | ディスク | メモリ(あふれるとディスクへ退避) |
| 溜まりすぎたとき | 送る側は影響を受けない(ディスクが尽きるまで) | 送る側が止まる(フロー制御) |
| 限界に来たら | ディスク満杯でブローカーが停止 | 送る側が固まる |
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枚の表にします。
| RabbitMQ | Kafka | |
|---|---|---|
| 一言で | 仕事を配る | 出来事を記録する |
| 中身 | キュー(取り出すと消える) | ログ(追記だけ。消えない) |
| 「どこまで」を持つのは | ブローカー | 読む側(オフセット) |
| やり直し | できない | オフセットを戻すだけ |
| 読み手を増やす | 分担のみ | 分担も同報も、グループ名だけで切り替わる |
| 順序 | 1つのキューの中で保証(ただし複数ワーカーなら追い越す) | 1つのパーティションの中だけ |
| メッセージごとの再試行 | できる(1件だけ nack して DLQ へ) | 苦手。 1件だけ飛ばすのは、自分で書く |
| 溜まったとき | 送る側が止まる | 溜まり続ける |
| メモリ | 130MB 前後 | 600MB 前後 |
| 1台で動くか | 動く | 動くが、本来は3台以上を前提にした設計 |
選び方は、この2問だけ
| 問い | 答え |
|---|---|
| 「これをやっといて」と、誰か1人に頼みたいか | → RabbitMQ |
| 「こういうことが起きた」を、誰が読むか分からないまま置いておきたいか | → Kafka |
具体例で並べます。
| やりたいこと | 向いているのは |
|---|---|
| メール送信、画像変換、PDF生成 | RabbitMQ(1回やれば終わり。やり直したくもない) |
| 決済処理のような、1件ずつ丁寧に再試行したい仕事 | RabbitMQ(DLQ が要る) |
| アクセスログ、クリック、センサーの値 | Kafka(大量。あとで何に使うか分からない) |
| 「注文が入った」を、複数のサービスが別々に使う | Kafka(読み手が増えても送る側を変えない) |
| データベースの変更を、他のシステムに配る | Kafka(レプリケーションと同じ発想) |
そして、個人のサービスには重すぎます
正直に書きます。
個人で作るサービスに、Kafka はまず要りません。
理由は、性能ではなく、割に合わなさです。
| 増えるもの | 具体的に |
|---|---|
| メモリ 600MB | 1台の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 established | Kafka がまだ起動中。 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. しばらく使わないだけなら、止めるだけ。
次に使うときは docker compose start です。 トピックもメッセージもオフセットも残ります。
3. 完全に消すとき。
-vだけでは、この記事のデータは消えません。-vが消すのは「名前付きボリューム」です。 この記事ではバインドマウント(./data)にしたので、中身は~/kafka/dataにそのまま残ります。 これはバインドマウントの利点でもあり、落とし穴でもあります。 Composeの回で見たdownとdown -vの違いに、もう1段あったわけです。
中身も消すなら、手で消します。
Permission deniedが出たらsudo rm -rf ~/kafka/dataです。 コンテナの中のユーザーが書いたファイルだからです。
4. イメージも消して、ディスクを戻します。
apache/kafkaのイメージは 400MB ほどあります。
5. 止めていたものを、戻します。
②で止めたものを戻すのを忘れないでください。 「あの環境、なぜか動かない」の原因になります。
まとめ
- Kafka はキューではなくログ。 読んでも消えない。 消えるのは保持期間が来たときだけ
- 「どこまで読んだか」を持っているのは、ブローカーではなく読む側。それがオフセットという数字
- だから、数字を戻せばもう一度読める。 RabbitMQ では原理的にできなかったこと
- オフセットはコンシューマーグループ単位。 グループが違えば、互いを知らない
- 同じグループなら分担、別グループなら両方に届く。 「増やす」と「配る」が、名前1つで切り替わる
- あとから来た読み手が、過去に遡れる。 送る側を1行も変えずに。 これが Kafka を使う最大の理由
- 順序が守られるのはパーティションの中だけ。 トピック全体の順序は保証されない
- 順序が大事なものには、キーを付ける。 同じキーは同じパーティションに入る
- パーティション数は増やせるが減らせない。 増やすとキーの割り当てが変わり、順序の保証が切れる
- コンシューマーは、パーティション数より多くしても暇なだけ
- 保持期間は既定7日。 永久ではない。 残すものは、読んだ側がデータベースへ書く
- アクティブセグメントは消えない。 「保持期間を過ぎたのに減らない」の原因はほぼこれ
- 読む側が遅いとき、Kafka は溜まるだけ。 止まらないので、
LAGを自分で見張る - RabbitMQ は逆に、溜まると送る側を黙って止める。 どちらが良いかではなく、性格が違う
- 1台の Kafka は、Kafka の強みをほぼ捨てている。 学習用と割り切る
- KRaft を使う。 ZooKeeper が出てくる手順書は、いま読むべきものではない
- そして、個人のサービスに Kafka はまず要らない。 テーブルに追記して位置を持つ、で足ります
参考リンク
- roadmap.sh — Backend(Message Brokers の項目)
- Apache Kafka 公式ドキュメント
- Apache Kafka — Introduction
- Apache Kafka — Design
- Apache Kafka — KRaft
- Apache Kafka — Topic Configs
- Apache Kafka — Quickstart
- Docker Hub — apache/kafka
- Kafka Streams 入門
次に読む
この記事は 【第8段階】深掘り の 10 / 30 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | 書いた直後に読むと無い — レプリケーションとCAP |
| → 次の記事 | 落ちても全部は止めない — サーキットブレーカと縮退 |
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- Kafka — 読んでも消えないログ型のキュー
- ストリーム処理と背圧(バックプレッシャ)
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント